Nodejs : 객체를 복제하는 방법

Nodejs : 객체를 복제하는 방법

---

어레이를 복제하면 cloneArr = arr.slice()

nodejs에서 객체를 복제하는 방법을 알고 싶습니다.

---

모든 성능 저하를 감수 할 필요가없는 유틸리티 및 클래스의 경우 필자는 종종 속임수를 쓰며 JSON을 사용하여 깊은 복사를 수행합니다.

function clone(a) {
   return JSON.parse(JSON.stringify(a));
}

이것은 유일한 대답이나 가장 우아한 대답이 아닙니다. 프로덕션 병목 현상에 대해서는 다른 모든 답변을 고려해야합니다. 그러나 이것은 빠르고 더러운 솔루션이며 매우 효과적이며 간단한 속성 해시를 복제하는 대부분의 상황에서 유용합니다.

---

Object.assign은 위의 답변에서 언급되지 않았습니다.

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

ES6를 사용하는 경우 스프레드 연산자를 사용할 수 있습니다.

let cloned = { ... source };

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

---

"자신 만의 롤링"을 원하지 않는 경우 몇 가지 노드 모듈이 있습니다. 이것은 좋아 보인다 : https://www.npmjs.com/package/clone

순환 참조를 포함하여 모든 종류의 항목을 처리하는 것처럼 보입니다. 로부터 github의의 페이지 :

복제 마스터 복제 개체, 배열, 날짜 개체 및 RegEx 개체. 모든 것이 재귀 적으로 복제되므로, 예를 들어 객체의 배열에서 날짜를 복제 할 수 있습니다. [...] 순환 참조? 네!

---

일반적이지만 유용한 복제 작업을 수행하는 것은 어렵습니다. 무엇을 재귀 적으로 복제해야하고 무엇을 복사해야하는지에 따라 특정 개체의 작동 방식이 달라지기 때문입니다.

유용 할 수있는 것은

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

이 코드에서 논리는

• 같은 경우 null또는 undefined그냥 반환 ( clone메서드가 있는지 확인하는 데 오류가 있으므로 특별한 경우가 필요합니다 )
• 개체에 clone메서드가 있습니까? 그런 다음 그것을 사용하십시오
• 객체가 배열입니까? 그런 다음 재귀 복제 작업을 수행하십시오.
• 그렇지 않으면 동일한 값을 반환합니다.

이 복제 기능을 사용하면 사용자 지정 복제 방법을 쉽게 구현할 수 있습니다. 예를 들어

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

객체에서 특정 배열에 대한 올바른 복제 작업이 얕은 복사본이라는 것을 알고있는 경우 values.slice()대신을 호출 할 수 있습니다 clone(values).

예를 들어 위의 코드에서 다각형 객체의 복제는 점을 복제하지만 동일한 스타일 객체를 공유하도록 명시 적으로 요구합니다. 대신 스타일 객체도 복제하려면 clone(this.style).

---

개체를 복제하는 기본 방법은 없습니다. 밑줄 _.clone은 얕은 클론을 구현 합니다.

_.clone = function(obj) {
  return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
};

슬라이스하거나 확장합니다.

여기에 _.extend

// extend the obj (first parameter)
_.extend = function(obj) {
  // for each other parameter
  each(slice.call(arguments, 1), function(source) {
    // loop through all properties of the other objects
    for (var prop in source) {
      // if the property is not undefined then add it to the object.
      if (source[prop] !== void 0) obj[prop] = source[prop];
    }
  });
  // return the object (first parameter)
  return obj;
};

Extend는 모든 항목을 반복하고 항목이 포함 된 새 개체를 만듭니다.

원하는 경우 나만의 순진한 구현을 롤아웃 할 수 있습니다.

function clone(o) {
  var ret = {};
  Object.keys(o).forEach(function (val) {
    ret[val] = o[val];
  });
  return ret;
}

클로저를 복제 할 수 없기 때문에 딥 클로닝을 피해야하는 이유가 있습니다.

개인적으로 질문 deep cloning objects before을했고 결론은 당신이 그렇게하지 않는다는 것입니다.

내 권장 사항은 사용 underscore이며 _.clone얕은 클론에 대한 방법입니다.

---

얕은 사본의 경우 (보통 모듈 등에서) reduce 패턴을 사용하는 것을 좋아합니다.

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

다음은 몇 가지 옵션에 대한 jsperf입니다. http://jsperf.com/shallow-copying

---

Old question, but there's a more elegant answer than what's been suggested so far; use the built-in utils._extend:

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

var varToCopy = { test: 12345, nested: { val: 6789 } };

var copiedObject = extend({}, varToCopy);

console.log(copiedObject);

// outputs:
// { test: 12345, nested: { val: 6789 } }

Note the use of the first parameter with an empty object {} - this tells extend that the copied object(s) need to be copied to a new object. If you use an existing object as the first parameter, then the second (and all subsequent) parameters will be deep-merge-copied over the first parameter variable.

Using the example variables above, you can also do this:

var anotherMergeVar = { foo: "bar" };

extend(copiedObject, { anotherParam: 'value' }, anotherMergeVar);

console.log(copiedObject);

// outputs:
// { test: 12345, nested: { val: 6789 }, anotherParam: 'value', foo: 'bar' }

Very handy utility, especially where I'm used to extend in AngularJS and jQuery.

Hope this helps someone else; object reference overwrites are a misery, and this solves it every time!

---

You can use lodash as well. It has a clone and cloneDeep methods.

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

---

Depending on what you want to do with your cloned object you can utilize the prototypal inheritence mechanism of javascript and achieve a somewhat cloned object through:

var clonedObject = Object.create(originalObject);

Just remember that this isn't a full clone - for better or worse.

A good thing about that is that you actually haven't duplicated the object so the memory footprint will be low.

Some tricky things to remember though about this method is that iteration of properties defined in the prototype chain sometimes works a bit different and the fact that any changes to the original object will affect the cloned object as well unless that property has been set on itself also.

---

I implemented a full deep copy. I believe its the best pick for a generic clone method, but it does not handle cyclical references.

Usage example:

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

The code itself:

This code copies objects with their prototypes, it also copy functions (might be useful for someone).

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

With this copy I can't find any difference between the original and the copied one except if the original used closures on its construction, so i think its a good implementation.

I hope it helps

---

for array, one can use

var arr = [1,2,3]; 
var arr_2 = arr ; 

print ( arr_2 ); 

arr=arr.slice(0);

print ( arr ); 

arr[1]=9999; 

print ( arr_2 ); 

참고URL : https://stackoverflow.com/questions/6089058/nodejs-how-to-clone-an-object