有很多答案，但没有一个提到ECMAScript 5中的Object.create，它确实没有给您一个确切的副本，而是将源设置为新对象的原型。

因此，这不是问题的确切答案，但它是一个单行解决方案，因此很优雅。它最适合2种情况：

在这种继承有用的地方（duh！）源对象不会被修改，因此这两个对象之间的关系不成问题。

例子：

var foo = { a : 1 };
var bar = Object.create(foo);
foo.a; // 1
bar.a; // 1
foo.a = 2;
bar.a; // 2 - prototype changed
bar.a = 3;
foo.a; // Still 2, since setting bar.a makes it an "own" property

为什么我认为这种解决方案更优越？它是本地的，因此没有循环，没有递归。然而，较旧的浏览器将需要polyfill。

我认为，在没有库的情况下，缓存的重复性是最好的。

被低估的WeakMap涉及到循环的问题，其中存储对新旧对象的引用可以帮助我们很容易地重建整个树。

我阻止了DOM元素的深度克隆，可能您不想克隆整个页面：）

function deepCopy(object) {
    const cache = new WeakMap(); // Map of old - new references

    function copy(obj) {
        if (typeof obj !== 'object' ||
            obj === null ||
            obj instanceof HTMLElement
        )
            return obj; // primitive value or HTMLElement

        if (obj instanceof Date) 
            return new Date().setTime(obj.getTime());

        if (obj instanceof RegExp) 
            return new RegExp(obj.source, obj.flags);

        if (cache.has(obj)) 
            return cache.get(obj);

        const result = obj instanceof Array ? [] : {};

        cache.set(obj, result); // store reference to object before the recursive starts

        if (obj instanceof Array) {
            for(const o of obj) {
                 result.push(copy(o));
            }
            return result;
        }

        const keys = Object.keys(obj); 

        for (const key of keys)
            result[key] = copy(obj[key]);

        return result;
    }

    return copy(object);
}

一些测试：

// #1
const obj1 = { };
const obj2 = { };
obj1.obj2 = obj2;
obj2.obj1 = obj1; // Trivial circular reference

var copy = deepCopy(obj1);
copy == obj1 // false
copy.obj2 === obj1.obj2 // false
copy.obj2.obj1.obj2 // and so on - no error (correctly cloned).

// #2
const obj = { x: 0 }
const clone = deepCopy({ a: obj, b: obj });
clone.a == clone.b // true

// #3
const arr = [];
arr[0] = arr; // A little bit weird but who cares
clone = deepCopy(arr)
clone == arr // false;
clone[0][0][0][0] == clone // true;

注意：我使用常量、for of循环、=>运算符和WeakMaps来创建更重要的代码。当前的浏览器支持此语法（ES6）

克隆对象的简单递归方法。也可以使用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）；

正如此链接所示，使用以下代码：

let clone = Object.create(Object.getPrototypeOf(obj),
 Object.getOwnPropertyDescriptors(obj));

有很多答案，但没有一个提到ECMAScript 5中的Object.create，它确实没有给您一个确切的副本，而是将源设置为新对象的原型。

因此，这不是问题的确切答案，但它是一个单行解决方案，因此很优雅。它最适合2种情况：

在这种继承有用的地方（duh！）源对象不会被修改，因此这两个对象之间的关系不成问题。

例子：

var foo = { a : 1 };
var bar = Object.create(foo);
foo.a; // 1
bar.a; // 1
foo.a = 2;
bar.a; // 2 - prototype changed
bar.a = 3;
foo.a; // Still 2, since setting bar.a makes it an "own" property

为什么我认为这种解决方案更优越？它是本地的，因此没有循环，没有递归。然而，较旧的浏览器将需要polyfill。

这是一个没有Object.assign（）陷阱的现代解决方案（不通过引用复制）：

const cloneObj = (obj) => {
    return Object.keys(obj).reduce((dolly, key) => {
        dolly[key] = (obj[key].constructor === Object) ?
            cloneObj(obj[key]) :
            obj[key];
        return dolly;
    }, {});
};