在ECMAScript 6中有Object.assign方法，它将所有可枚举自身财产的值从一个对象复制到另一个对象。例如：

var x = {myProp: "value"};
var y = Object.assign({}, x); 

但请注意，这是一个浅层复制-嵌套对象仍然作为引用复制。

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对象，但只要您不认为它只适用于您向它抛出的任何东西，它就可以满足许多目的。

互联网上的大多数解决方案都存在几个问题。所以我决定做一个跟进，包括为什么不应该接受接受的答案。

启动情况

我想深度复制一个Javascript对象及其所有子对象和它们的子对象等等。但由于我不是一个普通的开发人员，我的对象具有普通的财产、循环结构甚至嵌套对象。

因此，让我们先创建一个圆形结构和一个嵌套对象。

function Circ() {
    this.me = this;
}

function Nested(y) {
    this.y = y;
}

让我们把所有的东西放在一个名为a的对象中。

var a = {
    x: 'a',
    circ: new Circ(),
    nested: new Nested('a')
};

接下来，我们要将a复制到名为b的变量中，并对其进行变异。

var b = a;

b.x = 'b';
b.nested.y = 'b';

你知道这里发生了什么，因为如果不是这样，你甚至不会回答这个伟大的问题。

console.log(a, b);

a --> Object {
    x: "b",
    circ: Circ {
        me: Circ { ... }
    },
    nested: Nested {
        y: "b"
    }
}

b --> Object {
    x: "b",
    circ: Circ {
        me: Circ { ... }
    },
    nested: Nested {
        y: "b"
    }
}

现在让我们找到一个解决方案。

JSON

我第一次尝试是使用JSON。

var b = JSON.parse( JSON.stringify( a ) );

b.x = 'b';
b.nested.y = 'b';

不要在上面浪费太多时间，你会得到TypeError：将循环结构转换为JSON。

递归副本（接受的“答案”）

让我们来看看公认的答案。

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

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

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

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

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

看起来不错，呵呵？它是对象的递归副本，也处理其他类型，如Date，但这不是必需的。

var b = cloneSO(a);

b.x = 'b';
b.nested.y = 'b';

递归和循环结构不能很好地一起工作。。。RangeError:超出了最大调用堆栈大小

本地解决方案

在与同事争吵后，老板问我们发生了什么事，他在谷歌搜索后找到了一个简单的解决方案。它叫做Object.create。

var b = Object.create(a);

b.x = 'b';
b.nested.y = 'b';

这个解决方案不久前被添加到Javascript中，甚至可以处理循环结构。

console.log(a, b);

a --> Object {
    x: "a",
    circ: Circ {
        me: Circ { ... }
    },
    nested: Nested {
        y: "b"
    }
}

b --> Object {
    x: "b",
    circ: Circ {
        me: Circ { ... }
    },
    nested: Nested {
        y: "b"
    }
}

…你看，它不适用于内部的嵌套结构。

本地解决方案的polyfill

在旧浏览器中有一个用于Object.create的polyfill，就像IE 8一样。它有点像Mozilla推荐的，当然，它不是完美的，并且会导致与本机解决方案相同的问题。

function F() {};
function clonePF(o) {
    F.prototype = o;
    return new F();
}

var b = clonePF(a);

b.x = 'b';
b.nested.y = 'b';

我把F放在了范围之外，这样我们可以看看instanceof告诉我们什么。

console.log(a, b);

a --> Object {
    x: "a",
    circ: Circ {
        me: Circ { ... }
    },
    nested: Nested {
        y: "b"
    }
}

b --> F {
    x: "b",
    circ: Circ {
        me: Circ { ... }
    },
    nested: Nested {
        y: "b"
    }
}

console.log(typeof a, typeof b);

a --> object
b --> object

console.log(a instanceof Object, b instanceof Object);

a --> true
b --> true

console.log(a instanceof F, b instanceof F);

a --> false
b --> true

问题与本机解决方案相同，但输出稍差。

更好（但不是完美）的解决方案

当我仔细研究时，我发现了一个与这个问题类似的问题（在Javascript中，当执行深度复制时，我如何避免循环，因为属性是“this”？），但有一个更好的解决方案。

function cloneDR(o) {
    const gdcc = "__getDeepCircularCopy__";
    if (o !== Object(o)) {
        return o; // primitive value
    }

    var set = gdcc in o,
        cache = o[gdcc],
        result;
    if (set && typeof cache == "function") {
        return cache();
    }
    // else
    o[gdcc] = function() { return result; }; // overwrite
    if (o instanceof Array) {
        result = [];
        for (var i=0; i<o.length; i++) {
            result[i] = cloneDR(o[i]);
        }
    } else {
        result = {};
        for (var prop in o)
            if (prop != gdcc)
                result[prop] = cloneDR(o[prop]);
            else if (set)
                result[prop] = cloneDR(cache);
    }
    if (set) {
        o[gdcc] = cache; // reset
    } else {
        delete o[gdcc]; // unset again
    }
    return result;
}

var b = cloneDR(a);

b.x = 'b';
b.nested.y = 'b';

让我们看看输出。。。

console.log(a, b);

a --> Object {
    x: "a",
    circ: Object {
        me: Object { ... }
    },
    nested: Object {
        y: "a"
    }
}

b --> Object {
    x: "b",
    circ: Object {
        me: Object { ... }
    },
    nested: Object {
        y: "b"
    }
}

console.log(typeof a, typeof b);

a --> object
b --> object

console.log(a instanceof Object, b instanceof Object);

a --> true
b --> true

console.log(a instanceof F, b instanceof F);

a --> false
b --> false

需求是匹配的，但仍有一些较小的问题，包括将nested和circ的实例更改为Object。

共享一片叶子的树的结构不会被复制，它们将变成两片独立的叶子：

        [Object]                     [Object]
         /    \                       /    \
        /      \                     /      \
      |/_      _\|                 |/_      _\|  
  [Object]    [Object]   ===>  [Object]    [Object]
       \        /                 |           |
        \      /                  |           |
        _\|  |/_                 \|/         \|/
        [Object]               [Object]    [Object]

结论

最后一个使用递归和缓存的解决方案可能不是最好的，但它是对象的真正深度副本。它处理简单的财产、循环结构和嵌套对象，但在克隆时会弄乱它们的实例。

小提琴演奏家

A.Levy的答案几乎是完整的，这是我的一点贡献：有一种方法可以处理递归引用，请看下面这行

如果（this[attr]==this）copy[attr]=复制；

如果对象是XMLDOM元素，则必须改用cloneNode

if（this.cloneNode）返回this.clone节点（true）；

受A.Levy的详尽研究和Calvin的原型设计方法启发，我提供了以下解决方案：

Object.prototype.clone = 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;
}

Date.prototype.clone = function() {
  var copy = new Date();
  copy.setTime(this.getTime());
  return copy;
}

Number.prototype.clone = 
Boolean.prototype.clone =
String.prototype.clone = function() {
  return this;
}

另请参见答案中的Andy Burke注释。

function clone(obj)
{
    var cloneObj = Object.create(obj);

    return cloneObj;
}

在Javascript中，对象单独继承另一个对象（原型继承）。create（obj）返回一个对象，该对象是obj的子对象或子对象。在上面的函数中，它将有效地返回该对象的副本。

然而，这是一种非常奇怪的克隆方式，因为我没有将继承用于其真正目的。

使用npm的深度复制。在浏览器和节点中作为npm模块工作。。。

https://www.npmjs.com/package/deepcopy

设a=深度复制（b）