# 浅拷贝与深拷贝

# 浅拷贝

  • Object.assign
  • 展开运算符

# 深拷贝

  • JSON.parse(JSON.stringify(object))
let a = {
    age: 1,
    jobs: {
        first: 'FE'
    }
}
let b = JSON.parse(JSON.stringify(a))
a.jobs.first = 'native'
console.log(b.jobs.first) // FE 修改a更深的值不会改变b
1
2
3
4
5
6
7
8
9
  • 局限性
    • 会忽略 undefined
    • 不能序列化函数
    • 不能解决循环引用的对象
var obj={
            id:1,
            name:'andy',
            msg:{age:18}
        }
        function deepCopy(newObj,oldObj){
            for (key in oldObj){
                //获取对象属性
                var item=oldObj[key];
                if(item instanceof Array){
                    //1.判断是否是数组
                    newObj[key]=[];
                    deepCopy(newObj[key],item);
                } else if(item instanceof Object){
                    //2.判断是否是对象
                    newObj[key]={};
                    deepCopy(newObj[key],item);
                }else{
                    //3.其余为简单类型数据
                    newObj[key]=item;
                }
            }
        }
        var o_copy={};
        // Object.assign(o_copy,obj);
        deepCopy(o_copy,obj);
        o_copy.msg.age=20;
        console.log(obj);
        console.log(o_copy);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
function deepCopy(obj){
            var result;
            if(Object.prototype.toString.call(obj)=='[object Array]'){
                //若对象为数组(数组转为字符串为'[object Array]')
                result=[];
                for(i=0;i<obj.length;i++){
                    result[i]=deepCopy(obj[i]);
                }
            }else if(Object.prototype.toString.call(obj)=='[object Object]'){
                //若对象为对象(对象转为字符串为'[object Object]')
                result={}
                for(var attr in obj){
                    result[attr]=deepCopy(obj[attr]);
                }
            }else{
                result=obj;
            }
            return result;
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19