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

    return cloneObj;
}

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

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

这里许多同行针对深度克隆提出的解决方案JSON.parse（JSON.stringify（orig_obj）有几个问题，我发现这些问题如下：

它在复制原始对象中未定义值的条目时丢弃这些条目，如果有一些值，如Infinity、NaN等，它们将在复制时转换为null，如果原始对象中存在Date类型，则它将在克隆对象中字符串化（typeof Date_entry-->string）。

找到了一种克隆对象的有效方法，它在各种场景中都很适合我。请看一看下面的代码，因为它已经解决了JSON.parse（…）的所有上述缺陷，但最终实现了正确的深度克隆：

var orig_obj = {
  string: 'my_str',
  number: 123,
  bool: false,
  nul: null,
  nested : {
    value : true
  },
  nan : NaN,
  date: new Date(), 
  undef: undefined,
  inf: Infinity,
}
console.log("original_obj before modification: ", orig_obj, "\n");
console.log(typeof orig_obj.date, "\n");

var clone_obj = Object.assign({}, orig_obj);

//this below loop will help in deep cloning and solving above issues
for(let prop in orig_obj) {
    if(typeof orig_obj[prop] === "object") {
        if(orig_obj[prop] instanceof Date)
            clone_obj[prop] = orig_obj[prop];
        else {
            clone_obj[prop] = JSON.parse(JSON.stringify(orig_obj[prop]));
        }
    }
}

console.log("cloned_obj before modification: ", orig_obj, "\n");

clone_obj.bool = true;
clone_obj.nested.value = "false";

console.log("original_obj post modification: ", orig_obj, "\n");
console.log("cloned_obj post modification: ", clone_obj, "\n");
console.log(typeof clone_obj.date);

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

对象指定（Object Assign）

根据Apple JavaScript编码指南：

// Create an inner object with a variable x whose default
// value is 3.
function innerObj()
{
        this.x = 3;
}
innerObj.prototype.clone = function() {
    var temp = new innerObj();
    for (myvar in this) {
        // this object does not contain any objects, so
        // use the lightweight copy code.
        temp[myvar] = this[myvar];
    }
    return temp;
}

// Create an outer object with a variable y whose default
// value is 77.
function outerObj()
{
        // The outer object contains an inner object.  Allocate it here.
        this.inner = new innerObj();
        this.y = 77;
}
outerObj.prototype.clone = function() {
    var temp = new outerObj();
    for (myvar in this) {
        if (this[myvar].clone) {
            // This variable contains an object with a
            // clone operator.  Call it to create a copy.
            temp[myvar] = this[myvar].clone();
        } else {
            // This variable contains a scalar value,
            // a string value, or an object with no
            // clone function.  Assign it directly.
            temp[myvar] = this[myvar];
        }
    }
    return temp;
}

// Allocate an outer object and assign non-default values to variables in
// both the outer and inner objects.
outer = new outerObj;
outer.inner.x = 4;
outer.y = 16;

// Clone the outer object (which, in turn, clones the inner object).
newouter = outer.clone();

// Verify that both values were copied.
alert('inner x is '+newouter.inner.x); // prints 4
alert('y is '+newouter.y); // prints 16

史蒂夫

老问题的新答案！如果您有幸将ECMAScript 2016（ES6）与Spread Syntax一起使用，这很简单。

keepMeTheSame = {first: "Me!", second: "You!"};
cloned = {...keepMeTheSame}

这为对象的浅层副本提供了一种干净的方法。创建一个深度副本，意味着为每个递归嵌套对象中的每个值创建一个新副本，这需要使用上面更重的解决方案。

JavaScript不断发展。

一个特别不优雅的解决方案是使用JSON编码对没有成员方法的对象进行深度复制。方法是对目标对象进行JSON编码，然后通过对其进行解码，获得所需的副本。您可以解码任意次数，以制作任意数量的副本。

当然，函数不属于JSON，因此这只适用于没有成员方法的对象。

这种方法非常适合我的用例，因为我将JSON blob存储在一个键值存储中，并且当它们在JavaScript API中作为对象公开时，每个对象实际上都包含对象的原始状态的副本，因此我们可以在调用方对公开的对象进行变异后计算增量。

var object1 = {key:"value"};
var object2 = object1;

object2 = JSON.stringify(object1);
object2 = JSON.parse(object2);

object2.key = "a change";
console.log(object1);// returns value