Se você não usar Dates, functions, undefined, regExp ou Infinity dentro do seu objeto, um liner muito simples é 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'
}
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()

Isso funciona para todos os tipos de objetos que contêm objetos, matrizes, strings, booleanos e números.

Consulte também este artigo sobre o algoritmo de clone estruturado de navegadores usado ao postar mensagens para e de um trabalhador. Ele também contém uma função para clonagem profunda.

Com o jQuery, você pode copiar superficialmente com estender :

var copiedObject = jQuery.extend({}, originalObject)

alterações subseqüentes no copiedObjectnão afetarão o originalObjecte vice-versa.

Ou para fazer uma cópia profunda :

var copiedObject = jQuery.extend(true, {}, originalObject)

No ECMAScript 6, existe o método Object.assign , que copia valores de todas as propriedades próprias enumeráveis ​​de um objeto para outro. Por exemplo:

var x = {myProp: "value"};
var y = Object.assign({}, x); 

Mas esteja ciente de que objetos aninhados ainda são copiados como referência.

Por MDN :

• Se você deseja uma cópia superficial, use Object.assign({}, a)
• Para cópia "profunda", use JSON.parse(JSON.stringify(a))

Não há necessidade de bibliotecas externas, mas é necessário verificar primeiro a compatibilidade do navegador .

Existem muitas respostas, mas nenhuma menciona Object.create do ECMAScript 5, que reconhecidamente não fornece uma cópia exata, mas define a fonte como o protótipo do novo objeto.

Portanto, essa não é uma resposta exata para a pergunta, mas é uma solução de uma linha e, portanto, elegante. E funciona melhor em 2 casos:

1. Onde tal herança é útil (duh!)
2. Onde o objeto de origem não será modificado, tornando a relação entre os dois objetos um problema.

Exemplo:

var foo = { a : 1 };
var bar = Object.create(foo);
foo.a; // 1
bar.a; // 1
foo.a = 2;
bar.a; // 2 - prototype changed
bar.a = 3;
foo.a; // Still 2, since setting bar.a makes it an "own" property

Por que considero esta solução superior? É nativo, portanto, sem loop, sem recursão. No entanto, navegadores mais antigos precisarão de um polyfill.

Uma maneira elegante de clonar um objeto Javascript 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;
    }
  });
}

Existem vários problemas com a maioria das soluções na internet. Então, decidi fazer um acompanhamento, que inclui por que a resposta aceita não deveria ser aceita.

situação inicial

Quero copiar em profundidade um Javascript Objectcom todos os seus filhos e seus filhos e assim por diante. Mas desde que eu não sou um tipo de desenvolvedor normal, a minha Objecttem normais properties , circular structurese mesmo nested objects.

Então, vamos criar um circular structuree um nested objectprimeiro.

function Circ() {
    this.me = this;
}

function Nested(y) {
    this.y = y;
}

Vamos reunir tudo em um Objectnome a.

var a = {
    x: 'a',
    circ: new Circ(),
    nested: new Nested('a')
};

Em seguida, queremos copiar apara uma variável chamada be modificá-la.

var b = a;

b.x = 'b';
b.nested.y = 'b';

Você sabe o que aconteceu aqui, porque senão você nem chegaria a essa grande questão.

console.log(a, b);

a --> Object {
    x: "b",
    circ: Circ {
        me: Circ { ... }
    },
    nested: Nested {
        y: "b"
    }
}

b --> Object {
    x: "b",
    circ: Circ {
        me: Circ { ... }
    },
    nested: Nested {
        y: "b"
    }
}

Agora vamos encontrar uma solução.

JSON

A primeira tentativa que tentei foi usar JSON.

var b = JSON.parse( JSON.stringify( a ) );

b.x = 'b';
b.nested.y = 'b';

Não perca muito tempo com isso, você receberá TypeError: Converting circular structure to JSON.

Cópia recursiva (a "resposta" aceita)

Vamos dar uma olhada na resposta aceita.

function cloneSO(obj) {
    // Handle the 3 simple types, and null or undefined
    if (null == obj || "object" != typeof obj) 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, len = obj.length; i < len; i++) {
            copy[i] = cloneSO(obj[i]);
        }
        return copy;
    }

    // Handle Object
    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! Its type isn't supported.");
}

Parece bom, hein? É uma cópia recursiva do objeto e também lida com outros tipos Date, mas isso não era um requisito.

var b = cloneSO(a);

b.x = 'b';
b.nested.y = 'b';

Recursão e circular structuresnão funciona bem em conjunto ...RangeError: Maximum call stack size exceeded

solução nativa

Depois de discutir com meu colega de trabalho, meu chefe nos perguntou o que havia acontecido e ele encontrou uma solução simples depois de pesquisar no Google. É chamado Object.create.

var b = Object.create(a);

b.x = 'b';
b.nested.y = 'b';

Esta solução foi adicionada ao Javascript há algum tempo e até lida com circular structure.

console.log(a, b);

a --> Object {
    x: "a",
    circ: Circ {
        me: Circ { ... }
    },
    nested: Nested {
        y: "b"
    }
}

b --> Object {
    x: "b",
    circ: Circ {
        me: Circ { ... }
    },
    nested: Nested {
        y: "b"
    }
}

... e veja bem, não funcionou com a estrutura aninhada dentro.

polyfill para a solução nativa

Existe um polyfill Object.createno navegador mais antigo, assim como o IE 8. É algo como recomendado pelo Mozilla e, é claro, não é perfeito e resulta no mesmo problema da solução nativa .

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

var b = clonePF(a);

b.x = 'b';
b.nested.y = 'b';

Eu coloquei Ffora do escopo para que possamos dar uma olhada no que instanceofnos diz.

console.log(a, b);

a --> Object {
    x: "a",
    circ: Circ {
        me: Circ { ... }
    },
    nested: Nested {
        y: "b"
    }
}

b --> F {
    x: "b",
    circ: Circ {
        me: Circ { ... }
    },
    nested: Nested {
        y: "b"
    }
}

console.log(typeof a, typeof b);

a --> object
b --> object

console.log(a instanceof Object, b instanceof Object);

a --> true
b --> true

console.log(a instanceof F, b instanceof F);

a --> false
b --> true

Mesmo problema que a solução nativa , mas saída um pouco pior.

a melhor solução (mas não perfeita)

Ao pesquisar, encontrei uma pergunta semelhante ( em Javascript, ao executar uma cópia em profundidade, como evito um ciclo, devido a uma propriedade ser "isto"? ), Mas com uma solução muito melhor.

function cloneDR(o) {
    const gdcc = "__getDeepCircularCopy__";
    if (o !== Object(o)) {
        return o; // primitive value
    }

    var set = gdcc in o,
        cache = o[gdcc],
        result;
    if (set && typeof cache == "function") {
        return cache();
    }
    // else
    o[gdcc] = function() { return result; }; // overwrite
    if (o instanceof Array) {
        result = [];
        for (var i=0; i<o.length; i++) {
            result[i] = cloneDR(o[i]);
        }
    } else {
        result = {};
        for (var prop in o)
            if (prop != gdcc)
                result[prop] = cloneDR(o[prop]);
            else if (set)
                result[prop] = cloneDR(cache);
    }
    if (set) {
        o[gdcc] = cache; // reset
    } else {
        delete o[gdcc]; // unset again
    }
    return result;
}

var b = cloneDR(a);

b.x = 'b';
b.nested.y = 'b';

E vamos dar uma olhada na saída ...

console.log(a, b);

a --> Object {
    x: "a",
    circ: Object {
        me: Object { ... }
    },
    nested: Object {
        y: "a"
    }
}

b --> Object {
    x: "b",
    circ: Object {
        me: Object { ... }
    },
    nested: Object {
        y: "b"
    }
}

console.log(typeof a, typeof b);

a --> object
b --> object

console.log(a instanceof Object, b instanceof Object);

a --> true
b --> true

console.log(a instanceof F, b instanceof F);

a --> false
b --> false

Os requisitos são atendidos, mas ainda existem alguns problemas menores, incluindo a alteração instancede nestede circpara Object.

A estrutura das árvores que compartilham uma folha não será copiada, elas se tornarão duas folhas independentes:

        [Object]                     [Object]
         /    \                       /    \
        /      \                     /      \
      |/_      _\|                 |/_      _\|  
  [Object]    [Object]   ===>  [Object]    [Object]
       \        /                 |           |
        \      /                  |           |
        _\|  |/_                 \|/         \|/
        [Object]               [Object]    [Object]

conclusão

A última solução usando recursão e um cache, pode não ser o melhor, mas é um verdadeiro deep-cópia do objeto. Ele lida com simples properties, circular structurese nested object, mas vai atrapalhar a instância deles durante a clonagem.

jsfiddle

Se você concorda com uma cópia superficial, a biblioteca underscore.js possui um método clone .

y = _.clone(x);

ou você pode estendê-lo como

copiedObject = _.extend({},originalObject);

OK, imagine que você tem este objeto abaixo e deseja cloná-lo:

let obj = {a:1, b:2, c:3}; //ES6

ou

var obj = {a:1, b:2, c:3}; //ES5

a resposta depende principalmente de qual ECMAscript você está usando, ES6+pode simplesmente usar Object.assigno clone:

let cloned = Object.assign({}, obj); //new {a:1, b:2, c:3};

ou usando o operador spread como este:

let cloned = {...obj}; //new {a:1, b:2, c:3};

Mas se você estiver usando ES5, poderá usar alguns métodos, mas o JSON.stringify, apenas certifique-se de não usar uma grande quantidade de dados para copiar, mas em muitos casos pode ser uma maneira útil de uma linha:

let cloned = JSON.parse(JSON.stringify(obj)); 
//new {a:1, b:2, c:3};, can be handy, but avoid using on big chunk of data over and over

Uma solução particularmente deselegante é usar a codificação JSON para fazer cópias profundas de objetos que não possuem métodos de membro. A metodologia é codificar JSON seu objeto de destino e, ao decodificá-lo, você obtém a cópia que está procurando. Você pode decodificar quantas vezes quiser para fazer quantas cópias precisar.

Obviamente, as funções não pertencem ao JSON, portanto, isso funciona apenas para objetos sem métodos de membro.

Essa metodologia foi perfeita para o meu caso de uso, pois estou armazenando blobs JSON em um armazenamento de valor-chave e, quando eles são expostos como objetos em uma API JavaScript, cada objeto na verdade contém uma cópia do estado original do objeto, para que possamos pode calcular o delta após o chamador ter alterado o objeto exposto.

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

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

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

Você pode simplesmente usar uma propriedade de spread para copiar um objeto sem referências. Mas tenha cuidado (consulte os comentários), a 'cópia' está apenas no nível mais baixo de objeto / matriz. Propriedades aninhadas ainda são referências!

Clone completo:

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

// => mutate without references:

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

Clone com referências no segundo nível:

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

// => nested object is still a references:

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

Na verdade, o JavaScript não suporta nativamente clones profundos. Use uma função utilitária. Por exemplo Ramda:

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

Para aqueles que usam AngularJS, também há um método direto para clonar ou estender os objetos nesta biblioteca.

var destination = angular.copy(source);

ou

angular.copy(source, destination);

Mais na documentação do angular.copy ...

Aqui está uma função que você pode usar.

function clone(obj) {
    if(obj == null || typeof(obj) != 'object')
        return obj;    
    var temp = new obj.constructor(); 
    for(var key in obj)
        temp[key] = clone(obj[key]);    
    return temp;
}

A. A resposta de Lucy está quase completa, aqui está minha pequena contribuição: existe uma maneira de lidar com referências recursivas , veja esta linha

if(this[attr]==this) copy[attr] = copy;

Se o objeto for XML elemento DOM, devemos usar cloneNode vez

if(this.cloneNode) return this.cloneNode(true);

Inspirado no estudo exaustivo de A.Levy e na abordagem de prototipagem de Calvin, ofereço esta solução:

Object.prototype.clone = function() {
  if(this.cloneNode) return this.cloneNode(true);
  var copy = this instanceof Array ? [] : {};
  for(var attr in this) {
    if(typeof this[attr] == "function" || this[attr]==null || !this[attr].clone)
      copy[attr] = this[attr];
    else if(this[attr]==this) copy[attr] = copy;
    else copy[attr] = this[attr].clone();
  }
  return copy;
}

Date.prototype.clone = function() {
  var copy = new Date();
  copy.setTime(this.getTime());
  return copy;
}

Number.prototype.clone = 
Boolean.prototype.clone =
String.prototype.clone = function() {
  return this;
}

Veja também a nota de Andy Burke nas respostas.

Neste artigo: Como copiar matrizes e objetos em Javascript por Brian Huisman:

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

No ES-6, você pode simplesmente usar Object.assign (...). Ex:

let obj = {person: 'Thor Odinson'};
let clone = Object.assign({}, obj);

Uma boa referência está aqui: https://googlechrome.github.io/samples/object-assign-es6/

No ECMAScript 2018

let objClone = { ...obj };

Esteja ciente de que objetos aninhados ainda são copiados como referência.

Usando o Lodash:

var y = _.clone(x, true);

Interessado em clonar objetos simples:

JSON.parse(JSON.stringify(json_original));

Fonte: Como copiar o objeto JavaScript para a nova variável, NÃO por referência?

Você pode clonar um objeto e remover qualquer referência da anterior usando uma única linha de código. Simplesmente faça:

var obj1 = { text: 'moo1' };
var obj2 = Object.create(obj1); // Creates a new clone without references

obj2.text = 'moo2'; // Only updates obj2's text property

console.log(obj1, obj2); // Outputs: obj1: {text:'moo1'}, obj2: {text:'moo2'}

Para navegadores / mecanismos que atualmente não oferecem suporte ao Object.create, você pode usar este polyfill:

// Polyfill Object.create if it does not exist
if (!Object.create) {
    Object.create = function (o) {
        var F = function () {};
        F.prototype = o;
        return new F();
    };
}

Nova resposta para uma pergunta antiga! Se você tem o prazer de usar o ECMAScript 2016 (ES6) com a Spread Syntax , é fácil.

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

Isso fornece um método limpo para uma cópia superficial de um objeto. Fazer uma cópia profunda, significando criar uma nova cópia de todos os valores em todos os objetos aninhados recursivamente, requer uma das soluções mais pesadas acima.

JavaScript continua evoluindo.