Si no usa Dates, funciones, undefined, regExp o Infinity dentro de su objeto, un revestimiento muy simple es 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()

Esto funciona para todo tipo de objetos que contienen objetos, matrices, cadenas, booleanos y números.

Consulte también este artículo sobre el algoritmo de clonación estructurado de los navegadores que se utiliza al publicar mensajes desde y hacia un trabajador. También contiene una función para la clonación profunda.

Con jQuery, puede copiar poco con extend :

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

los cambios posteriores a la copiedObjectno afectarán a la originalObject, y viceversa.

O para hacer una copia profunda :

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

En ECMAScript 6 existe el método Object.assign , que copia los valores de todas las propiedades propias enumerables de un objeto a otro. Por ejemplo:

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

Pero tenga en cuenta que los objetos anidados todavía se copian como referencia.

Por MDN :

• Si desea una copia superficial, use Object.assign({}, a)
• Para una copia "profunda", use JSON.parse(JSON.stringify(a))

No hay necesidad de bibliotecas externas, pero primero debe verificar la compatibilidad del navegador .

Hay muchas respuestas, pero ninguna que menciona Object.create de ECMAScript 5, que ciertamente no le da una copia exacta, pero establece la fuente como el prototipo del nuevo objeto.

Por lo tanto, esta no es una respuesta exacta a la pregunta, pero es una solución de una línea y, por lo tanto, elegante. Y funciona mejor para 2 casos:

1. Donde tal herencia es útil (duh!)
2. Donde el objeto fuente no se modificará, lo que hace que la relación entre los 2 objetos no sea un problema.

Ejemplo:

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 qué considero que esta solución es superior? Es nativo, por lo tanto, sin bucles ni recursiones. Sin embargo, los navegadores más antiguos necesitarán un polyfill.

Una forma elegante de clonar un objeto Javascript en una línea de código

Un Object.assignmétodo es parte del estándar ECMAScript 2015 (ES6) y hace exactamente lo que necesita.

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

El método Object.assign () se utiliza para copiar los valores de todas las propiedades propias enumerables de uno o más objetos de origen a un objeto de destino.

Lee mas...

El polyfill para admitir navegadores antiguos:

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

Existen varios problemas con la mayoría de las soluciones en Internet. Así que decidí hacer un seguimiento, que incluye, por qué la respuesta aceptada no debería aceptarse.

situación inicial

Quiero copiar en profundidad un Javascript Objectcon todos sus hijos y sus hijos, etc. Pero como no soy un desarrollador normal, mi Objecttiene normal properties , circular structurese inclusonested objects .

Así que creemos un circular structurey un nested objectprimero.

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

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

Vamos a juntar todo en un Objectnombre a.

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

A continuación, queremos copiar aen una variable llamada by mutarla.

var b = a;

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

Sabes lo que pasó aquí porque si no, ni siquiera aterrizarías en esta gran pregunta.

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

Ahora encontremos una solución.

JSON

El primer intento que intenté fue usar JSON.

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

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

No pierdas demasiado tiempo en ello, obtendrás TypeError: Converting circular structure to JSON .

Copia recursiva (la "respuesta" aceptada)

Echemos un vistazo a la respuesta aceptada.

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

Se ve bien, ¿eh? Es una copia recursiva del objeto y también maneja otros tipos, como Date, pero eso no era un requisito.

var b = cloneSO(a);

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

Recursión y circular structuresno funciona bien juntos ...RangeError: Maximum call stack size exceeded

solución nativa

Después de discutir con mi compañero de trabajo, mi jefe nos preguntó qué pasó y encontró una solución simple después de buscar en Google. Se llama Object.create.

var b = Object.create(a);

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

Esta solución se agregó a Javascript hace algún tiempo e incluso se maneja 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"
    }
}

... y ves, no funcionaba con la estructura anidada adentro.

polyfill para la solución nativa

Hay un polyfill para Object.createel navegador anterior como el IE 8. Es algo como lo recomienda Mozilla, y por supuesto, no es perfecto y da como resultado el mismo problema que la solución nativa .

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

var b = clonePF(a);

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

Lo he puesto Ffuera del alcance para que podamos echar un vistazo a lo que instanceofnos dice.

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

Mismo problema que la solución nativa , pero un poco peor de salida.

la mejor (pero no perfecta) solución

Al investigar, encontré una pregunta similar ( en Javascript, al realizar una copia profunda, ¿cómo evito un ciclo, debido a que una propiedad es "esto"? ) A esta, pero con una solución mucho mejor.

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

Y echemos un vistazo a la salida ...

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

Los requisitos coinciden, pero todavía hay algunos problemas menores, incluido el cambio instancede nestedy circhacia Object.

La estructura de los árboles que comparten una hoja no se copiará, se convertirán en dos hojas independientes:

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

conclusión

La última solución que utiliza recursividad y un caché, puede no ser la mejor, pero es una copia profunda real del objeto. Maneja sencilla properties, circular structuresy nested object, pero se hace un lío la instancia de ellos durante la clonación.

jsfiddle

Si está de acuerdo con una copia superficial, la biblioteca underscore.js tiene un método de clonación .

y = _.clone(x);

o puedes extenderlo como

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

OK, imagina que tienes este objeto a continuación y quieres clonarlo:

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

o

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

la respuesta depende principalmente de qué ECMAscript está usando, ES6+simplemente puede usar Object.assignpara hacer el clon:

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

o usando un operador de propagación como este:

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

Pero si usa ES5, puede usar algunos métodos, pero JSON.stringifyasegúrese de no usar una gran cantidad de datos para copiar, pero podría ser una línea útil en muchos casos, algo como esto:

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

Una solución particularmente poco elegante es usar la codificación JSON para hacer copias profundas de objetos que no tienen métodos miembros. La metodología es codificar JSON su objeto de destino, luego al decodificarlo, obtiene la copia que está buscando. Puede decodificar tantas veces como desee para hacer tantas copias como necesite.

Por supuesto, las funciones no pertenecen a JSON, por lo que esto solo funciona para objetos sin métodos miembro.

Esta metodología fue perfecta para mi caso de uso, ya que estoy almacenando blobs JSON en un almacén de valores clave, y cuando se exponen como objetos en una API de JavaScript, cada objeto en realidad contiene una copia del estado original del objeto, por lo que puede calcular el delta después de que la persona que llama ha mutado el objeto expuesto.

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

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

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

Simplemente puede usar una propiedad de propagación para copiar un objeto sin referencias. Pero tenga cuidado (vea los comentarios), la 'copia' está justo en el nivel más bajo de objeto / matriz. ¡Las propiedades anidadas siguen siendo referencias!

Clon completo:

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

// => mutate without references:

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

Clon con referencias en segundo nivel:

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 en realidad no admite clones profundos de forma nativa. Use una función de utilidad. Por ejemplo Ramda:

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

Para aquellos que usan AngularJS, también hay un método directo para clonar o extender los objetos en esta biblioteca.

var destination = angular.copy(source);

o

angular.copy(source, destination);

Más en la documentación de angular.copy ...

Aquí hay una función que puede 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;
}

La respuesta de R. Levy está casi completa, aquí está mi pequeña contribución: hay una manera de manejar referencias recursivas , vea esta línea

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

Si el objeto es un elemento DOM XML, debemos usar cloneNode en su lugar

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

Inspirado por el exhaustivo estudio de A.Levy y el enfoque de creación de prototipos de Calvin, ofrezco esta solución:

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

Ver también la nota de Andy Burke en las respuestas.

De este artículo: Cómo copiar matrices y objetos en 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;
};

En ES-6 simplemente puede usar Object.assign (...). Ex:

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

Una buena referencia está aquí: https://googlechrome.github.io/samples/object-assign-es6/

En ECMAScript 2018

let objClone = { ...obj };

Tenga en cuenta que los objetos anidados todavía se copian como referencia.

Usando Lodash:

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

Interesado en clonar objetos simples:

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

Fuente: ¿Cómo copiar un objeto JavaScript a una nueva variable NO por referencia?

Puede clonar un objeto y eliminar cualquier referencia del anterior utilizando una sola línea de código. Simplemente haz:

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 los navegadores / motores que actualmente no admiten Object.create, puede 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();
    };
}

Nueva respuesta a una vieja pregunta! Si tiene el placer de usar ECMAScript 2016 (ES6) con Spread Syntax , es fácil.

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

Esto proporciona un método limpio para una copia superficial de un objeto. Hacer una copia profunda, lo que significa hacer una nueva copia de cada valor en cada objeto anidado recursivamente, requiere una de las soluciones más pesadas anteriores.

JavaScript sigue evolucionando.