我最喜欢的优雅JS对象克隆解决方案是

function CloneObject() {}
function cloneObject(o) {
   CloneObject.prototype = o;
   return new CloneObject();
}

使用cloneObject（object）获取JS对象的克隆。

与许多复制解决方案不同，此克隆在克隆对象中保持原型关系。

好的，我知道它有很多答案，但没有人指出，EcmaScript5有赋值方法，在FF和Chrome上工作，它复制可枚举的，并且拥有财产和符号。

对象指定（Object Assign）

这是对A.Levy代码的修改，以处理函数和多个/循环引用的克隆。这意味着，如果克隆的树中的两个财产是同一对象的引用，则克隆的对象树将使这些财产指向被引用对象的同一克隆。这也解决了循环依赖性的问题，如果不加以处理，就会导致无限循环。算法的复杂度为O（n）

function clone(obj){
    var clonedObjectsArray = [];
    var originalObjectsArray = []; //used to remove the unique ids when finished
    var next_objid = 0;

    function objectId(obj) {
        if (obj == null) return null;
        if (obj.__obj_id == undefined){
            obj.__obj_id = next_objid++;
            originalObjectsArray[obj.__obj_id] = obj;
        }
        return obj.__obj_id;
    }

    function cloneRecursive(obj) {
        if (null == obj || typeof obj == "string" || typeof obj == "number" || typeof obj == "boolean") 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; i < obj.length; ++i) {
                copy[i] = cloneRecursive(obj[i]);
            }
            return copy;
        }

        // Handle Object
        if (obj instanceof Object) {
            if (clonedObjectsArray[objectId(obj)] != undefined)
                return clonedObjectsArray[objectId(obj)];

            var copy;
            if (obj instanceof Function)//Handle Function
                copy = function(){return obj.apply(this, arguments);};
            else
                copy = {};

            clonedObjectsArray[objectId(obj)] = copy;

            for (var attr in obj)
                if (attr != "__obj_id" && obj.hasOwnProperty(attr))
                    copy[attr] = cloneRecursive(obj[attr]);                 

            return copy;
        }       


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



    //remove the unique ids
    for (var i = 0; i < originalObjectsArray.length; i++)
    {
        delete originalObjectsArray[i].__obj_id;
    };

    return cloneObj;
}

一些快速测试

var auxobj = {
    prop1 : "prop1 aux val", 
    prop2 : ["prop2 item1", "prop2 item2"]
    };

var obj = new Object();
obj.prop1 = "prop1_value";
obj.prop2 = [auxobj, auxobj, "some extra val", undefined];
obj.nr = 3465;
obj.bool = true;

obj.f1 = function (){
    this.prop1 = "prop1 val changed by f1";
};

objclone = clone(obj);

//some tests i've made
console.log("test number, boolean and string cloning: " + (objclone.prop1 == obj.prop1 && objclone.nr == obj.nr && objclone.bool == obj.bool));

objclone.f1();
console.log("test function cloning 1: " + (objclone.prop1 == 'prop1 val changed by f1'));
objclone.f1.prop = 'some prop';
console.log("test function cloning 2: " + (obj.f1.prop == undefined));

objclone.prop2[0].prop1 = "prop1 aux val NEW";
console.log("test multiple references cloning 1: " + (objclone.prop2[1].prop1 == objclone.prop2[0].prop1));
console.log("test multiple references cloning 2: " + (objclone.prop2[1].prop1 != obj.prop2[0].prop1));

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

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

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安慰

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

如果在对象中不使用Dates、functions、undefined、regExp或Infinity，那么一个非常简单的一行代码就是JSON.parse（JSON.stringify（object））：

常量a={string：'字符串'，编号：123，bool:false，nul：空，date:new date（），//字符串化undef：未定义，//丢失inf:无限，//强制为“null”}控制台日志（a）；console.log（类型a.date）；//日期对象constclone=JSON.parse（JSON.stringify（a））；console.log（克隆）；console.log（clone.date的类型）；//.toISOString（）的结果

这适用于包含对象、数组、字符串、布尔值和数字的所有类型的对象。

另请参阅本文，了解浏览器的结构化克隆算法，该算法在向工作人员发布消息时使用。它还包含一个用于深度克隆的功能。

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

    return cloneObj;
}

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

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