在JavaScript中，深克隆对象的最有效方法是什么？

Question

克隆JavaScript对象的最有效方法是什么？我已经看过 obj = eval（uneval（o））; 被使用，但是非标准，仅由firefox 。
。

我已经完成了 obj = obj = json.parse（json.stringify） （o））; ，但质疑效率。

我还看到了具有各种缺陷的递归复制功能。
我很惊讶没有规范的解决方案。

Answer 1

function clone(obj)
 { var clone = {};
   clone.prototype = obj.prototype;
   for (property in obj) clone[property] = obj[property];
   return clone;
 }

Answer 2

lodash有一个不错的_。clonedeep（value）方法：

var objects = [{ 'a': 1 }, { 'b': 2 }];

var deep = _.cloneDeep(objects);
console.log(deep[0] === objects[0]);
// => false

Answer 3

对于类似阵列的对象，似乎还没有理想的深克隆操作员。如下所示，John Resig的JQuery克隆器将具有非数字属性的数组变成不是数组的对象，RegdWight的JSON Cloner删除了非数字属性。以下测试在多个浏览器上说明了这些点：

function jQueryClone(obj) {
   return jQuery.extend(true, {}, obj)
}

function JSONClone(obj) {
   return JSON.parse(JSON.stringify(obj))
}

var arrayLikeObj = [[1, "a", "b"], [2, "b", "a"]];
arrayLikeObj.names = ["m", "n", "o"];
var JSONCopy = JSONClone(arrayLikeObj);
var jQueryCopy = jQueryClone(arrayLikeObj);

alert("Is arrayLikeObj an array instance?" + (arrayLikeObj instanceof Array) +
      "\nIs the jQueryClone an array instance? " + (jQueryCopy instanceof Array) +
      "\nWhat are the arrayLikeObj names? " + arrayLikeObj.names +
      "\nAnd what are the JSONClone names? " + JSONCopy.names)

Answer 4

（ ecmascript第5版）

var origin = { foo : {} };
var copy = Object.keys(origin).reduce(function(c,k){c[k]=origin[k];return c;},{});

console.log(origin, copy);
console.log(origin == copy); // false
console.log(origin.foo == copy.foo); // true

浅复制单位liner ecmascript 6th Edition 6th Edition 6th Edition 2015，2015，2015，2015年：

var origin = { foo : {} };
var copy = Object.assign({}, origin);

console.log(origin, copy);
console.log(origin == copy); // false
console.log(origin.foo == copy.foo); // true

Answer 5

仅仅因为我没有看到 angularjs 提到并认为人们可能想知道...

< a href =“ https://docs.angularjs.org/api/ng/function/angular.copy” rel =“ noreferrer”> angular.copy.copy 也提供了一种深层的方法复制对象和数组。

Answer 6

我有两个好的答案，具体取决于您的目标是克隆“普通的旧JavaScript对象”。

我们还假设您的意图是创建一个完整的克隆，而没有原型引用回到源对象。如果您对完整的克隆不感兴趣，则可以使用其他一些答案（Crockford的模式）中提供的许多object.clone（）例程。

对于普通的旧javaScript对象，在现代运行时克隆对象的久经考验的好方法很简单：

var clone = JSON.parse(JSON.stringify(obj));

请注意，源对象必须是纯JSON对象。这就是说，其所有嵌套属性都必须是标量（例如布尔，字符串，数组，对象等）。任何功能或特殊对象（例如RegexP或日期）都不会克隆。

有效吗？哎呀。我们尝试了各种克隆方法，这最有效。我敢肯定，有些忍者可以使人联想到更快的方法。但是我怀疑我们正在谈论边际收益。

这种方法简单易于实现。将其包裹在便利功能中，如果您确实需要挤出一些收益，请在以后的时间内进行。

现在，对于非平台JavaScript对象，没有一个非常简单的答案。实际上，不可能是因为JavaScript函数和内部对象状态的动态性质。深层克隆具有内部功能的JSON结构需要您重新创建这些功能及其内部上下文。 JavaScript根本没有标准化的方法。

再次执行此操作的正确方法是通过您在代码中声明和重复使用的便利方法。便利方法可以赋予对自己对象的一些了解，因此您可以确保在新对象中正确重新创建图形。

我们写了自己的书，但是我看到的最好的一般方法在这里涵盖：

http://davidwalsh.name /javascript-clone

这是正确的想法。作者（David Walsh）评论了广义功能的克隆。这是您可能选择的，具体取决于您的用例。

主要思想是，您需要特殊处理功能的实例化（可以说是这样说）。在这里，他为Regexp和日期提供了一些示例。

该代码简介不仅是非常可读的。它很容易扩展。

这有效吗？哎呀。鉴于目标是生产一个真正的深拷贝克隆，那么您将不得不走源对象图的成员。使用这种方法，您可以准确调整要治疗的儿童成员以及如何手动处理自定义类型。

所以你去了。两种方法。在我看来，两者都是有效的。

Answer 7

我迟到要回答这个问题了，但是我有另一种克隆对象的方法：

function cloneObject(obj) {
    if (obj === null || typeof(obj) !== 'object')
        return obj;
    var temp = obj.constructor(); // changed
    for (var key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
            obj['isActiveClone'] = null;
            temp[key] = cloneObject(obj[key]);
            delete obj['isActiveClone'];
        }
    }
    return temp;
}

var b = cloneObject({"a":1,"b":2});   // calling

那要好得多，更快：

var a = {"a":1,"b":2};
var b = JSON.parse(JSON.stringify(a));  

我

var a = {"a":1,"b":2};

// Deep copy
var newObject = jQuery.extend(true, {}, a);

已经标记了代码，您可以测试结果在这里：

分享结果：

参考：

Answer 8

只有当您可以使用 ecmascript 6 或 transpilers 。

功能：

• 复制时不会触发Getter/Setter。
• 保留Getter/Setter。
• 保存原型信息。
• 与对象 - 文字和 functional 写作风格。

代码：

function clone(target, source){

    for(let key in source){

        // Use getOwnPropertyDescriptor instead of source[key] to prevent from trigering setter/getter.
        let descriptor = Object.getOwnPropertyDescriptor(source, key);
        if(descriptor.value instanceof String){
            target[key] = new String(descriptor.value);
        }
        else if(descriptor.value instanceof Array){
            target[key] = clone([], descriptor.value);
        }
        else if(descriptor.value instanceof Object){
            let prototype = Reflect.getPrototypeOf(descriptor.value);
            let cloneObject = clone({}, descriptor.value);
            Reflect.setPrototypeOf(cloneObject, prototype);
            target[key] = cloneObject;
        }
        else {
            Object.defineProperty(target, key, descriptor);
        }
    }
    let prototype = Reflect.getPrototypeOf(source);
    Reflect.setPrototypeOf(target, prototype);
    return target;
}

Answer 9

这通常不是最有效的解决方案，但它可以实现我需要的。下面的简单测试用例...

function clone(obj, clones) {
    // Makes a deep copy of 'obj'. Handles cyclic structures by
    // tracking cloned obj's in the 'clones' parameter. Functions 
    // are included, but not cloned. Functions members are cloned.
    var new_obj,
        already_cloned,
        t = typeof obj,
        i = 0,
        l,
        pair; 

    clones = clones || [];

    if (obj === null) {
        return obj;
    }

    if (t === "object" || t === "function") {

        // check to see if we've already cloned obj
        for (i = 0, l = clones.length; i < l; i++) {
            pair = clones[i];
            if (pair[0] === obj) {
                already_cloned = pair[1];
                break;
            }
        }

        if (already_cloned) {
            return already_cloned; 
        } else {
            if (t === "object") { // create new object
                new_obj = new obj.constructor();
            } else { // Just use functions as is
                new_obj = obj;
            }

            clones.push([obj, new_obj]); // keep track of objects we've cloned

            for (key in obj) { // clone object members
                if (obj.hasOwnProperty(key)) {
                    new_obj[key] = clone(obj[key], clones);
                }
            }
        }
    }
    return new_obj || obj;
}

循环阵列测试...

a = []
a.push("b", "c", a)
aa = clone(a)
aa === a //=> false
aa[2] === a //=> false
aa[2] === a[2] //=> false
aa[2] === aa //=> true

功能测试...

f = new Function
f.a = a
ff = clone(f)
ff === f //=> true
ff.a === a //=> false

Answer 10

对于想要使用 JSON.PARSE（JSON.STRINGIFY（OBJ））版本的人，但不会丢失日期对象，您可以使用 parse> parse methot 的第二个参数回到日期：

function clone(obj) {
  var regExp = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
  return JSON.parse(JSON.stringify(obj), function(k, v) {
    if (typeof v === 'string' && regExp.test(v))
      return new Date(v)
    return v;
  })
}

// usage:
var original = {
 a: [1, null, undefined, 0, {a:null}, new Date()],
 b: {
   c(){ return 0 }
 }
}

var cloned = clone(original)

console.log(cloned)

Answer 11

我不同意最大的投票的答案在这里。 递归深克隆比 json.parse（json.stringify（obj））的方法快得多。

• jsperf 在此处排名第一： https ：//jsperf.com/deep-copy-vs-json-stringify-json-parse/5
• jsben 从上面的答案中更新以表明递归深的克隆击败了所有其他克隆提到： http://jsben.ch/13ykq

这是快速参考的功能：

function cloneDeep (o) {
  let newO
  let i

  if (typeof o !== 'object') return o

  if (!o) return o

  if (Object.prototype.toString.apply(o) === '[object Array]') {
    newO = []
    for (i = 0; i < o.length; i += 1) {
      newO[i] = cloneDeep(o[i])
    }
    return newO
  }

  newO = {}
  for (i in o) {
    if (o.hasOwnProperty(i)) {
      newO[i] = cloneDeep(o[i])
    }
  }
  return newO
}

Answer 12

// obj target object, vals source object
var setVals = function (obj, vals) {
    if (obj && vals) {
        for (var x in vals) {
            if (vals.hasOwnProperty(x)) {
                if (obj[x] && typeof vals[x] === 'object') {
                    obj[x] = setVals(obj[x], vals[x]);
                } else {
                    obj[x] = vals[x];
                }
            }
        }
    }
    return obj;
};

Answer 13

天然深克隆

现在有一个 structuredclone（value） ） 在所有主要浏览器中支持的功能和node＆gt; = 17。它具有 polyfills对于较旧的系统。

structuredClone(value)

如果需要，请先加载polyfill：

import structuredClone from '@ungap/structured-clone';

请参阅this answer for more details, but 注意这些限制：

• 函数对象不能由结构化的克隆算法复制；试图抛出DatacLoneError异常。
• 克隆DOM节点同样会引发DatacLoneError异常。
• 某些对象属性未保留：
  • REGEXP对象的最后点数属性未保留。
  • 属性描述符，设定器，get子和类似的类似元数据的功能未重复。例如，如果一个对象用属性描述符标记，则将以副本读取/写入，因为这是默认值。
  • 原型链未行走或重复。

较旧的答案

与数据丢失快速克隆-JSON.PARSE/Stringify

如果您不使用 date s，functions， undefined ， infinity ，regexps，地图，集合，斑点，filelists，imagedatas，稀疏数组，键入数组或对象内的其他复杂类型，一个非常简单的一个衬里，可深克隆一个对象是：

json.parse（json.stringify（object））< /代码>

const a = {
  string: 'string',
  number: 123,
  bool: false,
  nul: null,
  date: new Date(),  // stringified
  undef: undefined,  // lost
  inf: Infinity,  // forced to 'null'
  re: /.*/,  // lost
}
console.log(a);
console.log(typeof a.date);  // Date object
const clone = JSON.parse(JSON.stringify(a));
console.log(clone);
console.log(typeof clone.date);  // result of .toISOString()

请参阅 corban's答案用于基准。

使用库的可靠克隆

由于克隆对象不是微不足道的（复杂类型，循环引用，功能等），因此大多数主要库为克隆对象提供功能。 不要重新发明轮子 - 如果您已经在使用库，请检查其是否具有对象克隆功能。例如，

• lodash- clonedeep ;可以通过 lodash.clonedeep 模块，并且如果您是您的最佳选择，则可以是您的最佳选择尚未使用提供深克隆功能
• ramda的库 - clone
• angularjs- angular.copy.copy
• a href =“ https://api.jquery.com/jquery.extend/#jquery-extend-extend-deep-target-object-object-1-objectn” rel =“ noreferrer”> jquery.extend（true，true，{} ） ; .clone（）只有clones dom元素
• 只有库 - justa克隆 ;仅做一件事的零依赖性NPM模块库的一部分。
  每种场合都有无罪的公用事业。

Answer 14

核对此基准： http://jsben.ch/#/bwfk9

在我以前的测试中，我发现的主要问题

JSON.parse(JSON.stringify(obj))

是最慢的克隆对象的最慢方法（比 jquery.extend.extend 带有 deep 标志设置为10-20％的标志）。

当 deep 标志设置为 false （浅克隆）时，jquery.extend非常快。这是一个不错的选择，因为它包含一些用于类型验证的额外逻辑，并且不会复制未定义的属性等，但这也会减慢您的速度。

如果您知道要克隆的对象的结构，或者可以避免深嵌套数组，则可以为（obj中的var i in obj）编写一个简单的 循环在检查hasownproperty时克隆您的对象，它将是比jQuery快得多。

最后，如果您试图在热循环中克隆已知的对象结构，则可以通过简单地插入克隆过程并手动构造对象来获得更多的性能。

JavaScript Trace引擎在优化 for..in 循环和检查HasownProperty时也会减慢您的速度。当速度是绝对必须的时，手动克隆。

var clonedObject = {
  knownProp: obj.knownProp,
  ..
}

当心使用 JSON.PARSE（JSON.STRINGIFY（OBJ））在日期对象上的方法 - json.stringify（new Date（））返回ISO格式日期的字符串表示形式， JSON.PARSE（） 不转换回 date 对象。 a>。

此外，请注意，至少在Chrome 65中，本机克隆不是必经之路。根据JSPERF的说法，通过创建新功能来执行本机克隆几乎 800X 慢。使用JSON.Stringify，它在整个台上都非常快。

如果使用JavaScript ES6，请尝试此本机方法进行克隆或浅副本。

Object.assign({}, obj);

Answer 15

结构化的克隆

const clone = structuredClone(original);

现代浏览器和运行时间提供A ，暴露html标准的以前的内部结构化克隆/序列化算法用于创建对象的深度克隆。它仍然仅限于某些内置类型，但是除了JSON支持的少数类型外，它支持日期，左右，地图，集合，斑点，斑点，filelists，imagedatas，Imagedatas，稀疏阵列，稀疏阵列，键入阵列，可能会在以后。它还保留了克隆数据中的参考文献，从而使其能够支持会导致JSON错误的周期性和递归结构。

如果您需要支持旧的环境，其余的答案描述了在直接暴露此功能之前使用此功能的解决方法。

同步node.js解决方案：很棒！

Answer 16

假设您只有属性，而对象中没有任何功能，则可以使用：

var newObject = JSON.parse(JSON.stringify(oldObject));

Answer 17

如果没有内置的，您可以尝试：

function clone(obj) {
    if (obj === null || typeof (obj) !== 'object' || 'isActiveClone' in obj)
        return obj;

    if (obj instanceof Date)
        var temp = new obj.constructor(); //or new Date(obj);
    else
        var temp = obj.constructor();

    for (var key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
            obj['isActiveClone'] = null;
            temp[key] = clone(obj[key]);
            delete obj['isActiveClone'];
        }
    }
    return temp;
}

Answer 18

克隆（而不是deep-clone）的有效方法在一行代码中的对象

和 object.assign 方法是ecmascript 2015（ES6）标准的一部分，并且确实需要您所需的工作。

var clone = Object.assign({}, obj);

object.assign（）方法用于将所有枚举自己属性的值从一个或多个源对象复制到目标对象。

​polyfill 支持较旧的浏览器：

if (!Object.assign) {
  Object.defineProperty(Object, 'assign', {
    enumerable: false,
    configurable: true,
    writable: true,
    value: function(target) {
      'use strict';
      if (target === undefined || target === null) {
        throw new TypeError('Cannot convert first argument to object');
      }

      var to = Object(target);
      for (var i = 1; i < arguments.length; i++) {
        var nextSource = arguments[i];
        if (nextSource === undefined || nextSource === null) {
          continue;
        }
        nextSource = Object(nextSource);

        var keysArray = Object.keys(nextSource);
        for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {
          var nextKey = keysArray[nextIndex];
          var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
          if (desc !== undefined && desc.enumerable) {
            to[nextKey] = nextSource[nextKey];
          }
        }
      }
      return to;
    }
  });
}

Answer 19

根据表演的深度复制：

根据基准测试
排名从最佳到最差。
https://www.measurethat.net/benchmarks/show/show/17502 /0/deep -copy -comporparison

• 传播操作员 ... （原始数组 - 仅）
• slice（）（原始数组 - 仅）
• （0）（原始数组 - 仅）
• concat（）（原始数组 - 仅）
• json.parse（json.stringify（））数组 - 唯一的）
• 自定义函数，如下所示（
• ）
• 任何
• 数组 代码> _。clone（）（原始和文字数组 - 仅）

其中：

• primitives =字符串，数字和布尔值
• literals = object triletals {} ，array literals []
• any =原始人，文字和原型

深层复制了一系列原始词：

let arr1a = [1, 'a', true];

仅具有原始词（即数字，字符串和布尔人），重新分配， slice（ slice）（ ）， concat（）和UnderScore的 clone（）可以使用。

差异的情况最快：

let arr1b = [...arr1a];

slice（）的性能比剪接（0） and concat（）

let arr1d = arr1a.slice();
let arr1c = arr1a.splice(0);
let arr1e = arr1a.concat();

深复制一系列原始和对象文字：

let arr2a = [1, 'a', true, {}, []];
let arr2b = JSON.parse(JSON.stringify(arr2a));

深复制一个原始，对象文字和原型的数组：

let arr3a = [1, 'a', true, {}, [], new Object()];

编写自定义功能（比jquery $。 ）：

function copy(aObject) {
  // Prevent undefined objects
  // if (!aObject) return aObject;

  let bObject = Array.isArray(aObject) ? [] : {};

  let value;
  for (const key in aObject) {

    // Prevent self-references to parent object
    // if (Object.is(aObject[key], aObject)) continue;
    
    value = aObject[key];

    bObject[key] = (typeof value === "object") ? copy(value) : value;
  }

  return bObject;
}

let arr3b = copy(arr3a);

或使用第三方实用程序功能：

let arr3c = $.extend(true, [], arr3a); // jQuery
let arr3d = _.cloneDeep(arr3a); // Lodash

Answer 20

这就是我正在使用的：

function cloneObject(obj) {
    var clone = {};
    for(var i in obj) {
        if(typeof(obj[i])=="object" && obj[i] != null)
            clone[i] = cloneObject(obj[i]);
        else
            clone[i] = obj[i];
    }
    return clone;
}

Answer 21

代码：

// extends 'from' object with members from 'to'. If 'to' is null, a deep clone of 'from' is returned
function extend(from, to)
{
    if (from == null || typeof from != "object") return from;
    if (from.constructor != Object && from.constructor != Array) return from;
    if (from.constructor == Date || from.constructor == RegExp || from.constructor == Function ||
        from.constructor == String || from.constructor == Number || from.constructor == Boolean)
        return new from.constructor(from);

    to = to || new from.constructor();

    for (var name in from)
    {
        to[name] = typeof to[name] == "undefined" ? extend(from[name], null) : to[name];
    }

    return to;
}

测试：

var obj =
{
    date: new Date(),
    func: function(q) { return 1 + q; },
    num: 123,
    text: "asdasd",
    array: [1, "asd"],
    regex: new RegExp(/aaa/i),
    subobj:
    {
        num: 234,
        text: "asdsaD"
    }
}

var clone = extend(obj);

Answer 22

javaScript中的深层复制对象（我认为最好和最简单）

1。使用json.parse（json.stringify（object））;

var obj = { 
  a: 1,
  b: { 
    c: 2
  }
}
var newObj = JSON.parse(JSON.stringify(obj));
obj.b.c = 20;
console.log(obj); // { a: 1, b: { c: 20 } }
console.log(newObj); // { a: 1, b: { c: 2 } } 

2.创建的方法

function cloneObject(obj) {
    var clone = {};
    for(var i in obj) {
        if(obj[i] != null &&  typeof(obj[i])=="object")
            clone[i] = cloneObject(obj[i]);
        else
            clone[i] = obj[i];
    }
    return clone;
}

var obj = { 
  a: 1,
  b: { 
    c: 2
  }
}
var newObj = cloneObject(obj);
obj.b.c = 20;

console.log(obj); // { a: 1, b: { c: 20 } }
console.log(newObj); // { a: 1, b: { c: 2 } } 

3。使用lo-dash的_.clonedeep 链接 lodash

var obj = { 
  a: 1,
  b: { 
    c: 2
  }
}

var newObj = _.cloneDeep(obj);
obj.b.c = 20;
console.log(obj); // { a: 1, b: { c: 20 } }
console.log(newObj); // { a: 1, b: { c: 2 } } 

4。使用Object.Assign（）方法

var obj = { 
  a: 1,
  b: 2
}

var newObj = _.clone(obj);
obj.b = 20;
console.log(obj); // { a: 1, b: 20 }
console.log(newObj); // { a: 1, b: 2 }  

，但当

var obj = { 
  a: 1,
  b: { 
    c: 2
  }
}

var newObj = Object.assign({}, obj);
obj.b.c = 20;
console.log(obj); // { a: 1, b: { c: 20 } }
console.log(newObj); // { a: 1, b: { c: 20 } } --> WRONG
// Note: Properties on the prototype chain and non-enumerable properties cannot be copied.

5.使用underscore.js _.clone link link underscore.js

var obj = { 
  a: 1,
  b: 2
}

var newObj = _.clone(obj);
obj.b = 20;
console.log(obj); // { a: 1, b: 20 }
console.log(newObj); // { a: 1, b: 2 }  

，但当

var obj = { 
  a: 1,
  b: { 
    c: 2
  }
}

var newObj = _.cloneDeep(obj);
obj.b.c = 20;
console.log(obj); // { a: 1, b: { c: 20 } }
console.log(newObj); // { a: 1, b: { c: 20 } } --> WRONG
// (Create a shallow-copied clone of the provided plain object. Any nested objects or arrays will be copied by reference, not duplicated.)

jsben.ch performance bench performance playgronging 1〜3 http://jsben.ch/kvqld

Answer 23

克隆一个对象在JS中始终是一个关注的问题，但是在ES6之前，我列出了在下面的JavaScript中复制对象的不同方法，请想象您有以下对象，并且想对此进行深刻的副本

var obj = {a:1, b:2, c:3, d:4};

：复制此对象的方法，而无需更改原点：

1. es5+，使用一个简单的函数为您完成副本：

    功能DeepCopyObj（obj）{
       if（null == obj ||“对象”！= obj typeof obj）返回obj;
       if（obj instance of date）{
           var copy = new Date（）;
           copy.setTime（obj.getTime（））;
           返回副本；
       }
       if（obj instance of array）{
           var copy = [];
           for（var i = 0，len = obj.length; i＆lt; len; i ++）{
               复制[i] = deepCopyObj（obj [i]）;
           }
           返回副本；
       }
       if（obj instensof object）{
           var copy = {};
           对于（obj中的var attr）{
               if（obj.hasownproperty（attr））复制[attr] = deepCopyObj（obj [attr]）;
           }
           返回副本；
       }
       提出新的错误（“无法复制此对象。”）;
   }
    

2. es5+，使用 json.parse 和 json.stringify 。

     var deepCopyObj = json.parse（json.stringify（obj））;
    

3. 角：

     var deepcopyobj = angular.copy（obj）;
    

4. jQuery：

     var deepCopyObj = jquery.extend（true，{}，obj）;
    

5. inscore.js＆amp; lodash：

     var deepcopyobj = _.clonedeep（obj）; //最新版本的unterscore.js制作浅副本
    

希望这些帮助…

Answer 24

var clone = function() {
    var newObj = (this instanceof Array) ? [] : {};
    for (var i in this) {
        if (this[i] && typeof this[i] == "object") {
            newObj[i] = this[i].clone();
        }
        else
        {
            newObj[i] = this[i];
        }
    }
    return newObj;
}; 

Object.defineProperty( Object.prototype, "clone", {value: clone, enumerable: false});

Answer 25

有一个 library> library（称为“ clone”），这做得很好。它提供了我所知道的任意对象的最完整的递归克隆/复制。它还支持循环引用，而其他答案还没有涵盖。

您可以在npm 上也找到它。它可用于浏览器和node.js。

这是一个有关如何使用它的示例：

与

npm install clone

ender”> ender 。

ender build clone [...]

您也可以手动下载源代码。

然后，您可以在源代码中使用它。

var clone = require('clone');

var a = { foo: { bar: 'baz' } };  // inital value of a
var b = clone(a);                 // clone a -> b
a.foo.bar = 'foo';                // change a

console.log(a);                   // { foo: { bar: 'foo' } }
console.log(b);                   // { foo: { bar: 'baz' } }

（免责声明：我是图书馆的作者。）

Answer 26

我知道这是一个古老的帖子，但我认为这可能对下一个偶然的人有帮助。

只要您不将对象分配给任何内容都没有内存中的参考。因此，要制作要在其他对象之间共享的对象，您必须创建一个工厂：

var a = function(){
    return {
        father:'zacharias'
    };
},
b = a(),
c = a();
c.father = 'johndoe';
alert(b.father);

Answer 27

如果您正在使用它，则 underscore.js 库具有克隆方法。

var newObject = _.clone(oldObject);

Answer 28

这是上面的ConRoyp答案的一个版本，即使构造函数需要参数，也可以使用：

//If Object.create isn't already defined, we just do the simple shim,
//without the second argument, since that's all we need here
var object_create = Object.create;
if (typeof object_create !== 'function') {
    object_create = function(o) {
        function F() {}
        F.prototype = o;
        return new F();
    };
}

function deepCopy(obj) {
    if(obj == null || typeof(obj) !== 'object'){
        return obj;
    }
    //make sure the returned object has the same prototype as the original
    var ret = object_create(obj.constructor.prototype);
    for(var key in obj){
        ret[key] = deepCopy(obj[key]);
    }
    return ret;
}

此函数也可以在我的图书馆。

编辑：

这是一个更强大的版本（感谢Justin McCandless，现在也支持循环参考）：

/**
 * Deep copy an object (make copies of all its object properties, sub-properties, etc.)
 * An improved version of http://keithdevens.com/weblog/archive/2007/Jun/07/javascript.clone
 * that doesn't break if the constructor has required parameters
 * 
 * It also borrows some code from http://stackoverflow.com/a/11621004/560114
 */ 
function deepCopy(src, /* INTERNAL */ _visited, _copiesVisited) {
    if(src === null || typeof(src) !== 'object'){
        return src;
    }

    //Honor native/custom clone methods
    if(typeof src.clone == 'function'){
        return src.clone(true);
    }

    //Special cases:
    //Date
    if(src instanceof Date){
        return new Date(src.getTime());
    }
    //RegExp
    if(src instanceof RegExp){
        return new RegExp(src);
    }
    //DOM Element
    if(src.nodeType && typeof src.cloneNode == 'function'){
        return src.cloneNode(true);
    }

    // Initialize the visited objects arrays if needed.
    // This is used to detect cyclic references.
    if (_visited === undefined){
        _visited = [];
        _copiesVisited = [];
    }

    // Check if this object has already been visited
    var i, len = _visited.length;
    for (i = 0; i < len; i++) {
        // If so, get the copy we already made
        if (src === _visited[i]) {
            return _copiesVisited[i];
        }
    }

    //Array
    if (Object.prototype.toString.call(src) == '[object Array]') {
        //[].slice() by itself would soft clone
        var ret = src.slice();

        //add it to the visited array
        _visited.push(src);
        _copiesVisited.push(ret);

        var i = ret.length;
        while (i--) {
            ret[i] = deepCopy(ret[i], _visited, _copiesVisited);
        }
        return ret;
    }

    //If we've reached here, we have a regular object

    //make sure the returned object has the same prototype as the original
    var proto = (Object.getPrototypeOf ? Object.getPrototypeOf(src): src.__proto__);
    if (!proto) {
        proto = src.constructor.prototype; //this line would probably only be reached by very old browsers 
    }
    var dest = object_create(proto);

    //add this object to the visited array
    _visited.push(src);
    _copiesVisited.push(dest);

    for (var key in src) {
        //Note: this does NOT preserve ES5 property attributes like 'writable', 'enumerable', etc.
        //For an example of how this could be modified to do so, see the singleMixin() function
        dest[key] = deepCopy(src[key], _visited, _copiesVisited);
    }
    return dest;
}

//If Object.create isn't already defined, we just do the simple shim,
//without the second argument, since that's all we need here
var object_create = Object.create;
if (typeof object_create !== 'function') {
    object_create = function(o) {
        function F() {}
        F.prototype = o;
        return new F();
    };
}

Answer 29

以下创建了同一对象的两个实例。我找到了它，目前正在使用它。它简单易用。

var objToCreate = JSON.parse(JSON.stringify(cloneThis));

Answer 30

克罗克福德（Crockford）建议（我更喜欢）使用此功能：

function object(o) {
    function F() {}
    F.prototype = o;
    return new F();
}

var newObject = object(oldObject);

它是简短的，按预期工作，您不需要库。

---

编辑：

这是 object.create.create 的多填充，因此您也可以使用此功能。

var newObject = Object.create(oldObject);

注意：如果您使用其中的某些，则可能有一些使用 HasownProperty 的迭代问题。因为，创建创建新的空对象谁继承了 oldobject 。但是它仍然对克隆对象有用且实用。

如果 oldobject.a = 5;

newObject.a; // is 5

but：

oldObject.hasOwnProperty(a); // is true
newObject.hasOwnProperty(a); // is false