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

function clone(src, deep) {

    var toString = Object.prototype.toString;
    if(!src && typeof src != "object"){
        //any non-object ( Boolean, String, Number ), null, undefined, NaN
        return src;
    }

    //Honor native/custom clone methods
    if(src.clone && toString.call(src.clone) == "[object Function]"){
        return src.clone(deep);
    }

    //DOM Elements
    if(src.nodeType && toString.call(src.cloneNode) == "[object Function]"){
        return src.cloneNode(deep);
    }

    //Date
    if(toString.call(src) == "[object Date]"){
        return new Date(src.getTime());
    }

    //RegExp
    if(toString.call(src) == "[object RegExp]"){
        return new RegExp(src);
    }

    //Function
    if(toString.call(src) == "[object Function]"){
        //Wrap in another method to make sure == is not true;
        //Note: Huge performance issue due to closures, comment this :)
        return (function(){
            src.apply(this, arguments);
        });

    }

    var ret, index;
    //Array
    if(toString.call(src) == "[object Array]"){
        //[].slice(0) would soft clone
        ret = src.slice();
        if(deep){
            index = ret.length;
            while(index--){
                ret[index] = clone(ret[index], true);
            }
        }
    }
    //Object
    else {
        ret = src.constructor ? new src.constructor() : {};
        for (var prop in src) {
            ret[prop] = deep
                ? clone(src[prop], true)
                : src[prop];
        }
    }

    return ret;
};

您可以克隆一个对象，并使用一行代码从上一个对象中删除任何引用。只需执行以下操作：

var obj1 = { text: 'moo1' };
var obj2 = Object.create(obj1); // Creates a new clone without references

obj2.text = 'moo2'; // Only updates obj2's text property

console.log(obj1, obj2); // Outputs: obj1: {text:'moo1'}, obj2: {text:'moo2'}

对于当前不支持Object.create的浏览器/引擎，可以使用以下polyfill：

// Polyfill Object.create if it does not exist
if (!Object.create) {
    Object.create = function (o) {
        var F = function () {};
        F.prototype = o;
        return new F();
    };
}

对克隆简单对象感兴趣：

JSON.parse（JSON.stringify（JSON_inoriginal））；

来源：如何通过引用将JavaScript对象复制到新变量NOT？

在JavaScript中复制对象的方法

使用排列（…）语法使用Object.assign（）方法使用JSON.stringify（）和JSON.parse（）方法

const person = {
    firstName: 'John',
    lastName: 'Doe'
};

// using spread ...
let p1 = {
    ...person
};

// using  Object.assign() method
let p2 = Object.assign({}, person);

// using JSON
let p3 = JSON.parse(JSON.stringify(person));

不同的

仅复制顶层：｛…object｝和object.assign（｛｝，object）

让objA={a： “键a”，b：{c： “键c”，}}let objB=Object.assign（｛｝，objA）；//或｛…objB｝//更改对象BobjB.a=“更改objA.a（顶部）”console.log（“objA.a（top）无更改：\n”+JSON.stringify（objA，false，2））；objB.b.c=“更改应仅适用于objB.b.c，但在objA.b.c中”console.log（“objA.a.c第二级已更改：\n”+JSON.stringify（objA，false，2））；

对于深度复制，请使用旧浏览器的structuredClone（）2022或JSON.parse（JSON.stringify（object）），无需黑客即可轻松完成。

让objA={a： “键a”，b：{c： “键c”，}}让objB=typeof structuredClone==“函数”？structuredClone（objA）：JSON.parse（JSON.stringify（objB））；//更改对象BobjB.a=“更改objA.a（顶部）”objB.b.c=“更改应该只针对objB.c，但它在objA.c中”console.log（“objA没有更改：\n”+JSON.stringify（objA，false，2））；