很简单的方法，也许太简单了：

var cloned = JSON.parse(JSON.stringify(objectToClone));

这真的取决于你想克隆什么。这是一个真正的 JSON 对象还是 JavaScript 中的任何对象？如果你想做任何克隆，它可能会给你带来一些麻烦。哪个麻烦？我将在下面解释它，但首先是一个克隆对象文字、任何基元、数组和 DOM 节点的代码示例。

function clone(item) {
    if (!item) { return item; } // null, undefined values check

    var types = [ Number, String, Boolean ], 
        result;

    // normalizing primitives if someone did new String('aaa'), or new Number('444');
    types.forEach(function(type) {
        if (item instanceof type) {
            result = type( item );
        }
    });

    if (typeof result == "undefined") {
        if (Object.prototype.toString.call( item ) === "[object Array]") {
            result = [];
            item.forEach(function(child, index, array) { 
                result[index] = clone( child );
            });
        } else if (typeof item == "object") {
            // testing that this is DOM
            if (item.nodeType && typeof item.cloneNode == "function") {
                result = item.cloneNode( true );    
            } else if (!item.prototype) { // check that this is a literal
                if (item instanceof Date) {
                    result = new Date(item);
                } else {
                    // it is an object literal
                    result = {};
                    for (var i in item) {
                        result[i] = clone( item[i] );
                    }
                }
            } else {
                // depending what you would like here,
                // just keep the reference, or create new object
                if (false && item.constructor) {
                    // would not advice to do that, reason? Read below
                    result = new item.constructor();
                } else {
                    result = item;
                }
            }
        } else {
            result = item;
        }
    }

    return result;
}

var copy = clone({
    one : {
        'one-one' : new String("hello"),
        'one-two' : [
            "one", "two", true, "four"
        ]
    },
    two : document.createElement("div"),
    three : [
        {
            name : "three-one",
            number : new Number("100"),
            obj : new function() {
                this.name = "Object test";
            }   
        }
    ]
})

现在，让我们谈谈开始克隆 REAL 对象时可能遇到的问题。我现在谈论的是你通过做类似的事情创建的对象

var User = function(){}
var newuser = new User();

当然你可以克隆它们，这不是问题，每个对象都暴露构造函数属性，你可以用它来克隆对象，但它并不总是有效。你也可以for in在这个对象上做简单的事情，但它会走向同一个方向——麻烦。我还在代码中包含了克隆功能，但它被if( false )语句排除在外。

那么，为什么克隆会很痛苦？嗯，首先，每个对象/实例都可能有某种状态。你永远不能确定你的对象没有例如私有变量，如果是这种情况，通过克隆对象，你只是打破状态。

想象一下没有状态，那很好。那么我们还有另一个问题。通过“构造函数”方法克隆会给我们带来另一个障碍。这是一个参数依赖。你永远无法确定，创建这个对象的人，没有做过，某种

new User({
   bike : someBikeInstance
});

如果是这种情况，那么您就不走运了， someBikeInstance 可能是在某个上下文中创建的，而该上下文对于 clone 方法来说是未知的。

那么该怎么办？您仍然可以for in解决问题，并将此类对象视为普通对象文字，但也许根本不克隆此类对象是一个想法，而只是传递此对象的引用？

另一个解决方案是 - 您可以设置一个约定，所有必须克隆的对象都应该自己实现这部分并提供适当的 API 方法（如 cloneObject ）。cloneNodeDOM 正在做什么。

你决定。

JSON.parse(JSON.stringify())深度复制 Javascript 对象的组合是一种无效的黑客攻击，因为它适用于 JSON 数据。它不支持undefinedor 的值function () {}，并且在将nullJavascript 对象“串化”（编组）为 JSON 时将简单地忽略它们（或它们）。

更好的解决方案是使用深拷贝功能。下面的函数深度复制对象，不需要第三方库（jQuery、LoDash 等）。

function copy(aObject) {
  if (!aObject) {
    return aObject;
  }

  let v;
  let bObject = Array.isArray(aObject) ? [] : {};
  for (const k in aObject) {
    v = aObject[k];
    bObject[k] = (typeof v === "object") ? copy(v) : v;
  }

  return bObject;
}

这是一个 ES6 函数，它也适用于具有循环引用的对象：

function deepClone(obj, hash = new WeakMap()) {
    if (Object(obj) !== obj) return obj; // primitives
    if (hash.has(obj)) return hash.get(obj); // cyclic reference
    const result = obj instanceof Set ? new Set(obj) // See note about this!
                 : obj instanceof Map ? new Map(Array.from(obj, ([key, val]) => 
                                        [key, deepClone(val, hash)])) 
                 : obj instanceof Date ? new Date(obj)
                 : obj instanceof RegExp ? new RegExp(obj.source, obj.flags)
                 // ... add here any specific treatment for other classes ...
                 // and finally a catch-all:
                 : obj.constructor ? new obj.constructor() 
                 : Object.create(null);
    hash.set(obj, result);
    return Object.assign(result, ...Object.keys(obj).map(
        key => ({ [key]: deepClone(obj[key], hash) }) ));
}

// Sample data
var p = {
  data: 1,
  children: [{
    data: 2,
    parent: null
  }]
};
p.children[0].parent = p;

var q = deepClone(p);

console.log(q.children[0].parent.data); // 1

关于 Sets 和 Maps 的说明

如何处理设置和地图的钥匙是值得商榷的：这些键通常是原语（在这种情况下，没有辩论），但他们可以也是对象。在这种情况下，问题就变成了：应该克隆这些密钥吗？

有人可能会争辩说，应该这样做，以便如果这些对象在副本中发生变异，则原始对象中的对象不受影响，反之亦然。

另一方面，如果 Set/Maphas是一个键，那么这在原始和副本中都应该是正确的——至少在对它们中的任何一个进行任何更改之前都是如此。如果副本是一个 Set/Map，它的键以前从未出现过（因为它们是在克隆过程中创建的），那将会很奇怪：对于需要知道给定对象是否为是否键入该 Set/Map。

正如您所注意到的，我更倾向于第二种意见： Sets 和 Maps 的键是应该保持不变的值（可能是引用）。

此类选择通常也会与其他（可能是自定义的）对象一起出现。没有通用的解决方案，因为在很大程度上取决于克隆对象在您的特定情况下的行为方式。

该Underscore.js的contrib库库有一个称为函数快照深克隆对象

源代码片段：

snapshot: function(obj) {
  if(obj == null || typeof(obj) != 'object') {
    return obj;
  }

  var temp = new obj.constructor();

  for(var key in obj) {
    if (obj.hasOwnProperty(key)) {
      temp[key] = _.snapshot(obj[key]);
    }
  }

  return temp;
}

一旦库链接到您的项目，只需使用调用该函数

_.snapshot(object);