Implementation of deep copy deepclone

 encapsulation 
export function deepclone (obj) {
    
  var o
  //  If   He is the object object Words  ,  because null,object,array  It's also 'object';
  if (typeof obj === 'object') {
    
    //  If   If he is empty 
    if (obj === null) {
    
      o = null
    } else {
    
      //  If   He's an array arr Words 
      if (obj instanceof Array) {
    
        o = []
        for (var i = 0, len = obj.length; i < len; i++) {
    
          o.push(deepclone(obj[ i ]))
        }
      }
      //  If   He is the object object Words 
      else {
    
        o = {
    }
        for (var j in obj) {
    
          if (j != 'root' && j != 'parent') {
    
            o[ j ] = deepclone(obj[ j ])
          }
        }
      }
    }
  } else {
    
    o = obj
  }
  return o
};

1、 Deep copy ： The result changes after copying will not affect the results before copying It doesn't matter before or after copying
2、 Shallow copy ： Change the content before copying , It will affect the copy There is a relationship between pre copy and post copy

//  The problem of citation relationship  
// ... Operators can only copy one layer 
// ...  The first layer is deep copy , The second time is shallow copy .
let obj={
    name:'jim',address:{
    x:100,y:100}};
let o={
    ...obj};
obj.name='hello';
console.log(obj,o);
 
let a=[1,2,4];
let arr=[a];
let newArr=arr.slice();  //  Shallow copy 
newArr[0][0]=100;
console.log(arr);

3、 Deep copy JSON.parse(JSON.stringify(obj)); Incomplete Complex copies cannot be achieved

let obj={
    name:'jim',address:{
    x:100,y:100},f:function(){
    }};
let o=JSON.parse(JSON.stringify(obj));
obj.address.x=200;
console.log(obj,o);

4、 Implement a deep copy Implement a recursive copy

function deepClone(obj,hash=new WeakMap()){
    
    if(obj==null) return obj;   // If it is null  perhaps undefined  I don't copy 
    if(obj instanceof Date) return new Date(obj);
    if(obj instanceof RegExp) return new RegExp(obj);
    // It could be an object   Or ordinary value   If it's a function , There is no need for deep copy   Because functions are used to call , There is no need to copy a new function 
    if(typeof obj!=='object') return obj;
    //  If it's an object, it's a deep copy  [] {} Object.prototype.toString.call(obj)==[object Array]?[]:{}
    if(hash.get(obj)) return hash.get(obj);
 
    let cloneObj=new obj.constructor;
    hash.set(obj,cloneObj);
    for(let key in obj){
    
        if(obj.hasOwnProperty(key)){
    
            // Implement a recursive copy 
            cloneObj[key]=deepClone(obj[key],hash);
        }
    }
    return cloneObj;
}
let obj={
    name:1,address:{
    x:1000}}
let d=deepClone(obj);
obj.address.x=200;
console.log(d);
//  If the object is more complex   Circular reference