在我的代码中，我经常定义一个函数（_）来处理副本，这样我就可以将值传递给函数。此代码创建一个深度副本，但保持继承。它还跟踪子副本，以便无需无限循环即可复制自引用对象。请随意使用。

这可能不是最优雅的，但它还没有让我失望。

_ = function(oReferance) {
  var aReferances = new Array();
  var getPrototypeOf = function(oObject) {
    if(typeof(Object.getPrototypeOf)!=="undefined") return Object.getPrototypeOf(oObject);
    var oTest = new Object();
    if(typeof(oObject.__proto__)!=="undefined"&&typeof(oTest.__proto__)!=="undefined"&&oTest.__proto__===Object.prototype) return oObject.__proto__;
    if(typeof(oObject.constructor)!=="undefined"&&typeof(oTest.constructor)!=="undefined"&&oTest.constructor===Object&&typeof(oObject.constructor.prototype)!=="undefined") return oObject.constructor.prototype;
    return Object.prototype;
  };
  var recursiveCopy = function(oSource) {
    if(typeof(oSource)!=="object") return oSource;
    if(oSource===null) return null;
    for(var i=0;i<aReferances.length;i++) if(aReferances[i][0]===oSource) return aReferances[i][1];
    var Copy = new Function();
    Copy.prototype = getPrototypeOf(oSource);
    var oCopy = new Copy();
    aReferances.push([oSource,oCopy]);
    for(sPropertyName in oSource) if(oSource.hasOwnProperty(sPropertyName)) oCopy[sPropertyName] = recursiveCopy(oSource[sPropertyName]);
    return oCopy;
  };
  return recursiveCopy(oReferance);
};

// Examples:
Wigit = function(){};
Wigit.prototype.bInThePrototype = true;
A = new Wigit();
A.nCoolNumber = 7;
B = _(A);
B.nCoolNumber = 8; // A.nCoolNumber is still 7
B.bInThePrototype // true
B instanceof Wigit // true

我不知道这在哪些情况下不起作用，但它给了我一个数组的副本。我觉得它很可爱：）希望它有帮助

copiedArr = origArr.filter(function(x){return true})

可以使用rest运算符克隆阵列或对象

let myObj = {1: 100, 'a': 200};

let clone = {...myObj}; 

clone.a = 300;

console.log(clone.a) // Output :- 300
console.log(myObj.a) // Output :- 200

我已经完成了上述所有解决方案，它们都很好。然而，您可以使用另一种方法来克隆对象（值不引用）。对象分配

let x = {
    a: '1',
    b: '2'
}

let y = Object.assign({}, x)
y.a = "3"

console.log(x)

输出将为

{ a: '1', b: '2' }

此外，您还可以使用相同的方法克隆阵列。

clonedArray = Object.assign([], array)

您可以使用函数闭包来获得深度复制的所有好处，而无需深度复制。这是一个非常不同的范例，但效果很好。不要试图复制现有对象，只要在需要时使用函数实例化新对象即可。

首先，创建一个返回对象的函数

function template() {
  return {
    values: [1, 2, 3],
    nest: {x: {a: "a", b: "b"}, y: 100}
  };
}

然后创建一个简单的浅层复制函数

function copy(a, b) {
  Object.keys(b).forEach(function(key) {
    a[key] = b[key];
  });
}

创建一个新对象，并将模板的财产复制到其中

var newObject = {}; 
copy(newObject, template());

但上述复制步骤不是必需的。您需要做的就是：

var newObject = template();

现在您有了一个新对象，请测试它的财产：

console.log(Object.keys(newObject));

这将显示：

["values", "nest"]

是的，这些是newObject自己的财产，而不是对另一个对象上财产的引用。让我们检查一下：

console.log(newObject.nest.x.b);

这将显示：

"b"

newObject获得了模板对象的所有财产，但没有任何依赖链。

http://jsbin.com/ISUTIpoC/1/edit?js安慰

我添加此示例是为了鼓励一些讨论，因此请添加一些评论：）

根据MDN：

如果要浅层复制，请使用Object.assign（｛｝，a）对于“深度”复制，请使用JSON.parse（JSON.stringify（a））

不需要外部库，但您需要首先检查浏览器兼容性。