结构化克隆

2022年更新：structuredClone（）全局函数已在Node 17、Deno 1.14和大多数主要浏览器中可用（请参阅我可以使用）。

您可以使用与HTML标准相同的结构化克隆机制在领域之间发送数据。

const clone = structuredClone(original);

有关详细信息，请参阅另一个答案。

Jan Turo的上述答案非常接近，由于兼容性问题，可能是在浏览器中使用的最佳选择，但这可能会导致一些奇怪的枚举问题。例如，执行：

for ( var i in someArray ) { ... }

在遍历数组元素后，将clone（）方法赋给i。下面是一个避免枚举并适用于node.js的改编：

Object.defineProperty( Object.prototype, "clone", {
    value: function() {
        if ( this.cloneNode )
        {
            return this.cloneNode( true );
        }

        var copy = this instanceof Array ? [] : {};
        for( var attr in this )
        {
            if ( typeof this[ attr ] == "function" || this[ attr ] == null || !this[ attr ].clone )
            {
                copy[ attr ] = this[ attr ];
            }
            else if ( this[ attr ] == this )
            {
                copy[ attr ] = copy;
            }
            else
            {
                copy[ attr ] = this[ attr ].clone();
            }
        }
        return copy;
    }
});

Object.defineProperty( Date.prototype, "clone", {
    value: function() {
        var copy = new Date();
        copy.setTime( this.getTime() );
        return copy;
    }
});

Object.defineProperty( Number.prototype, "clone", { value: function() { return this; } } );
Object.defineProperty( Boolean.prototype, "clone", { value: function() { return this; } } );
Object.defineProperty( String.prototype, "clone", { value: function() { return this; } } );

这避免了使clone（）方法可枚举，因为defineProperty（）默认为false。

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

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

   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/

如果在对象中不使用Dates、functions、undefined、regExp或Infinity，那么一个非常简单的一行代码就是JSON.parse（JSON.stringify（object））：

常量a={string：'字符串'，编号：123，bool:false，nul：空，date:new date（），//字符串化undef：未定义，//丢失inf:无限，//强制为“null”}控制台日志（a）；console.log（类型a.date）；//日期对象constclone=JSON.parse（JSON.stringify（a））；console.log（克隆）；console.log（clone.date的类型）；//.toISOString（）的结果

这适用于包含对象、数组、字符串、布尔值和数字的所有类型的对象。

另请参阅本文，了解浏览器的结构化克隆算法，该算法在向工作人员发布消息时使用。它还包含一个用于深度克隆的功能。

本文来自Brian Huisman的《如何在Javascript中复制数组和对象》：

Object.prototype.clone = function() {
  var newObj = (this instanceof Array) ? [] : {};
  for (var i in this) {
    if (i == 'clone') continue;
    if (this[i] && typeof this[i] == "object") {
      newObj[i] = this[i].clone();
    } else newObj[i] = this[i]
  } return newObj;
};

如果你对一个浅拷贝没有问题，underscore.js库有一个克隆方法。

y = _.clone(x);

或者你可以像

copiedObject = _.extend({},originalObject);