使用js實現復制功能

function cloneObject(source,target){
    if(source === null||source === undefined) return source;
    if(source===document) return;
    //判斷target是不是繼承對象的實例,是不是引用類型(null,undefined,Boolean,string,number都不是引用類型)
    if(!Object.prototype.isPrototypeOf(target)){
        //判斷源對象是不是dom元素
        if(HTMLElement.prototype.isPrototypeOf(source)){
            //創建dom元素
             target = document.createElement(source.nodeName);
        }else if(source.constructor === RegExp){
            // 任何正則表達式都有source和flags，source是正則內容,flags是正則修飾符
            // 因為這兩個屬性都是隻讀屬性，不能寫入，必須通過構造函數創建時帶入
            target = new RegExp(source.source,source.flags);
        }else if(source.constructor === Date){
            // 日期對象在創建的對象中將原有的日期對象放入，可以讓當前日期對象變為原有日期對象的值，但是沒有引用關系
            targer = new Date(source);
        }else if(source.constructor === Function){
            // 復制函數，通過正則表達式將函數中的參數以及函數體內容提取到數組中，然後通過new Function()創建
            var arr = source.toString().replace(/\n|\r/g,"").trim().match(/\((.*?)\)\s*\{(.*)\}/).slice(1);
            target = new Function(arr[0].trim(),arr[1]);
        }else if(source.constructor === Set){
            // set類型，在處理時，new Set時可以帶入數組，因此我們將原有set的列表強轉為數組，並且將這個強轉後的數組復制給新數組
            target = new Set(cloneObject(Array.from(source.values())));
        }else if(source.constructor === Map){
            target = new Map();
            // 如果是map類型，遍歷map中每個元素
            for(var [key,value] of source.entries()){
                // 如果key是引用類型，
                if(Object.prototype.isPrototypeOf(key)){
                     // 如果value引用類型，則將key和value分別做復制，並且將返回的結果放在map中
                    if(Object.prototype.isPrototypeOf(value)){
                        target.set(cloneObject(key),cloneObject(value));
                    }else{
                         //如果value不是引用類型，隻將key復制，並且放入map
                        target.set(cloneObject(key),value);
                    }
                }else{
                    // 這是key不是引用類型時
                    if(Object.prototype.isPrototyeOf(value)){
                        target.set(key,cloneObject(value));
                    }else{
                        target.set(key,value);
                    }
                }
            }
        }
        else{
        //除瞭null和undefined，其他類型都有constructor。任何對象的constructor都是它的類型,利用其constructor創建對象
        //通過對象類型的反射創建新的同類型對象
            target = new source.constructor();
        }
        
    }
    //獲取對象的所有字符屬性名和Symbol屬性名的數組
    var names = Object.getOwnPropertyName(source).concat(Object.getOwnPropertySymbols(source));
    for(var i = 0;i < names.lenght; i++){
        // 如果當前復制的是函數，並且這個函數的屬性是prototype，那麼這個屬性不復制，否則會死循環
        if(source.constructor === Function&&names[i] === "prototype")
            continue;
        // 獲取當前屬性名的描述對象
        var desc = Object.getOwnPropertyDescriptor(source,names[i]);
        //   這個描述對象的值如果是引用類型
        if(Object.prototype.isPrototypeOf(desc.value)){
             // 根據需要將源對象的描述內容設置給當前目標對象相同屬性名的描述內容,及值付為剛才創建相同類型的對象
            Object.defineProperty(target,names[i],{
                enumerable:desc.enumerable,
                configurable:desc.configurable,
                writable:desc.writable,
                value:cloneObject(desc.value)
            });
        }else{
             //如果描述的對象的值不是引用類型，直接將描述對象設置給目標對象的這個屬性
            Object.defineProperty(target,names.desc);
        }
    }
    return target;
}


//原型.isPrototypeOf(對象)。對象裡面是不是擁有xx的原型
//反射:通過對象

var obj={
    a:1,
    b:3,    //ab復制不會隨其中一個的變化而變化
    c:{        //c復制會隨其中一個的變化而變化,因為c屬於對象的地址引用關系
        d:10,
        e:20
    }
};
var o1 = JSON.parse(JSON.stringify(obj)); //將obj復制給o1

var obj = {
a:1,
b:2,
c:{
        a:1,
  b:2,
  c:{
            a:1,
      b:2,
      }
}
}
//函數定義參數時，註意必要參數寫在前面，非必要參數寫在後面
function cloneObj(source,target){
    if(target === undefined) target = {};
for(var prop in source){
  //如果
        if(typeof source[prop] === "object" && source[prop] != null){
      target[prop] = {};
      cloneObj(source[prop],target[prop]);
  }else{
            target[prop] = source[prop];
  }
}
return target;
}