深拷贝和浅拷贝

深浅拷贝的区分

浅拷贝：拷贝的是引用地址，当引用的值改变时，另外一个也会跟着改变;

浅拷贝是新旧对象还是共享同一块内存，改变其中一个，另一个也会受影响，。

 

深拷贝：复制出一个全新的对象实例，新对象跟原对象不共享内存，两者操作互不影响

 

深拷贝和浅拷贝的使用场景是在复杂对象里，复杂数据类型里：object,array,funtion

 

常用的浅拷贝实现方法

1，Object.assign

ES6中拷贝对象的方法，接受的第一个参数是拷贝的目标target，剩下的参数是拷贝的源对象sources（可以是多个）

let target = {};
let source = {
    a: '123',
    b: {name: 'javascript'}
}
Object.assign(target,source);
console.log(target); // {a:'123',b:{name:'javascript'}}

Object.assign使用注意事项：

• 只拷贝源对象的自身属性（不拷贝继承属性）
• 不会拷贝对象不可枚举的属性
• undefined和null无法转成对象，他们不能作为Object.assign参数，但是可以作为源对象
• 属性名为Symbol 值的属性，可以被Object.assign拷贝

let copy2 = Object.assign({}, {x:1})

 

2，Array.slice

let array = [{a:1},{b:2}]
let array1 = array.slice(0);
console.log(array1)

slice:从已有的数组中返回选定的元素

3，扩展运算符

let obj = {a:1,b:{c:1}}
let obj2 = {...obj}
console.log(obj2)

 参考：https://blog.csdn.net/weixin_42246997/article/details/107341725

 

二，实现深拷贝

// 1. JOSN.stringify()/JSON.parse()
let obj = {a: 1, b: {x: 3}}
JSON.parse(JSON.stringify(obj))
 
// 2. 递归拷贝
function deepClone(obj) {
  let copy = obj instanceof Array ? [] : {}
  for (let i in obj) {
    if (obj.hasOwnProperty(i)) {
      copy[i] = typeof obj[i] === 'object' ? deepClone(obj[i]) : obj[i]
    }
  }
  return copy
}

 

三，实现深浅拷贝

    // 浅拷贝实现
    function shallowCopy(obj) {
        var dst = {}
        for (var prop in obj) {
            if (obj.hasOwnProperty(prop)) {
                dst[prop] = obj[prop]
            }
        }
        return dst
    }

    var obj = { a: 1, arr: [2, 3] }
    var shallowObj = shallowCopy(obj)
    console.log(shallowObj.arr[1])

    shallowObj.arr[1] = 5;
    console.log(obj.arr[1])

    // 赋值
    let a = { 'name': '1111', 'age': 'dddd'}
    let b = a;
    b.name = 22;
    console.log(a)
    // 浅拷贝{name: 22, age: "dddd"}


    // 深拷贝：拷贝实例
    
    function deepCopy(obj) {
        if (obj instanceof Array) {
            let n = [];
            for (let i = 0; i < obj.length; i++) {
                n[i] = deepCopy(obj[i])
            }
            return n;
        } else if (obj instanceof Object) {
            let n = {};
            for (let i in obj) {
                n[i] = deepCopy(obj[i])
            }
            return n;
        } else {
            return obj
        }
    }
    var obj2 = { a: 1, arr: [2, 3] }
    var deepObj = deepCopy(obj2)
    console.log('深拷贝', deepObj.arr[0])
    deepObj.arr[1] = 6;
    console.log('深拷贝' + obj2.arr[0])

    // 深拷贝：通过JSON解析实现
    // 把一个对象转成json字符串在转成json对象
    let obj3 = { 'a': 1, 'b': 2 }
    JSON.parse(JSON.stringify(obj3))

    // 参考：https://www.imooc.com/article/68975