Qual é a maneira mais eficiente de clonar um objeto JavaScript? Vi obj = eval(uneval(o));ser usado, mas isso não é padrão e é suportado apenas pelo Firefox .

Eu fiz coisas como, obj = JSON.parse(JSON.stringify(o));mas questiono a eficiência.

Também vi funções de cópia recursiva com várias falhas.
Estou surpreso que não exista solução canônica.

Clonagem profunda nativa

É chamado de "clonagem estruturada", funciona experimentalmente no nó 11 e posterior e, esperançosamente, chegará aos navegadores. Veja esta resposta para mais detalhes.

Clonagem rápida com perda de dados - JSON.parse / stringify

Se você não usar Dates, funções undefined, Infinity, regexps, Mapas, Conjuntos, gotas, filelists, ImageDatas, Arrays esparsos, datilografado matrizes ou outros tipos complexos dentro de seu objeto, uma forma muito simples um forro de clone profundo um objeto é:

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()

Veja a resposta de Corban para referências.

Clonagem confiável usando uma biblioteca

Como a clonagem de objetos não é trivial (tipos complexos, referências circulares, função etc.), a maioria das principais bibliotecas fornece função para clonar objetos. Não reinvente a roda - se você já estiver usando uma biblioteca, verifique se ela possui uma função de clonagem de objetos. Por exemplo,

• lodash - cloneDeep; pode ser importado separadamente por meio do módulo lodash.clonedeep e provavelmente é a melhor opção se você ainda não estiver usando uma biblioteca que fornece uma função de clonagem profunda
• AngularJS - angular.copy
• jQuery - jQuery.extend(true, { }, oldObject); .clone()apenas clona elementos DOM

ES6

Para completar, observe que o ES6 oferece dois mecanismos de cópia rasos: Object.assign()e a sintaxe de propagação . que copia valores de todas as propriedades próprias enumeráveis ​​de um objeto para outro. Por exemplo:

var A1 = {a: "2"};
var A2 = Object.assign({}, A1);
var A3 = {...A1};  // Spread Syntax

Faça o checkout deste benchmark: http://jsben.ch/#/bWfk9

Nos meus testes anteriores, onde a velocidade era a principal preocupação que encontrei

JSON.parse(JSON.stringify(obj))

para ser a maneira mais lenta de clonar profundamente um objeto (é mais lento que o jQuery.extend com o deepsinalizador definido como verdadeiro de 10 a 20%).

O jQuery.extend é muito rápido quando o deepsinalizador é definido como false(clone superficial). É uma boa opção, pois inclui alguma lógica extra para validação de tipo e não copia propriedades indefinidas, etc., mas isso também o torna um pouco mais lento.

Se você conhece a estrutura dos objetos que está tentando clonar ou pode evitar matrizes aninhadas profundas, pode escrever um for (var i in obj)loop simples para clonar seu objeto enquanto verifica hasOwnProperty, e será muito mais rápido que o jQuery.

Por fim, se você estiver tentando clonar uma estrutura de objeto conhecida em um hot loop, poderá obter MUITO MAIS DESEMPENHO simplesmente alinhando o procedimento de clonagem e construindo manualmente o objeto.

Os mecanismos de rastreamento JavaScript são for..inruins para otimizar loops e a verificação de hasOwnProperty também o tornará lento. Clone manual quando a velocidade é uma necessidade absoluta.

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

Cuidado ao usar o JSON.parse(JSON.stringify(obj))método em Dateobjetos - JSON.stringify(new Date())retorna uma representação de string da data no formato ISO, que JSON.parse() não é convertida novamente em um Dateobjeto. Veja esta resposta para mais detalhes .

Além disso, observe que, pelo menos no Chrome 65, a clonagem nativa não é o caminho a percorrer. De acordo com o JSPerf, executar a clonagem nativa criando uma nova função é quase 800x mais lenta que o uso do JSON.stringify, que é incrivelmente rápido em todo o caminho.

Atualização para ES6

Se você estiver usando o Javascript ES6, tente este método nativo para clonagem ou cópia superficial.

Object.assign({}, obj);

Supondo que você tenha apenas variáveis ​​e não funções no seu objeto, você pode apenas usar:

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

Clonagem Estruturada

O padrão HTML inclui um algoritmo interno de clonagem / serialização estruturado que pode criar clones profundos de objetos. Ele ainda é limitado a certos tipos internos, mas, além dos poucos tipos suportados pelo JSON, também suporta Datas, RegExps, Mapas, Conjuntos, Blobs, FileLists, ImageDatas, Matrizes esparsas, Matrizes digitadas e provavelmente mais no futuro . Ele também preserva referências nos dados clonados, permitindo suportar estruturas cíclicas e recursivas que causariam erros no JSON.

Suporte no Node.js: experimental 🙂

O v8módulo no Node.js atualmente (a partir do Nó 11) expõe diretamente a API de serialização estruturada , mas essa funcionalidade ainda está marcada como "experimental" e está sujeita a alterações ou remoção em versões futuras. Se você estiver usando uma versão compatível, a clonagem de um objeto é tão simples quanto:

const v8 = require('v8');

const structuredClone = obj => {
  return v8.deserialize(v8.serialize(obj));
};

Suporte direto em navegadores: talvez eventualmente? 😐

Atualmente, os navegadores não fornecem uma interface direta para o algoritmo de clonagem estruturada, mas uma structuredClone()função global foi discutida no whatwg / html # 793 no GitHub . Conforme proposto atualmente, usá-lo para a maioria dos propósitos seria tão simples quanto:

const clone = structuredClone(original);

A menos que isso seja enviado, as implementações de clones estruturados dos navegadores são expostas apenas indiretamente.

Solução alternativa assíncrona: utilizável. 😕

A maneira mais baixa de criar um clone estruturado com APIs existentes é postar os dados através de uma porta de um MessageChannels . A outra porta emitirá um messageevento com um clone estruturado do anexo .data. Infelizmente, a escuta desses eventos é necessariamente assíncrona, e as alternativas síncronas são menos práticas.

class StructuredCloner {
  constructor() {
    this.pendingClones_ = new Map();
    this.nextKey_ = 0;

    const channel = new MessageChannel();
    this.inPort_ = channel.port1;
    this.outPort_ = channel.port2;

    this.outPort_.onmessage = ({data: {key, value}}) => {
      const resolve = this.pendingClones_.get(key);
      resolve(value);
      this.pendingClones_.delete(key);
    };
    this.outPort_.start();
  }

  cloneAsync(value) {
    return new Promise(resolve => {
      const key = this.nextKey_++;
      this.pendingClones_.set(key, resolve);
      this.inPort_.postMessage({key, value});
    });
  }
}

const structuredCloneAsync = window.structuredCloneAsync =
    StructuredCloner.prototype.cloneAsync.bind(new StructuredCloner);

Exemplo de uso:

const main = async () => {
  const original = { date: new Date(), number: Math.random() };
  original.self = original;

  const clone = await structuredCloneAsync(original);

  // They're different objects:
  console.assert(original !== clone);
  console.assert(original.date !== clone.date);

  // They're cyclical:
  console.assert(original.self === original);
  console.assert(clone.self === clone);

  // They contain equivalent values:
  console.assert(original.number === clone.number);
  console.assert(Number(original.date) === Number(clone.date));

  console.log("Assertions complete.");
};

main();

Soluções síncronas: péssimas! 🤢

Não há boas opções para criar clones estruturados de forma síncrona. Aqui estão alguns truques impraticáveis.

history.pushState()e history.replaceState()ambos criam um clone estruturado de seu primeiro argumento e atribuem esse valor a history.state. Você pode usar isso para criar um clone estruturado de qualquer objeto como este:

const structuredClone = obj => {
  const oldState = history.state;
  history.replaceState(obj, null);
  const clonedObj = history.state;
  history.replaceState(oldState, null);
  return clonedObj;
};

Exemplo de uso:

'use strict';

const main = () => {
  const original = { date: new Date(), number: Math.random() };
  original.self = original;

  const clone = structuredClone(original);
  
  // They're different objects:
  console.assert(original !== clone);
  console.assert(original.date !== clone.date);

  // They're cyclical:
  console.assert(original.self === original);
  console.assert(clone.self === clone);

  // They contain equivalent values:
  console.assert(original.number === clone.number);
  console.assert(Number(original.date) === Number(clone.date));
  
  console.log("Assertions complete.");
};

const structuredClone = obj => {
  const oldState = history.state;
  history.replaceState(obj, null);
  const clonedObj = history.state;
  history.replaceState(oldState, null);
  return clonedObj;
};

main();

Embora síncrono, isso pode ser extremamente lento. Incorre em toda a sobrecarga associada à manipulação do histórico do navegador. Se você chamar esse método repetidamente, o Chrome ficará temporariamente sem resposta.

O Notificationconstrutor cria um clone estruturado de seus dados associados. Ele também tenta exibir uma notificação do navegador para o usuário, mas isso falhará silenciosamente, a menos que você tenha solicitado permissão de notificação. Caso você tenha permissão para outros fins, fecharemos imediatamente a notificação que criamos.

const structuredClone = obj => {
  const n = new Notification('', {data: obj, silent: true});
  n.onshow = n.close.bind(n);
  return n.data;
};

Exemplo de uso:

'use strict';

const main = () => {
  const original = { date: new Date(), number: Math.random() };
  original.self = original;

  const clone = structuredClone(original);
  
  // They're different objects:
  console.assert(original !== clone);
  console.assert(original.date !== clone.date);

  // They're cyclical:
  console.assert(original.self === original);
  console.assert(clone.self === clone);

  // They contain equivalent values:
  console.assert(original.number === clone.number);
  console.assert(Number(original.date) === Number(clone.date));
  
  console.log("Assertions complete.");
};

const structuredClone = obj => {
  const n = new Notification('', {data: obj, silent: true});
  n.close();
  return n.data;
};

main();

Se não houver nenhum, você pode tentar:

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;
}

A maneira eficiente de clonar (não clonar profundamente) um objeto em uma linha de código

Um Object.assignmétodo faz parte do padrão ECMAScript 2015 (ES6) e faz exatamente o que você precisa.

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

O método Object.assign () é usado para copiar os valores de todas as propriedades enumeráveis ​​de um ou mais objetos de origem para um objeto de destino.

Consulte Mais informação...

O polyfill para suportar navegadores mais antigos:

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;
    }
  });
}

Código:

// 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;
}

Teste:

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);

Isto é o que estou usando:

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;
}

Cópia profunda por desempenho: classificada da melhor à pior

• Reatribuição "=" (matrizes de cadeia, matrizes de número - apenas)
• Fatia (matrizes de cadeia, matrizes de número - apenas)
• Concatenação (matrizes de cadeia, matrizes de número - apenas)
• Função personalizada: cópia for-loop ou recursiva
• $ .extend do jQuery
• JSON.parse (matrizes de cadeia, matrizes de número, matrizes de objeto - apenas)
• Underscore.js _.clone 's (matrizes de cadeia, matrizes numéricas - apenas)
• _.CloneDeep de Lo-Dash

Copie em profundidade uma matriz de seqüências de caracteres ou números (um nível - sem ponteiros de referência):

Quando uma matriz contém números e seqüências de caracteres - funções como .slice (), .concat (), .splice (), o operador de atribuição "=" e a função de clone do Underscore.js; fará uma cópia profunda dos elementos da matriz.

Onde a reatribuição tem o desempenho mais rápido:

var arr1 = ['a', 'b', 'c'];
var arr2 = arr1;
arr1 = ['a', 'b', 'c'];

E .slice () tem melhor desempenho que .concat (), http://jsperf.com/duplicate-array-slice-vs-concat/3

var arr1 = ['a', 'b', 'c'];  // Becomes arr1 = ['a', 'b', 'c']
var arr2a = arr1.slice(0);   // Becomes arr2a = ['a', 'b', 'c'] - deep copy
var arr2b = arr1.concat();   // Becomes arr2b = ['a', 'b', 'c'] - deep copy

Cópia profunda de uma matriz de objetos (dois ou mais níveis - ponteiros de referência):

var arr1 = [{object:'a'}, {object:'b'}];

Escreva uma função personalizada (com desempenho mais rápido que $ .extend () ou JSON.parse):

function copy(o) {
   var out, v, key;
   out = Array.isArray(o) ? [] : {};
   for (key in o) {
       v = o[key];
       out[key] = (typeof v === "object" && v !== null) ? copy(v) : v;
   }
   return out;
}

copy(arr1);

Use funções utilitárias de terceiros:

$.extend(true, [], arr1); // Jquery Extend
JSON.parse(arr1);
_.cloneDeep(arr1); // Lo-dash

Onde $ .extend do jQuery tem melhor desempenho:

• http://jsperf.com/js-deep-copy/2
• http://jsperf.com/jquery-extend-vs-json-parse/2

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});

Objetos de cópia profunda em JavaScript (acho o melhor e o mais simples)

1. Usando JSON.parse (JSON.stringify (objeto));

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.Usando o método criado

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. Usando o link _.cloneDeep do Lo-Dash

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. Usando o método 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 }  

MAS ERRADO QUANDO

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.Utilizando o link Underscore.js _.clone 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 }  

MAS ERRADO QUANDO

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 Playground de Benchmarking de Desempenho 1 ~ 3 http://jsben.ch/KVQLd

Há uma biblioteca (chamada “clone”) , que faz isso muito bem. Ele fornece a clonagem / cópia recursiva mais completa de objetos arbitrários que eu conheço. Ele também suporta referências circulares, que ainda não são cobertas pelas outras respostas.

Você pode encontrá-lo também nas npm . Pode ser usado para o navegador e também para o Node.js.

Aqui está um exemplo de como usá-lo:

Instale-o com

npm install clone

ou empacotá-lo com Ender .

ender build clone [...]

Você também pode baixar o código-fonte manualmente.

Então você pode usá-lo no seu código fonte.

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' } }

(Aviso: sou o autor da biblioteca.)

Cloning Um objeto sempre foi uma preocupação em JS, mas já existia antes do ES6, listo diferentes maneiras de copiar um objeto em JavaScript abaixo, imagine que você tenha o objeto abaixo e gostaria de ter uma cópia profunda disso:

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

Existem algumas maneiras de copiar este objeto, sem alterar a origem:

1) ES5 +, usando uma função simples para fazer a cópia para você:

function deepCopyObj(obj) {
    if (null == obj || "object" != typeof obj) return obj;
    if (obj instanceof Date) {
        var copy = new Date();
        copy.setTime(obj.getTime());
        return copy;
    }
    if (obj instanceof Array) {
        var copy = [];
        for (var i = 0, len = obj.length; i < len; i++) {
            copy[i] = cloneSO(obj[i]);
        }
        return copy;
    }
    if (obj instanceof Object) {
        var copy = {};
        for (var attr in obj) {
            if (obj.hasOwnProperty(attr)) copy[attr] = cloneSO(obj[attr]);
        }
        return copy;
    }
    throw new Error("Unable to copy obj this object.");
}

2) ES5 +, usando JSON.parse e JSON.stringify.

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

3) AngularJs:

var  deepCopyObj = angular.copy(obj);

4) jQuery:

var deepCopyObj = jQuery.extend(true, {}, obj);

5) SublinhadoJs & Loadash:

var deepCopyObj = _.cloneDeep(obj); //latest version UndescoreJs makes shallow copy

Espero que estas ajudem ...

Sei que este é um post antigo, mas achei que isso poderia ser de alguma ajuda para a próxima pessoa que tropeçar.

Contanto que você não atribua um objeto a nada, ele não mantém referência na memória. Portanto, para criar um objeto que você deseja compartilhar entre outros objetos, você precisará criar uma fábrica como esta:

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

Se você estiver usando, a biblioteca Underscore.js possui um método clone .

var newObject = _.clone(oldObject);

Aqui está uma versão da resposta de ConroyP acima que funciona mesmo que o construtor tenha exigido parâmetros:

//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;
}

Esta função também está disponível na minha biblioteca simpleoo .

Editar:

Aqui está uma versão mais robusta (graças a Justin McCandless, agora isso também suporta referências cíclicas):

/**
 * 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();
    };
}

A seguir, são criadas duas instâncias do mesmo objeto. Eu encontrei e estou usando atualmente. É simples e fácil de usar.

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

Crockford sugere (e eu prefiro) usar esta função:

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

var newObject = object(oldObject);

É conciso, funciona como esperado e você não precisa de uma biblioteca.

EDITAR:

Este é um polyfill para Object.create, portanto, você também pode usá-lo.

var newObject = Object.create(oldObject);

NOTA: Se você usar um pouco disso, poderá ter problemas com alguma iteração usada hasOwnProperty. Porque, createcrie um novo objeto vazio que herda oldObject. Mas ainda é útil e prático para clonar objetos.

Por exemplo, se oldObject.a = 5;

newObject.a; // is 5

mas:

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

O Lodash possui um bom método _.cloneDeep (value) :

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

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

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

Cópia única de uma cópia ( ECMAScript 5th edition ):

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

Uma cópia simples e rasa ( ECMAScript 6ª edição , 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

Só porque eu não vi o AngularJS mencionado e pensei que as pessoas poderiam querer saber ...

angular.copy também fornece um método de cópia profunda de objetos e matrizes.

Parece ainda não haver um operador de clone profundo ideal para objetos do tipo array. Como o código abaixo ilustra, o clonador jQuery de John Resig transforma matrizes com propriedades não numéricas em objetos que não são matrizes e o clonador JSON do RegDwight remove as propriedades não numéricas. Os testes a seguir ilustram esses pontos em vários navegadores:

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)

Eu tenho duas boas respostas, dependendo se seu objetivo é clonar um "objeto JavaScript antigo simples" ou não.

Vamos supor também que sua intenção é criar um clone completo sem referências de protótipo para o objeto de origem. Se você não estiver interessado em um clone completo, poderá usar muitas das rotinas Object.clone () fornecidas em algumas das outras respostas (padrão de Crockford).

Para objetos JavaScript simples e antigos, uma boa maneira de clonar um objeto em tempos de execução modernos é muito simples:

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

Observe que o objeto de origem deve ser um objeto JSON puro. Isto é, todas as suas propriedades aninhadas devem ser escalares (como booleano, string, array, objeto, etc.). Quaisquer funções ou objetos especiais como RegExp ou Date não serão clonados.

É eficiente? Claro que sim. Tentamos todos os tipos de métodos de clonagem e isso funciona melhor. Tenho certeza que algum ninja poderia invocar um método mais rápido. Mas suspeito que estamos falando de ganhos marginais.

Essa abordagem é simples e fácil de implementar. Envolva-o em uma função de conveniência e, se você realmente precisar obter algum ganho, tente mais tarde.

Agora, para objetos JavaScript não comuns, não há uma resposta realmente simples. De fato, não pode haver por causa da natureza dinâmica das funções JavaScript e do estado interno do objeto. A clonagem profunda de uma estrutura JSON com funções internas requer que você recrie essas funções e seu contexto interno. E o JavaScript simplesmente não tem uma maneira padronizada de fazer isso.

A maneira correta de fazer isso, mais uma vez, é através de um método de conveniência que você declara e reutiliza dentro do seu código. O método de conveniência pode ser dotado de alguma compreensão de seus próprios objetos, para que você possa recriar adequadamente o gráfico dentro do novo objeto.

Nós escrevemos por conta própria, mas a melhor abordagem geral que já vi é abordada aqui:

http://davidwalsh.name/javascript-clone

Essa é a ideia certa. O autor (David Walsh) comentou a clonagem de funções generalizadas. Isso é algo que você pode optar por fazer, dependendo do seu caso de uso.

A idéia principal é que você precisa lidar especialmente com a instanciação de suas funções (ou classes prototípicas, por assim dizer) por tipo. Aqui, ele forneceu alguns exemplos para RegExp e Date.

Este código não é apenas breve, mas também é muito legível. É bem fácil de estender.

Isso é eficiente? Claro que sim. Como o objetivo é produzir um verdadeiro clone de cópia profunda, você precisará percorrer os membros do gráfico do objeto de origem. Com essa abordagem, você pode ajustar exatamente quais membros filhos tratar e como lidar manualmente com tipos personalizados.

Então lá vai você. Duas abordagens. Ambos são eficientes na minha opinião.

Geralmente, essa não é a solução mais eficiente, mas faz o que eu preciso. Casos de teste simples abaixo ...

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;
}

Teste de matriz cíclica ...

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

Teste de funcionamento...

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

AngularJS

Bem, se você estiver usando angular, você também pode fazer isso

var newObject = angular.copy(oldObject);

Discordo da resposta com os melhores votos aqui . Um Deep Clone recursivo é muito mais rápido que a abordagem JSON.parse (JSON.stringify (obj)) mencionada.

• O Jsperf classifica o número um aqui: https://jsperf.com/deep-copy-vs-json-stringify-json-parse/5
• Jsben da resposta acima foi atualizado para mostrar que um clone profundo recursivo supera todos os outros mencionados: http://jsben.ch/13YKQ

E aqui está a função para referência rápida:

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
}

// 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;
};

Somente quando você pode usar o ECMAScript 6 ou transpilers .

Recursos:

• Não acionará o getter / setter durante a cópia.
• Preserva o getter / setter.
• Preserva informações de protótipo.
• Funciona com estilos de escrita OO literal e objeto- funcional .

Código:

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;
}

Aqui está um método abrangente clone () que pode clonar qualquer objeto JavaScript. Ele lida com quase todos os casos:

function clone(src, deep) {

    var toString = Object.prototype.toString;
    if (!src && typeof src != "object") {
        // Any non-object (Boolean, String, Number), null, undefined, NaN
        return src;
    }

    // Honor native/custom clone methods
    if (src.clone && toString.call(src.clone) == "[object Function]") {
        return src.clone(deep);
    }

    // DOM elements
    if (src.nodeType && toString.call(src.cloneNode) == "[object Function]") {
        return src.cloneNode(deep);
    }

    // Date
    if (toString.call(src) == "[object Date]") {
        return new Date(src.getTime());
    }

    // RegExp
    if (toString.call(src) == "[object RegExp]") {
        return new RegExp(src);
    }

    // Function
    if (toString.call(src) == "[object Function]") {

        //Wrap in another method to make sure == is not true;
        //Note: Huge performance issue due to closures, comment this :)
        return (function(){
            src.apply(this, arguments);
        });
    }

    var ret, index;
    //Array
    if (toString.call(src) == "[object Array]") {
        //[].slice(0) would soft clone
        ret = src.slice();
        if (deep) {
            index = ret.length;
            while (index--) {
                ret[index] = clone(ret[index], true);
            }
        }
    }
    //Object
    else {
        ret = src.constructor ? new src.constructor() : {};
        for (var prop in src) {
            ret[prop] = deep
                ? clone(src[prop], true)
                : src[prop];
        }
    }
    return ret;
};