深拷贝&浅拷贝

数据类型：基本数据类型，和引用数据类型。

        基本数据类型的特点：直接存储在栈 (stack) 中的数据

        引用数据类型的特点：存储的是该对象在栈中引用，真实的数据存放在堆内存里，引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。

赋值和浅拷贝：

1.对象赋值：将一个对象赋值给一个新的对象时，赋的其实是对象的地址，而不是数据，两者的改变会互相影响，不管改变的是基础类型还是引用类型的值。

2.浅拷贝:浅拷贝会创建一个对象，再去遍历对象的原始对象，如果拷贝的是基础类型，那么就拷贝基础类型的值，如果拷贝的是引用类型，那么拷贝的是地址，如果改变新的对象那么原来的对象也会被改变。 浅拷贝的语法糖Object.assgin(新的对象，需要拷贝的对象)

3.深拷贝：深拷贝会对基本类型和引用类型的每一级数据都拷贝，如果改变新对象的值那么原来被拷贝的对象不会跟着改变。

实现深拷贝：

   // 递归实现深拷贝
        // 方法1:遍历对象，数组，如果是基本类型则赋值，如果是引用类型则递归调用
        var obj={
            name:"test",
            main:{
                a:1,b:2
            },
            fn:function(){

            },
            friends:[1,2,3,[22,23]]
        }
        function copy(obj){
            let newobj=null
            // 判断必须是对象且不为null,如果不是对象或为null，则newobj直接赋值
            if(typeof(obj)=='object'&&obj!=null){
                // 判断是数组还是对象进行赋值空对象或空数组
                newobj=obj instanceof Array?[]:{}
                console.log(newobj)
                for(let i in obj){
                    newobj[i]=copy(obj[i])

                }
            }else{
                // 基本类型直接赋值
                newobj=obj
            }
            return newobj
        }
        var obj2 = copy(obj)
        obj2.name = '修改成功'
        obj2.main.a = 100
        console.log(obj)
        console.log(obj2)

 // 方法2:遍历对象，数组，如果是基本类型则赋值，如果是引用类型则递归调用
        var obj={
            name:"test",
            main:{
                a:1,b:2
            },
            fn:function(){

            },
            friends:[1,2,3,[22,23]]
        }
        function deepCopy(target){
            if( typeof target ==='object' ){
                const newTarget=Array.isArray(target)?[]:Object.create(null)
                for(let tar in target){
                    newTarget[tar]=deepCopy(target[tar])
                }
                return newTarget
            }else{
                return target
            }
        }
        const obj2=deepCopy(obj)
        obj2.name='我是修改'
        console.log(obj)
        console.log(obj2)

//  方法3：哈希表map支持循环引用
        function deepCopy(target,h=new Map){
            if(typeof target==='object'){
                if(h.has(target)) return h.get(target)
                const newTarget=Array.isArray(target)?[]:Object.create(null)
                for(let key in target){
                    newTarget[key]=deepCopy(target[key],h=new Map)
                  
                }
                // h中添加键值对都是target和newtarget
                h.set(target,newTarget)
                
                console.log(h)
                return newTarget
            }else{
                return target
            }
        }

 // 方法4：哈希表 WeakMap 代替 Map  WeakMap 的键是弱引用，告诉 JS 垃圾回收机制，当键回收时，对应 WeakMap 也可以回收，更适合大量数据深拷
        function deepCopy(target, h = new WeakMap) {
        if (typeof target === 'object') {
              if (h.has(target)) return h.get(target)
              const newTarget = Array.isArray(target) ? [] : Object.create(null)
             for (const key in target) {
              newTarget[key] = deepCopy(target[key], h)
             }
            h.set(target, newTarget)
             return newTarget
         } else {
             return target
                }
         }

作者：LeetCode
链接：https://leetcode.cn/leetbook/read/interview-coding-frontend/dq2eot/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。