什么是深浅

观点

深拷贝、浅拷贝只针对像Object/Array如许的对象，关于基础范例而言，能够理解为是没有深浅的区分的。

浅拷贝复制的是援用，修正对象的属性，会相互影响。

just like this

let a = {name: 'ziv'}
let b = a // a和b指向了统一块内存
b.name = 'lucky'
console.log(a.name) // 'lucky'
console.log(b.name) // 'lucky'

深拷贝从新拓荒了一个空间，修正对象的属性，相互不会影响。

完成浅拷贝

运用内置的要领

// Object.assign()
//只能用于浅拷贝对象或许兼并对象
let obj = {a:'x', b: {c: 'y'}}
let newObj = Object.assign({}, obj)
obj.b.c = 'z'
console.log(newObj) // {a:"x", b: {c: "z"}}

// Array.from() 
// ...操作符
// slice()
// concat() 用于数组

let arr = [1,2, [3,4,5]]
let sliceArr = arr.slice()
let concatArr = arr.concat()
let fromArr = Array.from(arr)
let newArr = [...arr]

arr[2][1] = 'sixsix'

console.log(sliceArr) // [1,2,[3,'sixsix',5]]
console.log(concatArr) // [1,2,[3,'sixsix',5]]
console.log(fromArr) // [1,2,[3,'sixsix',5]]

运用遍历

// 对象浅拷贝
let shallowCopy = function(obj) {
    // 假如不是对象，不实行拷贝
    if (typeof obj !== 'object') return 
    // 推断对象是数组照样对象
    let newObj = obj instanceof Array ? [] : {}
    // 遍历obj
    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            // 拷贝到新对象中
            newObj[key] = obj[key]
        }
    }
    return newObj
}

完成深拷贝

序列化反序列化

// 适用于数组另有对象，然则关于函数对象、正则对象、希罕数组等没法举行深拷贝（而且会直接丧失响应的值），并且会扬弃对象的constructor，也就是说不管这个函数的组织函数是谁，运用这类拷贝以后，constructor都邑变成Object。对轮回援用一样没法处置惩罚。
let arr = ['old', 1, true, ['old1', 'old2'], {old: 1}]

let new_arr = JSON.parse(JSON.stringify(arr))
arr[3][0] = 'new1' // new_arr并不会变动
console.log(new_arr) 

运用递归

// 适用于对象内里有对象
let deepCopy = function(obj) {
    if (typeof obj !== 'object') return obj
    let newObj = obj instanceof Array ? [] : {}
    
    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            newObj[key] = typeof obj[key] === 'object' ? deepCopy(obj[key]) : obj[key]
        }
    }
    return newObj
}