基于模板克隆对象。如果您不想要精确的副本，但确实想要某种可靠的克隆操作的健壮性，但您只想要克隆位，或者希望确保可以控制每个属性值的存在或格式，该怎么办？

我之所以这么做，是因为它对我们有用，我们之所以创建它，是因为我们找不到类似的东西。您可以使用它来基于模板对象克隆对象，该模板对象指定了要克隆的对象的属性，如果源对象上不存在这些属性，或者您希望如何处理克隆，则模板允许函数将这些属性转换为不同的属性。如果没有用，我相信有人可以删除这个答案。

   function isFunction(functionToCheck) {
       var getType = {};
       return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
   }

   function cloneObjectByTemplate(obj, tpl, cloneConstructor) {
       if (typeof cloneConstructor === "undefined") {
           cloneConstructor = false;
       }
       if (obj == null || typeof (obj) != 'object') return obj;

       //if we have an array, work through it's contents and apply the template to each item...
       if (Array.isArray(obj)) {
           var ret = [];
           for (var i = 0; i < obj.length; i++) {
               ret.push(cloneObjectByTemplate(obj[i], tpl, cloneConstructor));
           }
           return ret;
       }

       //otherwise we have an object...
       //var temp:any = {}; // obj.constructor(); // we can't call obj.constructor because typescript defines this, so if we are dealing with a typescript object it might reset values.
       var temp = cloneConstructor ? new obj.constructor() : {};

       for (var key in tpl) {
           //if we are provided with a function to determine the value of this property, call it...
           if (isFunction(tpl[key])) {
               temp[key] = tpl[key](obj); //assign the result of the function call, passing in the value
           } else {
               //if our object has this property...
               if (obj[key] != undefined) {
                   if (Array.isArray(obj[key])) {
                       temp[key] = [];
                       for (var i = 0; i < obj[key].length; i++) {
                           temp[key].push(cloneObjectByTemplate(obj[key][i], tpl[key], cloneConstructor));
                       }
                   } else {
                       temp[key] = cloneObjectByTemplate(obj[key], tpl[key], cloneConstructor);
                   }
               }
           }
       }

       return temp;
   }

一个简单的调用方法如下：

var source = {
       a: "whatever",
       b: {
           x: "yeah",
           y: "haha"
       }
   };
   var template = {
       a: true, //we want to clone "a"
       b: {
           x: true //we want to clone "b.x" too
       }
   }; 
   var destination = cloneObjectByTemplate(source, template);

如果您想使用函数来确保返回属性或确保它是特定类型，请使用这样的模板。我们提供了一个函数，它仍然只是复制源对象的ID属性，但它确保它是一个数字，即使它不存在于源对象上。

 var template = {
    ID: function (srcObj) {
        if(srcObj.ID == undefined){ return -1; }
        return parseInt(srcObj.ID.toString());
    }
}

数组可以很好地进行克隆，但如果您愿意，也可以使用自己的函数来处理这些单独的属性，并执行以下特殊操作：

 var template = {
    tags: function (srcObj) {
        var tags = [];
        if (process.tags != undefined) {
            for (var i = 0; i < process.tags.length; i++) {

                tags.push(cloneObjectByTemplate(
                  srcObj.tags[i],
                  { a : true, b : true } //another template for each item in the array
                );
            }
        }
        return tags;
    }
 }

所以在上面，我们的模板只复制源对象的标签属性（如果它存在的话）（假设它是一个数组），并且对该数组中的每个元素调用clone函数，根据第二个模板单独克隆它，该模板只复制这些标签元素的a和b属性。

如果您要将对象移入和移出节点，并且希望控制这些对象的哪些属性被克隆，那么这是在node.js中控制这些属性的一种很好的方法，代码也可以在浏览器中工作。

下面是它的用法示例：http://jsfiddle.net/hjchyLt1/

function clone(obj) {
    if(obj == null || typeof(obj) != 'object')
        return obj;    
    var temp = new obj.constructor(); 
    for(var key in obj)
        temp[key] = clone(obj[key]);    
    return temp;
}

2022年更新

有一个新的JS标准叫做结构化克隆。它可以在许多浏览器中工作（请参阅我可以使用）。

const clone = structuredClone(object);

旧答案

对JavaScript中的任何对象执行此操作都不简单或直接。您将遇到错误地从对象的原型中提取属性的问题，这些属性应该留在原型中，而不是复制到新实例中。例如，如果您要向Object.prototype添加一个克隆方法，如某些答案所示，则需要显式跳过该属性。但是，如果有其他添加到Object.prototype或其他中间原型的方法，您不知道，该怎么办？在这种情况下，您将复制不应该复制的属性，因此需要使用hasOwnProperty方法检测不可预见的非本地属性。

除了非枚举属性之外，当您尝试复制具有隐藏财产的对象时，还会遇到更困难的问题。例如，原型是函数的隐藏属性。此外，对象的原型被__proto__属性引用，该属性也是隐藏的，不会被for/in循环复制到源对象的属性上。我认为__proto__可能特定于Firefox的JavaScript解释器，在其他浏览器中可能会有所不同，但你可以理解这一点。并非所有事物都是可枚举的。如果知道隐藏属性的名称，可以复制它，但我不知道有什么方法可以自动发现它。

寻求优雅解决方案的另一个障碍是正确设置原型继承的问题。如果源对象的原型是object，那么只需使用｛｝创建一个新的通用对象就可以了，但是如果源对象原型是object的后代，那么您将丢失该原型中使用hasOwnProperty筛选器跳过的其他成员，或者这些成员在原型中，但最初不可枚举。一种解决方案可能是调用源对象的构造函数属性以获取初始复制对象，然后复制属性，但这样仍然无法获取不可枚举的属性。例如，Date对象将其数据存储为隐藏成员：

function clone(obj) {
    if (null == obj || "object" != typeof obj) return obj;
    var copy = obj.constructor();
    for (var attr in obj) {
        if (obj.hasOwnProperty(attr)) copy[attr] = obj[attr];
    }
    return copy;
}

var d1 = new Date();

/* Executes function after 5 seconds. */
setTimeout(function(){
    var d2 = clone(d1);
    alert("d1 = " + d1.toString() + "\nd2 = " + d2.toString());
}, 5000);

d1的日期字符串将比d2晚5秒。一种使一个Date与另一个Date相同的方法是调用setTime方法，但这是Date类特有的。我不认为这个问题有一个防弹的通用解决方案，尽管我很乐意错了！

当我不得不实现一般的深度复制时，我最终妥协了，假设我只需要复制一个普通的Object、Array、Date、String、Number或Boolean。最后3种类型是不可变的，所以我可以执行一个浅拷贝，而不用担心它会发生变化。我进一步假设Object或Array中包含的任何元素也将是该列表中的6种简单类型之一。这可以通过以下代码实现：

function clone(obj) {
    var copy;

    // Handle the 3 simple types, and null or undefined
    if (null == obj || "object" != typeof obj) return obj;

    // Handle Date
    if (obj instanceof Date) {
        copy = new Date();
        copy.setTime(obj.getTime());
        return copy;
    }

    // Handle Array
    if (obj instanceof Array) {
        copy = [];
        for (var i = 0, len = obj.length; i < len; i++) {
            copy[i] = clone(obj[i]);
        }
        return copy;
    }

    // Handle Object
    if (obj instanceof Object) {
        copy = {};
        for (var attr in obj) {
            if (obj.hasOwnProperty(attr)) copy[attr] = clone(obj[attr]);
        }
        return copy;
    }

    throw new Error("Unable to copy obj! Its type isn't supported.");
}

只要对象和数组中的数据形成一个树结构，上述函数就可以适用于我提到的6种简单类型。也就是说，对象中对同一数据的引用不超过一个。例如：

// This would be cloneable:
var tree = {
    "left"  : { "left" : null, "right" : null, "data" : 3 },
    "right" : null,
    "data"  : 8
};

// This would kind-of work, but you would get 2 copies of the 
// inner node instead of 2 references to the same copy
var directedAcylicGraph = {
    "left"  : { "left" : null, "right" : null, "data" : 3 },
    "data"  : 8
};
directedAcyclicGraph["right"] = directedAcyclicGraph["left"];

// Cloning this would cause a stack overflow due to infinite recursion:
var cyclicGraph = {
    "left"  : { "left" : null, "right" : null, "data" : 3 },
    "data"  : 8
};
cyclicGraph["right"] = cyclicGraph;

它将无法处理任何JavaScript对象，但只要您不认为它只适用于您向它抛出的任何东西，它就可以满足许多目的。

//
// creates 'clone' method on context object
//
//  var 
//     clon = Object.clone( anyValue );
//
!((function (propertyName, definition) {
    this[propertyName] = definition();
}).call(
    Object,
    "clone",
    function () {
        function isfn(fn) {
            return typeof fn === "function";
        }

        function isobj(o) {
            return o === Object(o);
        }

        function isarray(o) {
            return Object.prototype.toString.call(o) === "[object Array]";
        }

        function fnclon(fn) {
            return function () {
                fn.apply(this, arguments);
            };
        }

        function owns(obj, p) {
            return obj.hasOwnProperty(p);
        }

        function isemptyobj(obj) {
            for (var p in obj) {
                return false;
            }
            return true;
        }

        function isObject(o) {
            return Object.prototype.toString.call(o) === "[object Object]";
        }
        return function (input) {
            if (isfn(input)) {
                return fnclon(input);
            } else if (isobj(input)) {
                var cloned = {};
                for (var p in input) {
                    owns(Object.prototype, p)
                    || (
                        isfn(input[p])
                        && ( cloned[p] = function () { return input[p].apply(input, arguments); } )
                        || ( cloned[p] = input[p] )
                    );
                }
                if (isarray(input)) {
                    cloned.length = input.length;
                    "concat every filter forEach indexOf join lastIndexOf map pop push reduce reduceRight reverse shift slice some sort splice toLocaleString toString unshift"
                    .split(" ")
                    .forEach(
                      function (methodName) {
                        isfn( Array.prototype[methodName] )
                        && (
                            cloned[methodName] =
                            function () {
                                return Array.prototype[methodName].apply(cloned, arguments);
                            }
                        );
                      }
                    );
                }
                return isemptyobj(cloned)
                       ? (
                          isObject(input)
                          ? cloned
                          : input
                        )
                       : cloned;
            } else {
                return input;
            }
        };
    }
));
//

克隆对象的简单递归方法。也可以使用lodash.clone。

让克隆=（obj）=>{let obj2=Array.isArray（obj）？[] : {};for（设k为obj）{obj2[k]=（obj[k]===“对象”的类型）？克隆（obj[k]）：obj[k]；}返回obj2；}让w＝{name:“Apple”，类型：[“Fuji”，“Gala”]}；设x=克隆（w）；w.name=“橙色”；w.types=[“Navel”]；console.log（x）；console.log（w）；

表演

今天2020.04.30我在MacOs High Sierra v10.13.6上对Chrome v81.0、Safari v13.1和Firefox v75.0上选择的解决方案进行了测试。

我专注于复制DATA（具有简单类型字段的对象，而不是方法等）的速度。解决方案A-I只能进行浅层复制，解决方案J-U可以进行深层复制。

浅层副本的结果

解决方案｛…obj｝（A）在chrome和firefox上速度最快，在safari上速度中等基于Object.assign（B）的解决方案在所有浏览器上都很快jQuery（E）和lodash（F，G，H）解决方案是中等/相当快的解决方案JSON.parse/stringify（K）非常慢解决方案D和U在所有浏览器上都很慢

深度复制的结果

解决方案Q在所有浏览器上都是最快的jQuery（L）和lodash（J）是中速的解决方案JSON.parse/stringify（K）非常慢解决方案U在所有浏览器上都是最慢的lodash（J）和1000级深对象的Chrome上的U崩溃解决方案

细节

对于选择的解决方案：A.BC（我的）DEFGH我JKLMNOPQRSTU我进行了4次测试

浅小：具有10个非嵌套字段的对象-可以在此处运行浅大：具有1000个非嵌套字段的对象-可以在此处运行deep-small：具有10级嵌套字段的对象-可以在此处运行deep-big：具有1000级嵌套字段的对象-可以在此处运行

测试中使用的对象显示在下面的代码段中

let obj_ShallowSmall={字段0：假，字段1：真，字段2:1，字段3:0，字段4：空，字段5:[]，字段6:{}，field7：“text7”，字段8：“text8”，}让obj_DepSmall={级别0：{级别1：{级别2：{级别3：{级别4：{级别5：{级别6：{第7级：{级别8：{第9级：[[[[[[[[]]，}}}}}}}}},};让obj_ShallowBig=数组（1000）.fill（0）.reduce（（a，c，i）=>（a['field'+i]=getField（i），a），{}）；让obj_DepBig=genDeepObject（1000）；// ------------------//显示对象// ------------------console.log（'obj_ShallowSmall:'，JSON.stringify（obj_SharlowSmall））；console.log（'obj_DepSmall:'，JSON.stringify（obj_DeepSmall））；console.log（'obj_ShallowBig:'，JSON.stringify（obj_SharlowBig））；console.log（'obj_DepBig:'，JSON.stringify（obj_DeepBig））；// ------------------//助手// ------------------函数getField（k）{设i=k%10；如果（i==0）返回false；如果（i==1）返回真；如果（i==2）返回k；如果（i==3）返回0；如果（i==4）返回null；如果（i==5）返回[]；如果（i＝＝6）返回{}；如果（i>=7）返回“text”+k；}函数genDeepObject（N）{//生成：｛level0:｛level1：｛…levelN：｛end:[[[…N次…['abc']…]]｝｝｝｝…｝｝让obj＝{}；设o=obj；设arr=[]；设a=arr；for（设i=0；i<N；i++）{o['level'+i]={}；o=o['level'+i]；设aa=[]；a.推（aa）；a=aa；}a[0]=“公元前”；o['end']=arr；返回obj；}

下面的代码片段展示了经过测试的解决方案，并显示了它们之间的差异

函数A（obj）{返回｛…obj｝}函数B（obj）{return Object.assign（｛｝，obj）；}函数C（obj）{return Object.keys（obj）.reduce（（a，c）=>（a[c]=obj[c]，a），{}）}函数D（obj）{让copyOfObject＝｛｝；Object.defineProperties（copyOfObject，Object.getOwnPropertyDescriptors（obj））；返回copyOfObject；}函数E（obj）{return jQuery.exextend（｛｝，obj）//浅}函数F（obj）{return _.clone（obj）；}函数G（obj）{return _.clone（obj，true）；}函数H（obj）{返回扩展（｛｝，obj）；}函数I（obj）{如果（null==obj||“对象”！=obj类型）返回obj；var copy=obj.constructor（）；for（obj中的var属性）{如果（obj.hasOwnProperty（attr））copy[attr]=obj[attr]；}返回副本；}函数J（obj）{return _.cloneDeep（obj，true）；}函数K（obj）{返回JSON.parse（JSON.stringify（obj））；}函数L（obj）{return jQuery.exextend（true，｛｝，obj）//deep}函数M（obj）{如果（obj==null | |类型（obj）！='对象'）返回obj；var temp=新建obj.constructor（）；for（obj中的var键）temp[key]=M（obj[key]）；返回温度；}函数N（obj）{设EClone=函数（obj）{var newObj=（数组的obj实例）？[] : {};for（对象中的变量i）{如果（i=='EClone'）继续；如果（obj[i]&&类型obj[i]==“对象”）{newObj[i]=EClone（obj[i]）；}否则newObj[i]=obj[i]}返回newObj；};返回EClone（obj）；};函数O（obj）{如果（obj==null||typeof obj！=“object”）返回obj；如果（obj.constructor！=对象&&obj.constructionr！=数组）返回obj；如果（obj.constructor==日期| | obj.constructionr==RegExp | | obc.constructor==函数||obj.structor==字符串||obj.structor==数字||obc.structor==布尔值）返回新的obj.constructor（obj）；let to=new obj.constructor（）；for（obj中的var名称）{to[name]=typeof to[name]==“undefined”？O（obj[名称]，null）：到[名称]；}返回；}函数P（obj）{函数克隆（目标，源）{for（输入源代码）{//使用getOwnPropertyDescriptor而不是source[key]来防止触发setter/getter。let descriptor=Object.getOwnPropertyDescriptor（源，键）；if（字符串的descriptor.value实例）{target[key]=新字符串（descriptor.value）；}else if（数组的descriptor.value实例）{target[key]=克隆（[]，descriptor.value）；}else if（descriptor.value对象实例）{let prototype=Reflect.getPrototypeOf（descriptor.value）；let cloneObject=clone（｛｝，descriptor.value）；Reflect.setPrototypeOf（克隆对象，原型）；target[key]=克隆对象；}其他{Object.defineProperty（目标、键、描述符）；}}let prototype=Reflect.getPrototypeOf（源代码）；Reflect.setPrototypeOf（目标，原型）；回归目标；}返回克隆（｛｝，obj）；}函数Q（obj）{var复制；//处理3个简单类型，以及null或undefined如果（null==obj||“对象”！=obj类型）返回obj；//处理日期if（日期的obj实例）{copy=新日期（）；copy.setTime（obj.getTime（））；返回副本；}//句柄数组if（数组的obj实例）{copy=[]；对于（变量i=0，len=obj.length；i<len；i++）{copy[i]=Q（obj[i]）；}返回副本；}//句柄对象if（对象的obj实例）{copy＝｛｝；for（obj中的var属性）{如果（obj.hasOwnProperty（attr））copy[attr]=Q（obj.[attr]）；}返回副本；}throw new Error（“无法复制obj！不支持其类型。”）；}函数R（obj）{const gdcc=“__getDeepCircularCopy__”；if（obj！==对象（obj））{返回obj；//原始值}var set=obj中的gdcc，缓存＝obj[gdcc]，后果if（设置缓存类型==“函数”）{return cache（）；}//其他obj[gdcc]=函数（）｛return result；｝；//覆盖if（数组的obj实例）{结果=[]；对于（var i=0；i<obj.length；i++）{结果[i]=R（obj[i]）；}}其他{结果＝{}；for（obj中的var属性）if（prop！=gdcc）result[prop]=R（obj[prop]）；else if（设置）result[prop]=R（缓存）；}if（设置）{obj[gdcc]=缓存；//重置}其他{删除对象[gdcc]；//再次取消设置}返回结果；}函数S（obj）{const cache=new WeakMap（）；//新旧参考地图函数副本（对象）{if（对象类型！=='对象'||对象==空||HTMLElement的对象实例)返回对象；//原始值或HTMLElementif（日期的对象实例）return new Date（）.setTime（object.getTime（））；if（RegExp的对象实例）返回新的RegExp（object.source，object.flags）；if（cache.has（对象））返回cache.get（对象）；const result=数组的对象实例？[] : {};cache.set（对象，结果）；//在递归开始之前存储对对象的引用if（数组的对象实例）{for（对象的常量）{result.push（复制（o））；}返回结果；}const keys=对象.keys（对象）；for（键的常量键）result[key]=复制（对象[key]）；返回结果；}返回副本（obj）；}

下面是Chrome对于浅大型对象的示例结果