拓展运算符...,JSON,for in递归拷贝对象的区别

一.拓展运算符...

let obj = {a:1,b:2}
let obj2 = {...obj}

拓展运算符...拷贝是深拷贝,其实这个是不准确的,因为当被拷贝的对象是一维对象(即对象里面没有包含对象)时,确实可以当做是深拷贝,原对象改变,Obj2不受影响,但是当对象是多维时

let obj = {
    a:1,
    b:2,
    objs={ a:3 , b:4 }
}
let obj2 = {...obj}
obj.a = 5
console.log(obj2)    //不受影响 { a: 1, b: 2, objs: { a: 3, b: 4 } }
obj.objs.a = 10
console.log(obj2)    //受影响 { a: 1, b: 2, objs: { a: 10, b: 4 } }

从这里可以看出,拓展运算符并没有实现完全的深拷贝,对于多维而言,依旧留存了内部对象的引用地址的形式

二.JSON拷贝 如果我们需要对多维数组进行深拷贝,不妨利用JSON来进行拷贝,即

let obj = {
    a:1,
    b:2,
    objs={ a:3 , b:4 }
}
let obj2 = JSON.parse(JSON.stringfly(obj))

这种拷贝,就是完全的深拷贝了

三.for in 拷贝

(1).首先基础的for in

let obj = {
	name:'小明',
    friend:'小红',
    game:{
    	one:'LOL',
        two:'Jx3'
    }
}

let newObj = {}

for ( let i in obj ){
	newObj[i] = obj[i]
}

obj.name = '改变'
obj.game.one = '改变'

console.log(newObj)	//{ name: '小明', friend: '小红' , game: { one: '改变', two: 'JX3' }}

这种,也是一样和拓展运算符的诟病,当只有一层的时候确实可以深拷贝,但是如果对象里面含有对象,name里面的对象依旧是浅拷贝,所以我们就可以用到递归

递归是什么?

递归就是自己调用自己

let obj = {
    name: 'out',
    friend: {
        name: 'in',
        age: '16'
    }
}


function fn(obj) {
    let newObj = {}
    for (let index in obj) {
        if (obj[index] instanceof Object) {
            let o = fn(obj[index])
            newObj[index] = o
        }else{
            newObj[index] = obj[index]
        }
    }
    return newObj
}

let result = fn(obj)
obj.name = '修改'
obj.friend.name= '修改'

console.log(obj)
console.log(result)

{ name: '修改', friend: { name: '修改', age: '16' } }
{ name: 'out', friend: { name: 'in', age: '16' } }

这样边顺利的完成了深拷贝