使用扩展语法执行对象的浅层复制。这意味着没有任何嵌套对象实例被克隆，正如您在下面的嵌套对象子实例示例中看到的那样

常量user1=｛name:“Alex”，地址：'公园大道15号'，年龄43岁，儿童：{name:“John”}}const user2=｛…user1｝；user1.child.name='chris'；console.log（用户1）；console.log（用户2）；

为了解决这个嵌套对象问题并执行深度复制，我们可以使用JSON.parse（JSON.stringify（someObject））

常量user1=｛name:“Alex”，地址：'公园大道15号'，年龄43岁，儿童：{name:“John”}}const user2=JSON.parse（JSON.stringify（user1））；user1.child.name='chris'；console.log（用户1）；console.log（用户2）；

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

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

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

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

我已经编写了自己的实现。不确定它是否算作更好的解决方案：

/*
    a function for deep cloning objects that contains other nested objects and circular structures.
    objects are stored in a 3D array, according to their length (number of properties) and their depth in the original object.
                                    index (z)
                                         |
                                         |
                                         |
                                         |
                                         |
                                         |                      depth (x)
                                         |_ _ _ _ _ _ _ _ _ _ _ _
                                        /_/_/_/_/_/_/_/_/_/
                                       /_/_/_/_/_/_/_/_/_/
                                      /_/_/_/_/_/_/...../
                                     /................./
                                    /.....            /
                                   /                 /
                                  /------------------
            object length (y)    /
*/

实施情况如下：

function deepClone(obj) {
    var depth = -1;
    var arr = [];
    return clone(obj, arr, depth);
}

/**
 *
 * @param obj source object
 * @param arr 3D array to store the references to objects
 * @param depth depth of the current object relative to the passed 'obj'
 * @returns {*}
 */
function clone(obj, arr, depth){
    if (typeof obj !== "object") {
        return obj;
    }

    var length = Object.keys(obj).length; // native method to get the number of properties in 'obj'

    var result = Object.create(Object.getPrototypeOf(obj)); // inherit the prototype of the original object
    if(result instanceof Array){
        result.length = length;
    }

    depth++; // depth is increased because we entered an object here

    arr[depth] = []; // this is the x-axis, each index here is the depth
    arr[depth][length] = []; // this is the y-axis, each index is the length of the object (aka number of props)
    // start the depth at current and go down, cyclic structures won't form on depths more than the current one
    for(var x = depth; x >= 0; x--){
        // loop only if the array at this depth and length already have elements
        if(arr[x][length]){
            for(var index = 0; index < arr[x][length].length; index++){
                if(obj === arr[x][length][index]){
                    return obj;
                }
            }
        }
    }

    arr[depth][length].push(obj); // store the object in the array at the current depth and length
    for (var prop in obj) {
        if (obj.hasOwnProperty(prop)) result[prop] = clone(obj[prop], arr, depth);
    }

    return result;
}

我之所以来到这个页面是因为同样的问题，但我既没有使用JQuery，也没有一个克隆方法适用于我自己的对象。

我知道我的答案与这个问题没有太大关系，因为这是一种不同的方法。我不使用克隆函数，而是使用创建函数。它对我来说有以下（不幸的是限制）目的：

我主要使用JSP生成的Javascript我一开始就知道必须生成哪个Object（在我的例子中，它是来自数据库的信息，只获取一次，需要在JS中更频繁地部署。

首先，我这样定义对象：

var obj= new Object();
obj.Type='Row';
obj.ID=1;
obj.Value='Blah blah';

现在我移动了所有的东西，比如：

function getObjSelektor(id_nummer,selected){
var obj = document.createElement("select");
obj.setAttribute("id","Selektor_"+id_nummer);
obj.setAttribute("name","Selektor");
obj.setAttribute("size","1");

var obj_opt_1 = document.createElement("option");
obj_opt_1.setAttribute("value","1");
if(1==selected)
    posopval_opt_1.setAttribute("selected","selected");
obj_opt_1.innerHTML="Blah blah";
obj.appendChild(obj_opt_1);

var obj_opt_2 = document.createElement("option");
obj_opt_2.setAttribute("value","2");
if(2==selected)
    obj_opt_2.setAttribute("selected","selected");
obj_opt_2.innerHTML="2nd Row";
obj.appendChild(obj_opt_2);

...

return obj;
}

并调用常规代码中的函数：

myDiv.getObjSelektor(getObjSelektor(anotherObject.ID));

正如所说，这是一种不同的方法，它为我的目的解决了我的问题。

您可以简单地使用扩展属性来复制没有引用的对象。但是要小心（请参见注释），“副本”仅位于最低的对象/数组级别。嵌套的财产仍然是引用！

完整克隆：

let x = {a: 'value1'}
let x2 = {...x}

// => mutate without references:

x2.a = 'value2'
console.log(x.a)    // => 'value1'

在第二级克隆引用：

const y = {a: {b: 'value3'}}
const y2 = {...y}

// => nested object is still a references:

y2.a.b = 'value4'
console.log(y.a.b)    // => 'value4'

JavaScript实际上不支持本地深度克隆。使用效用函数。例如Ramda：

http://ramdajs.com/docs/#clone

复制最终可能指向自身的对象的问题可以通过简单的检查来解决。每次有复制操作时，添加此复选框。它可能很慢，但应该会起作用。

我使用toType（）函数显式返回对象类型。我也有自己的copyObj（）函数，它在逻辑上非常相似，可以回答所有三种Object（）、Array（）和Date（）情况。

我在NodeJS中运行它。

尚未测试。

// Returns true, if one of the parent's children is the target.
// This is useful, for avoiding copyObj() through an infinite loop!
function isChild(target, parent) {
  if (toType(parent) == '[object Object]') {
    for (var name in parent) {
      var curProperty = parent[name];

      // Direct child.
      if (curProperty = target) return true;

      // Check if target is a child of this property, and so on, recursively.
      if (toType(curProperty) == '[object Object]' || toType(curProperty) == '[object Array]') {
        if (isChild(target, curProperty)) return true;
      }
    }
  } else if (toType(parent) == '[object Array]') {
    for (var i=0; i < parent.length; i++) {
      var curItem = parent[i];

      // Direct child.
      if (curItem = target) return true;

      // Check if target is a child of this property, and so on, recursively.
      if (toType(curItem) == '[object Object]' || toType(curItem) == '[object Array]') {
        if (isChild(target, curItem)) return true;
      }
    }
  }

  return false;     // Not the target.
}