Clonage d'un objet dans Node.js

Quelle est la meilleure façon de cloner un objet dans node.js

par exemple, je veux éviter la situation où:

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

L'objet peut bien contenir des types complexes en tant qu'attributs, donc un simple for (var x dans obj1) ne résoudra pas. Dois-je écrire moi-même un clone récursif ou y a-t-il quelque chose que je ne vois pas?

Possibilité 1

Copie profonde sans fioritures:

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

Possibilité 2 (obsolète)

Attention: Cette solution est désormais marquée comme déconseillée dans la documentation de Node.js :

La méthode util._extend () n'a jamais été conçue pour être utilisée en dehors des modules internes Node.js. La communauté l'a quand même trouvée et utilisée.

Il est obsolète et ne doit pas être utilisé dans le nouveau code. JavaScript est livré avec des fonctionnalités intégrées très similaires via Object.assign ().

Réponse originale ::

Pour une copie superficielle, utilisez la fonction intégrée 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

Le code source de la _extendfonction de Node est ici: 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;
};

Je suis surpris que cela Object.assignn'ait pas été mentionné.

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

Si disponible (par exemple Babel), vous pouvez utiliser l' opérateur de propagation d'objet :

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

Cela définira une méthode d'extension que vous pouvez utiliser. Le code provient de cet article.

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

Vous pouvez utiliser la fonction d'extension de JQuery:

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

Il existe également un plugin Node.js:

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

Pour le faire sans JQuery ou Plugin, lisez ceci ici:

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

Découvrez underscore.js . Il a à la fois cloné et étendu et de nombreuses autres fonctions très utiles.

Cela peut être utile: Utilisation du module Underscore avec Node.js

Il y a des modules Node là-bas si vous ne voulez pas "rouler le vôtre". Celui-ci a l'air bien: https://www.npmjs.com/package/clone

On dirait qu'il gère toutes sortes de choses, y compris les références circulaires. Depuis la page github :

clone maîtrise les objets de clonage, les tableaux, les objets Date et les objets RegEx. Tout est cloné récursivement, de sorte que vous pouvez cloner des dates dans des tableaux d'objets, par exemple. [...] Références circulaires? Oui!

Ce code est également un travail car la méthode Object.create () crée un nouvel objet avec l'objet prototype et les propriétés spécifiés.

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

var obj2 = Object.create(obj1);

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

obj1.x; //5

Le moyen le plus simple et le plus rapide pour cloner un objet dans NodeJS est d'utiliser la méthode 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"}

La méthode Object.keys nécessite JavaScript 1.8.5; nodeJS v0.4.11 prend en charge cette méthode

mais bien sûr, pour les objets imbriqués, il faut implémenter des fonctions

Une autre solution consiste à utiliser le JSON natif (implémenté dans JavaScript 1.7), mais il est beaucoup plus lent (~ 10 fois plus lent) que le précédent

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

Il existe également un projet sur Github qui vise à être un port plus direct du jQuery.extend():

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

Un exemple, modifié à partir des documents 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);

Il existe une autre bibliothèque lodash , elle a clone et cloneDeep , ainsi que de nombreuses autres fonctions utiles.

Vous souffrez tous et pourtant la solution est simple.

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

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

À la recherche d'une véritable option de clone, je suis tombé sur le lien ridicule ici:

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

J'ai modifié la solution sur cette page afin que la fonction attachée au Objectprototype ne soit pas énumérable. Voici mon résultat:

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

Espérons que cela aide aussi quelqu'un d'autre. Notez qu'il y a quelques mises en garde ... en particulier avec les propriétés nommées "clone". Cela fonctionne bien pour moi. Je ne prends aucun crédit pour l'écrire. Encore une fois, j'ai seulement changé la façon dont il était défini.

Vous pouvez également utiliser SugarJS dans NodeJS.

http://sugarjs.com/

Ils ont une fonction de clonage très propre: http://sugarjs.com/api/Object/clone

Si vous utilisez Coffee-Script, c'est aussi simple que:

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

Bien que ce ne soit pas un clone profond.

Aucune des réponses ne m'a satisfait, plusieurs ne fonctionnent pas ou ne sont que des clones superficiels, les réponses de @ clint-harris et l'utilisation de JSON.parse / stringify sont bonnes mais assez lentes. J'ai trouvé un module qui fait du clonage en profondeur rapidement: https://github.com/AlexeyKupershtokh/node-v8-clone

Il n'y a aucun moyen intégré de faire un vrai clone (copie complète) d'un objet dans node.js. Il y a quelques cas délicats, vous devriez donc certainement utiliser une bibliothèque pour cela. J'ai écrit une telle fonction pour ma bibliothèque simpleoo . Vous pouvez utiliser ledeepCopy fonction sans utiliser quoi que ce soit d'autre de la bibliothèque (qui est assez petite) si vous n'en avez pas besoin. Cette fonction prend en charge le clonage de plusieurs types de données, y compris les tableaux, les dates et les expressions régulières, elle prend en charge les références récursives et elle fonctionne également avec les objets dont les fonctions constructeur ont des paramètres requis.

Voici le code:

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

Cloneur le plus rapide, il ouvre la méthode de clonage natif de node.js

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

Une autre solution consiste à encapsuler directement dans la nouvelle variable en utilisant: obj1= {...obj2}

Vous pouvez également utiliser cette bibliothèque de clones pour cloner des objets en profondeur.

 npm install --save clone

const clone = require('clone');

const clonedObject = clone(sourceObject);

Vous pouvez créer un prototype d'objet, puis appeler une instance d'objet chaque fois que vous souhaitez utiliser et modifier un objet:

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

Vous pouvez également passer des arguments au constructeur d'objet

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

J'espère que cela vous sera utile.