Nodejs: so Klonen Sie ein Objekt

Objekt.weisen Sie noch nicht erwähnt worden in einem der oben genannten Antworten.

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

Wenn Sie auf ES6 können Sie den spread-operator:

let cloned = { ... source };

Referenz: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign

Es ist schwer zu tun, eine generische, aber nützliche clone-Betrieb, denn was sollte geklont werden, die rekursiv und was sollte das gerade kopiert wird, hängt davon ab, wie das jeweilige Objekt wirken soll.

Etwas, das nützlich sein kann ist

function clone(x)
{
    if (x === null || x === undefined)
        return x;
    if (typeof x.clone === "function")
        return x.clone();
    if (x.constructor == Array)
    {
        var r = [];
        for (var i=0,n=x.length; i<n; i++)
            r.push(clone(x[i]));
        return r;
    }
    return x;
}

In diesem code die Logik ist

• bei null oder undefined nur wieder das gleiche (der Besondere Fall ist, erforderlich, weil es ein Fehler ist, zu versuchen, um zu sehen, wenn ein clone - Methode vorhanden ist)
• hat der Gegenstand eine clone Methode ? verwenden Sie dann, dass
• ist das Objekt ein array ? dann machen Sie eine rekursive Klonen
• ansonsten einfach den gleichen Wert zurückgeben

Diese Klon-Funktion ermöglichen sollte, die Umsetzung custom clone-Methoden leicht... zum Beispiel

function Point(x, y)
{
    this.x = x;
    this.y = y;

    ...
}

Point.prototype.clone = function()
{
    return new Point(this.x, this.y);
};



function Polygon(points, style)
{
    this.points = points;
    this.style = style;

    ...
}

Polygon.prototype.clone = function()
{
    return new Polygon(clone(this.points),
                       this.style);
};

Wenn in das Objekt, das Sie wissen, dass eine korrekte cloning-Vorgang für einen bestimmten array ist nur eine flache Kopie dann können Sie anrufen values.slice() statt clone(values).

Zum Beispiel im obigen code bin ich ausdrücklich vorschreibt, dass ein Klonen von einem polygon-Objekt Klonen der Punkte, aber teilen die gleiche style-Objekt. Wenn ich clone das style-Objekt zu anstelle, dann kann ich nur weitergeben clone(this.style).

Für eine flache Kopie, möchte ich reduzieren Muster (in der Regel in einem Modul oder so), etwa so:

var newObject = Object.keys(original).reduce(function (obj, item) {
    obj[item] = original[item];
    return obj;
},{});

Hier ein jsperf für ein paar der Optionen: http://jsperf.com/shallow-copying

Können Sie lodash als gut. Es hat eine Klon und cloneDeep Methoden.

var _= require('lodash');

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

var shallow = _.clone(objects);
console.log(shallow[0] === objects[0]);
//=> true

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

Implementiert habe ich eine volle Tiefe Kopie. Ich glaube, es ist die beste Wahl für eine generische clone-Methode, aber es funktioniert nicht mit zyklischen Referenzen.

Beispiel:

parent = {'prop_chain':3}
obj = Object.create(parent)
obj.a=0; obj.b=1; obj.c=2;

obj2 = copy(obj)

console.log(obj, obj.prop_chain)
//'{'a':0, 'b':1, 'c':2} 3
console.log(obj2, obj2.prop_chain)
//'{'a':0, 'b':1, 'c':2} 3

parent.prop_chain=4
obj2.a = 15

console.log(obj, obj.prop_chain)
//'{'a':0, 'b':1, 'c':2} 4
console.log(obj2, obj2.prop_chain)
//'{'a':15, 'b':1, 'c':2} 4

Der code selbst:

Dieser code kopiert Objekte mit Ihren Prototypen, es auch copy-Funktionen (könnte nützlich sein für jemanden).

function copy(obj) {
  //(F.prototype will hold the object prototype chain)
  function F() {}
  var newObj;

  if(typeof obj.clone === 'function')
    return obj.clone()

  //To copy something that is not an object, just return it:
  if(typeof obj !== 'object' && typeof obj !== 'function' || obj == null)
    return obj;

  if(typeof obj === 'object') {    
    //Copy the prototype:
    newObj = {}
    var proto = Object.getPrototypeOf(obj)
    Object.setPrototypeOf(newObj, proto)
  } else {
    //If the object is a function the function evaluate it:
    var aux
    newObj = eval('aux='+obj.toString())
    //And copy the prototype:
    newObj.prototype = obj.prototype
  }

  //Copy the object normal properties with a deep copy:
  for(var i in obj) {
    if(obj.hasOwnProperty(i)) {
      if(typeof obj[i] !== 'object')
        newObj[i] = obj[i]
      else
        newObj[i] = copy(obj[i])
    }
  }

  return newObj;
}

Mit dieser Kopie kann ich keinen Unterschied zwischen der ursprünglichen und der kopierten außer wenn das original verwendet Sperrungen auf seine Konstruktion, so dass ich denke es ist eine gute Umsetzung.

Ich hoffe, es hilft