深拷贝与浅拷贝

浅拷贝：只拷贝一层基本类型数据，遇见引用类型还是复制的地址，所以拷贝后的数据 和 拷贝前的数据，还存在共用同一个地址的属性，此时拷贝并不彻底，两份数据还会相互影响，所以叫浅拷贝
深拷贝：完整的把数据的任意层级属性和值拷贝到新数据上，拷贝前后的两个数据完全一样，但是是不同的地址，相互不会影响。

let obj = { a: 1, b: 2, c: 3, d: { dd: 44 } }

// 两个变量指向同一个地址空间 不是拷贝
let obj1 = obj

// Object.assign是语言提供的浅拷贝方法，把第二个参数开始的数据的属性都拷贝到第一个参数上
// let obj2 = Object.assign({}, obj, obj1, obj2)

// 浅拷贝: 拷贝原数据 到新的数据上，但是只是复制一层数据，对于数据项如果是引用类型，那么还是复制的地址，
// 所以拷贝后的数据 和 拷贝前的数据，还存在共用同一个地址的属性
// let obj3 = {}
// for (let key in obj) {
//  console.log('key-value: ', key, obj[key])
//  obj3[key] = obj[key]
// }

// 深拷贝

// source 待拷贝的源数据
// 不完善的版本 不支持数组
function cloneDeep(source) {
    const ret = {}

    for (let key in source) {
        console.log('key-value: ', key, source[key])
        if (typeof source[key] == 'object') {
            ret[key] = cloneDeep(source[key])
        } else {
            ret[key] = source[key]
        }
    }

    console.log('ret: ', ret)
    return ret
}

// const obj4 = cloneDeep(obj)

let arr1 = [1, 2, 3, 4, [55, 66, 77], { a: 1 }]
function cloneDeep1(source) {
    // 获取被拷贝的数据的类型
    let type = Object.prototype.toString.call(source).slice(8, -1)

    let ret = {}

    // 如果被拷贝的数据是一个数组，ret赋值为空数组
    if (type === 'Array') {
        ret = []
    }

    if (type === 'Object') {
        for (let key in source) {
            // console.log('key-value: ', key, source[key])
            if (typeof source[key] == 'object') {
                ret[key] = cloneDeep1(source[key])
            } else {
                ret[key] = source[key]
            }
        }
    } else if (type === 'Array') {
        for (let i = 0; i < source.length; i++) {
            if (typeof source[i] === 'object') {
                ret[i] = cloneDeep1(source[i])
            } else {
                ret[i] = source[i]
            }
        }
    }

    // console.log('ret: ', ret)
    return ret
}

const arr2 = cloneDeep1(arr1)