प्रसार सिंटैक्स का उपयोग करके ES6 में गहरी प्रतिलिपि

Question 1

मैं अपने Redux प्रोजेक्ट के लिए एक गहरी प्रतिलिपि मानचित्र विधि बनाने की कोशिश कर रहा हूं जो सरणियों के बजाय वस्तुओं के साथ काम करेगी। मैंने पढ़ा कि Redux में प्रत्येक राज्य को पिछले राज्यों में कुछ भी नहीं बदलना चाहिए।

export const mapCopy = (object, callback) => {
    return Object.keys(object).reduce(function (output, key) {

    output[key] = callback.call(this, {...object[key]});

    return output;
    }, {});
}

यह काम करता हैं:

    return mapCopy(state, e => {

            if (e.id === action.id) {
                 e.title = 'new item';
            }

            return e;
        })

हालाँकि यह आंतरिक वस्तुओं की गहरी नकल नहीं करता है इसलिए मुझे इसे करने की आवश्यकता है:

export const mapCopy = (object, callback) => {
    return Object.keys(object).reduce(function (output, key) {

    let newObject = {...object[key]};
    newObject.style = {...newObject.style};
    newObject.data = {...newObject.data};

    output[key] = callback.call(this, newObject);

    return output;
    }, {});
}

यह कम सुरुचिपूर्ण है क्योंकि यह जानना आवश्यक है कि कौन सी वस्तुएं पारित की गई हैं। क्या ऑब्जेक्ट को गहरी कॉपी करने के लिए फैल सिंटैक्स का उपयोग करने के लिए ईएस 6 में एक तरीका है?

Question 2

ऐसी कोई कार्यक्षमता ES6 में अंतर्निहित नहीं है। मुझे लगता है कि आपके पास कुछ विकल्प हैं जो आप करना चाहते हैं उसके आधार पर।

यदि आप वास्तव में गहरी प्रतिलिपि बनाना चाहते हैं:

एक पुस्तकालय का उपयोग करें। उदाहरण के लिए, लॉश में एक cloneDeepविधि है।
अपने स्वयं के क्लोनिंग फ़ंक्शन को लागू करें।

आपकी विशिष्ट समस्या के लिए वैकल्पिक समाधान (कोई गहरी प्रति)

हालाँकि, मुझे लगता है, यदि आप कुछ चीजों को बदलने के इच्छुक हैं, तो आप अपने आप को कुछ काम बचा सकते हैं। मैं मान रहा हूं कि आप अपने फ़ंक्शन के लिए सभी कॉल साइटों को नियंत्रित करते हैं।

निर्दिष्ट करें कि सभी कॉलबैक mapCopyको मौजूदा ऑब्जेक्ट को म्यूट करने के बजाय नई वस्तुओं को वापस करना होगा। उदाहरण के लिए:
```
mapCopy(state, e => {
  if (e.id === action.id) {
    return Object.assign({}, e, {
      title: 'new item'
    });
  } else {  
    return e;
  }
});
```
यह Object.assignएक नई वस्तु बनाने के लिए उपयोग करता है , eउस नई वस्तु के गुणों को सेट करता है, फिर उस नई वस्तु पर एक नया शीर्षक सेट करता है। इसका मतलब है कि आप कभी भी मौजूदा वस्तुओं को म्यूट नहीं करते हैं और केवल आवश्यक होने पर नए बनाते हैं।

mapCopy अब वास्तव में सरल हो सकता है:

export const mapCopy = (object, callback) => {
  return Object.keys(object).reduce(function (output, key) {
    output[key] = callback.call(this, object[key]);
    return output;
  }, {});
}

अनिवार्य रूप से, mapCopyसही काम करने के लिए अपने कॉलर्स पर भरोसा कर रहा है। यही कारण है कि मैंने कहा कि आप सभी कॉल साइटों को नियंत्रित करते हैं।

Question 3

इसके बजाय गहरी प्रतिलिपि के लिए इसका उपयोग करें

var newObject = JSON.parse(JSON.stringify(oldObject))

var oldObject = {
  name: 'A',
  address: {
    street: 'Station Road',
    city: 'Pune'
  }
}
var newObject = JSON.parse(JSON.stringify(oldObject));

newObject.address.city = 'Delhi';
console.log('newObject');
console.log(newObject);
console.log('oldObject');
console.log(oldObject);

स्निपेट का विस्तार करें

Question 4

एमडीएन से

नोट: किसी वाक्य की प्रतिलिपि बनाते समय स्प्रेड सिंटैक्स प्रभावी रूप से एक स्तर गहरा हो जाता है। इसलिए, यह बहुआयामी सरणियों की प्रतिलिपि बनाने के लिए अनुपयुक्त हो सकता है क्योंकि निम्न उदाहरण दिखाता है (यह Object.assign () और प्रसार सिंटैक्स के साथ समान है)।

व्यक्तिगत रूप से, मैं सुझाव देता हूं कि बहु-स्तरीय वस्तु / सरणी क्लोनिंग के लिए लोदश के क्लोनडिप फ़ंक्शन का उपयोग करें ।

यहाँ एक काम कर उदाहरण है:

const arr1 = [{ 'a': 1 }];

const arr2 = [...arr1];

const arr3 = _.clone(arr1);

const arr4 = arr1.slice();

const arr5 = _.cloneDeep(arr1);

const arr6 = [...{...arr1}]; // a bit ugly syntax but it is working!


// first level
console.log(arr1 === arr2); // false
console.log(arr1 === arr3); // false
console.log(arr1 === arr4); // false
console.log(arr1 === arr5); // false
console.log(arr1 === arr6); // false

// second level
console.log(arr1[0] === arr2[0]); // true
console.log(arr1[0] === arr3[0]); // true
console.log(arr1[0] === arr4[0]); // true
console.log(arr1[0] === arr5[0]); // false
console.log(arr1[0] === arr6[0]); // false

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.js"></script>

स्निपेट का विस्तार करें

Question 5

मैं अक्सर इसका उपयोग करता हूं:

function deepCopy(obj) {
    if(typeof obj !== 'object' || obj === null) {
        return obj;
    }

    if(obj instanceof Date) {
        return new Date(obj.getTime());
    }

    if(obj instanceof Array) {
        return obj.reduce((arr, item, i) => {
            arr[i] = deepCopy(item);
            return arr;
        }, []);
    }

    if(obj instanceof Object) {
        return Object.keys(obj).reduce((newObj, key) => {
            newObj[key] = deepCopy(obj[key]);
            return newObj;
        }, {})
    }
}

Question 6

const a = {
  foods: {
    dinner: 'Pasta'
  }
}
let b = JSON.parse(JSON.stringify(a))
b.foods.dinner = 'Soup'
console.log(b.foods.dinner) // Soup
console.log(a.foods.dinner) // Pasta

का उपयोग करना JSON.stringifyऔर JSON.parseसबसे अच्छा तरीका है। क्योंकि स्प्रेड ऑपरेटर के उपयोग से हम उस कुशल उत्तर को प्राप्त नहीं कर पाएंगे जब json ऑब्जेक्ट में इसके अंदर एक और ऑब्जेक्ट होता है। हमें मैन्युअल रूप से यह निर्दिष्ट करने की आवश्यकता है।

Question 7

function deepclone(obj) {
    let newObj = {};

    if (typeof obj === 'object') {
        for (let key in obj) {
            let property = obj[key],
                type = typeof property;
            switch (type) {
                case 'object':
                    if( Object.prototype.toString.call( property ) === '[object Array]' ) {
                        newObj[key] = [];
                        for (let item of property) {
                            newObj[key].push(this.deepclone(item))
                        }
                    } else {
                        newObj[key] = deepclone(property);
                    }
                    break;
                default:
                    newObj[key] = property;
                    break;

            }
        }
        return newObj
    } else {
        return obj;
    }
}

Question 8

// use: clone( <thing to copy> ) returns <new copy>
// untested use at own risk
function clone(o, m){
  // return non object values
  if('object' !==typeof o) return o
  // m: a map of old refs to new object refs to stop recursion
  if('object' !==typeof m || null ===m) m =new WeakMap()
  var n =m.get(o)
  if('undefined' !==typeof n) return n
  // shallow/leaf clone object
  var c =Object.getPrototypeOf(o).constructor
  // TODO: specialize copies for expected built in types i.e. Date etc
  switch(c) {
    // shouldn't be copied, keep reference
    case Boolean:
    case Error:
    case Function:
    case Number:
    case Promise:
    case String:
    case Symbol:
    case WeakMap:
    case WeakSet:
      n =o
      break;
    // array like/collection objects
    case Array:
      m.set(o, n =o.slice(0))
      // recursive copy for child objects
      n.forEach(function(v,i){
        if('object' ===typeof v) n[i] =clone(v, m)
      });
      break;
    case ArrayBuffer:
      m.set(o, n =o.slice(0))
      break;
    case DataView:
      m.set(o, n =new (c)(clone(o.buffer, m), o.byteOffset, o.byteLength))
      break;
    case Map:
    case Set:
      m.set(o, n =new (c)(clone(Array.from(o.entries()), m)))
      break;
    case Int8Array:
    case Uint8Array:
    case Uint8ClampedArray:
    case Int16Array:
    case Uint16Array:
    case Int32Array:
    case Uint32Array:
    case Float32Array:
    case Float64Array:
      m.set(o, n =new (c)(clone(o.buffer, m), o.byteOffset, o.length))
      break;
    // use built in copy constructor
    case Date:
    case RegExp:
      m.set(o, n =new (c)(o))
      break;
    // fallback generic object copy
    default:
      m.set(o, n =Object.assign(new (c)(), o))
      // recursive copy for child objects
      for(c in n) if('object' ===typeof n[c]) n[c] =clone(n[c], m)
  }
  return n
}

Question 9

const cloneData = (dataArray) => {
    newData= []
    dataArray.forEach((value) => {
        newData.push({...value})
    })
    return newData
}

a = [{name: "siva"}, {name: "siva1"}];
b = myCopy (a)
b === ए / झूठी `

Question 10

मैं खुद पिछले दिनों इन उत्तरों पर उतरा, गहरी जटिल संरचनाओं को कॉपी करने का एक तरीका खोजने की कोशिश कर रहा था, जिसमें पुनरावर्ती लिंक शामिल हो सकते हैं। जैसा कि मैं पहले सुझाए गए किसी भी चीज से संतुष्ट नहीं था, मैंने खुद इस पहिये को लागू किया। और यह काफी अच्छी तरह से काम करता है। आशा है कि यह किसी की मदद करता है।

उदाहरण का उपयोग:

OriginalStruct.deep_copy = deep_copy; // attach the function as a method

TheClone = OriginalStruct.deep_copy();

कृपया इसका उपयोग करने के लिए लाइव उदाहरण के लिए https://github.com/latitov/JS_DeepCopy देखें , और साथ ही deep_print () भी है।

यदि आपको इसकी त्वरित आवश्यकता है, तो यहीं deep_copy () फ़ंक्शन का स्रोत है:

function deep_copy() {
    'use strict';   // required for undef test of 'this' below

    // Copyright (c) 2019, Leonid Titov, Mentions Highly Appreciated.

    var id_cnt = 1;
    var all_old_objects = {};
    var all_new_objects = {};
    var root_obj = this;

    if (root_obj === undefined) {
        console.log(`deep_copy() error: wrong call context`);
        return;
    }

    var new_obj = copy_obj(root_obj);

    for (var id in all_old_objects) {
        delete all_old_objects[id].__temp_id;
    }

    return new_obj;
    //

    function copy_obj(o) {
        var new_obj = {};
        if (o.__temp_id === undefined) {
            o.__temp_id = id_cnt;
            all_old_objects[id_cnt] = o;
            all_new_objects[id_cnt] = new_obj;
            id_cnt ++;

            for (var prop in o) {
                if (o[prop] instanceof Array) {
                    new_obj[prop] = copy_array(o[prop]);
                }
                else if (o[prop] instanceof Object) {
                    new_obj[prop] = copy_obj(o[prop]);
                }
                else if (prop === '__temp_id') {
                    continue;
                }
                else {
                    new_obj[prop] = o[prop];
                }
            }
        }
        else {
            new_obj = all_new_objects[o.__temp_id];
        }
        return new_obj;
    }
    function copy_array(a) {
        var new_array = [];
        if (a.__temp_id === undefined) {
            a.__temp_id = id_cnt;
            all_old_objects[id_cnt] = a;
            all_new_objects[id_cnt] = new_array;
            id_cnt ++;

            a.forEach((v,i) => {
                if (v instanceof Array) {
                    new_array[i] = copy_array(v);
                }
                else if (v instanceof Object) {
                    new_array[i] = copy_object(v);
                }
                else {
                    new_array[i] = v;
                }
            });
        }
        else {
            new_array = all_new_objects[a.__temp_id];
        }
        return new_array;
    }
}

चीयर्स @!

Question 11

यहाँ मेरी गहरी कॉपी एल्गोरिथ्म है।

const DeepClone = (obj) => {
     if(obj===null||typeof(obj)!=='object')return null;
    let newObj = { ...obj };

    for (let prop in obj) {
      if (
        typeof obj[prop] === "object" ||
        typeof obj[prop] === "function"
      ) {
        newObj[prop] = DeepClone(obj[prop]);
      }
    }

    return newObj;
  };

Question 12

यहाँ deepClone फ़ंक्शन है जो सभी आदिम, सरणी, ऑब्जेक्ट, फ़ंक्शन डेटा प्रकारों को संभालता है

function deepClone(obj){
	if(Array.isArray(obj)){
		var arr = [];
		for (var i = 0; i < obj.length; i++) {
			arr[i] = deepClone(obj[i]);
		}
		return arr;
	}

	if(typeof(obj) == "object"){
		var cloned = {};
		for(let key in obj){
			cloned[key] = deepClone(obj[key])
		}
		return cloned;	
	}
	return obj;
}

console.log( deepClone(1) )

console.log( deepClone('abc') )

console.log( deepClone([1,2]) )

console.log( deepClone({a: 'abc', b: 'def'}) )

console.log( deepClone({
  a: 'a',
  num: 123,
  func: function(){'hello'},
  arr: [[1,2,3,[4,5]], 'def'],
  obj: {
    one: {
      two: {
        three: 3
      }
    }
  }
}) )

स्निपेट का विस्तार करें