Clonación de un objeto en Node.js

¿Cuál es la mejor manera de clonar un objeto en node.js?

Por ejemplo, quiero evitar la situación en la que:

var obj1 = {x: 5, y:5};
var obj2 = obj1;
obj2.x = 6;
console.log(obj1.x); // logs 6

El objeto puede contener tipos complejos como atributos, por lo que un simple para (var x en obj1) no resolvería. ¿Necesito escribir un clon recursivo yo mismo o hay algo incorporado que no estoy viendo?

Posibilidad 1

Copia profunda de bajo costo:

var obj2 = JSON.parse(JSON.stringify(obj1));

Posibilidad 2 (en desuso)

Atención: esta solución ahora está marcada como obsoleta en la documentación de Node.js :

El método util._extend () nunca fue diseñado para usarse fuera de los módulos internos de Node.js. La comunidad lo encontró y lo usó de todos modos.

Está en desuso y no debe usarse en un código nuevo. JavaScript viene con una funcionalidad incorporada muy similar a través de Object.assign ().

Respuesta original :

Para una copia superficial, use la función incorporada de Node util._extend().

var extend = require('util')._extend;

var obj1 = {x: 5, y:5};
var obj2 = extend({}, obj1);
obj2.x = 6;
console.log(obj1.x); // still logs 5

El código fuente de la _extendfunción de Node está aquí: https://github.com/joyent/node/blob/master/lib/util.js

exports._extend = function(origin, add) {
  // Don't do anything if add isn't an object
  if (!add || typeof add !== 'object') return origin;

  var keys = Object.keys(add);
  var i = keys.length;
  while (i--) {
    origin[keys[i]] = add[keys[i]];
  }
  return origin;
};

Me sorprende que Object.assignno se haya mencionado.

let cloned = Object.assign({}, source);

Si está disponible (por ejemplo, Babel), puede usar el operador de propagación de objetos :

let cloned = { ... source };

Object.defineProperty(Object.prototype, "extend", {
    enumerable: false,
    value: function(from) {
        var props = Object.getOwnPropertyNames(from);
        var dest = this;
        props.forEach(function(name) {
            if (name in dest) {
                var destination = Object.getOwnPropertyDescriptor(from, name);
                Object.defineProperty(dest, name, destination);
            }
        });
        return this;
    }
});

Esto definirá un método extendido que puede usar. El código proviene de este artículo.

var obj2 = JSON.parse(JSON.stringify(obj1));

Puede usar la función extender de JQuery:

var newClone= jQuery.extend({}, oldObject);  
var deepClone = jQuery.extend(true, {}, oldObject); 

También hay un complemento Node.js:

https://github.com/shimondoodkin/nodejs-clone-extend

Para hacerlo sin JQuery o Plugin, lea esto aquí:

http://my.opera.com/GreyWyvern/blog/show.dml/1725165

Echa un vistazo a underscore.js . Tiene tanto clonar como extender y muchas otras funciones muy útiles.

Esto puede ser útil: Usar el módulo subrayado con Node.js

Hay algunos módulos de Nodo por ahí si no quieres "rodar el tuyo". Este se ve bien: https://www.npmjs.com/package/clone

Parece que maneja todo tipo de cosas, incluidas las referencias circulares. Desde la página de github :

Clone Master Clonación de objetos, matrices, objetos de fecha y objetos RegEx. Todo se clona de forma recursiva, por lo que puede clonar fechas en matrices en objetos, por ejemplo. [...] ¿Referencias circulares? ¡Sí!

Este código también funciona porque el método Object.create () crea un nuevo objeto con el objeto prototipo y las propiedades especificadas.

var obj1 = {x:5, y:5};

var obj2 = Object.create(obj1);

obj2.x; //5
obj2.x = 6;
obj2.x; //6

obj1.x; //5

La manera más simple y rápida de clonar un objeto en NodeJS es usar el método Object.keys (obj)

var a = {"a": "a11", "b": "avc"};
var b;

for(var keys = Object.keys(a), l = keys.length; l; --l)
{
   b[ keys[l-1] ] = a[ keys[l-1] ];
}
b.a = 0;

console.log("a: " + JSON.stringify(a)); // LOG: a: {"a":"a11","b":"avc"} 
console.log("b: " + JSON.stringify(b)); // LOG: b: {"a":0,"b":"avc"}

El método Object.keys requiere JavaScript 1.8.5; nodeJS v0.4.11 admite este método

pero, por supuesto, para los objetos anidados es necesario implementar funciones recursivas

Otra solución es usar JSON nativo (implementado en JavaScript 1.7), pero es mucho más lento (~ 10 veces más lento) que el anterior

var a = {"a": i, "b": i*i};
var b = JSON.parse(JSON.stringify(a));
b.a = 0;

También hay un proyecto en Github que pretende ser un puerto más directo de jQuery.extend():

https://github.com/dreamerslab/node.extend

Un ejemplo, modificado de los documentos de jQuery :

var extend = require('node.extend');

var object1 = {
    apple: 0,
    banana: {
        weight: 52,
        price: 100
    },
    cherry: 97
};

var object2 = {
    banana: {
        price: 200
    },
    durian: 100
};

var merged = extend(object1, object2);

Hay otra biblioteca lodash , tiene clone y cloneDeep , también muchas otras funciones útiles.

Todos sufren pero la solución es simple.

var obj1 = {x: 5, y:5};

var obj2 = {...obj1}; // Boom

Buscando una verdadera opción de clonación, me topé con el enlace de ridcully aquí:

http://my.opera.com/GreyWyvern/blog/show.dml/1725165

Modifiqué la solución en esa página para que la función asociada al Objectprototipo no sea enumerable. Aquí está mi resultado:

Object.defineProperty(Object.prototype, 'clone', {
    enumerable: false,
    value: function() {
        var newObj = (this instanceof Array) ? [] : {};
        for (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;
    }
});

Esperemos que esto ayude a alguien más también. Tenga en cuenta que hay algunas advertencias ... particularmente con las propiedades llamadas "clon". Esto funciona bien para mi. No tomo ningún crédito por escribirlo. Nuevamente, solo cambié la forma en que se estaba definiendo.

También puede usar SugarJS en NodeJS.

http://sugarjs.com/

Tienen una función de clonación muy limpia: http://sugarjs.com/api/Object/clone

Si está utilizando coffee-script, es tan fácil como:

newObject = {}
newObject[key] = value  for own key,value of oldObject

Aunque este no es un clon profundo.

Ninguna de las respuestas me satisfizo, varias no funcionan o son clones poco profundos, las respuestas de @ clint-harris y el uso de JSON.parse / stringify son buenas pero bastante lentas. Encontré un módulo que hace una clonación profunda rápidamente: https://github.com/AlexeyKupershtokh/node-v8-clone

No hay una forma integrada de hacer un clon real (copia profunda) de un objeto en node.js. Hay algunos casos extremos complicados, por lo que definitivamente debe usar una biblioteca para esto. Escribí una función para mi biblioteca simpleoo . Puedes usar eldeepCopy función sin usar nada más de la biblioteca (que es bastante pequeña) si no la necesita. Esta función admite la clonación de múltiples tipos de datos, incluidas matrices, fechas y expresiones regulares, admite referencias recursivas y también funciona con objetos cuyas funciones de constructor tienen los parámetros necesarios.

Aquí está el código:

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

/**
 * 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 = function deepCopy(src, /* INTERNAL */ _visited) {
    if(src == null || typeof(src) !== 'object'){
        return src;
    }

    // Initialize the visited objects array if needed
    // This is used to detect cyclic references
    if (_visited == undefined){
        _visited = [];
    }
    // Ensure src has not already been visited
    else {
        var i, len = _visited.length;
        for (i = 0; i < len; i++) {
            // If src was already visited, don't try to copy it, just return the reference
            if (src === _visited[i]) {
                return src;
            }
        }
    }

    // Add this object to the visited array
    _visited.push(src);

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

    //Special cases:
    //Array
    if (Object.prototype.toString.call(src) == '[object Array]') {
        //[].slice(0) would soft clone
        ret = src.slice();
        var i = ret.length;
        while (i--){
            ret[i] = deepCopy(ret[i], _visited);
        }
        return ret;
    }
    //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);
    }

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

    //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 ret = object_create(proto);

    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
        ret[key] = deepCopy(src[key], _visited);
    }
    return ret;
};

npm install node-v8-clone

Clonador más rápido, abre el método de clonación nativo desde node.js

var clone = require('node-v8-clone').clone;
var newObj = clone(obj, true); //true - deep recursive clone

Otra solución es encapsular directamente en la nueva variable usando: obj1= {...obj2}

También puede usar esta biblioteca de clonación para clonar objetos en profundidad.

 npm install --save clone

const clone = require('clone');

const clonedObject = clone(sourceObject);

Puede crear un prototipo de objeto y luego llamar a la instancia de objeto cada vez que quiera usar y cambiar de objeto:

function object () {
  this.x = 5;
  this.y = 5;
}
var obj1 = new object();
var obj2 = new object();
obj2.x = 6;
console.log(obj1.x); //logs 5

También puede pasar argumentos al constructor de objetos

function object (x, y) {
   this.x = x;
   this.y = y;
}
var obj1 = new object(5, 5);
var obj2 = new object(6, 6);
console.log(obj1.x); //logs 5
console.log(obj2.x); //logs 6

Espero que esto sea útil.