Underscore: डीप एक्सटेंड और डीप कॉपी

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

सच है, जावास्क्रिप्ट में गहरी प्रतियां निश्चित रूप से गड़बड़ हैं। वहाँ कुछ बिंदु होना चाहिए जहाँ आप कहते हैं कि लाभ हानियों से अधिक है, है ना? लोगों द्वारा लगातार क्रमी डीप-कॉपी विधियों को लिखना जो अपेक्षित रूप से काम नहीं करते हैं, एक गहरी प्रतिलिपि विधि का उपयोग करने से भी बदतर है जिसे सावधानीपूर्वक कोड किया गया है, लेकिन इसकी अच्छी तरह से प्रलेखित सीमाएं हैं। उदाहरण के लिए, इस आदमी का समाधान बहुत अच्छा है: http://stackoverflow.com/questions/728360/copying-an-object-in-javascript/728694#728694

वह अधिकांश ठिकानों को कवर करता है, और उन दस्तावेजों को शामिल करता है जिन्हें वह सही तरीके से संभाल नहीं पाएगा। वह मानता है कि वस्तु में केवल ये प्रकार हैं: वस्तु, सरणी, दिनांक, स्ट्रिंग, संख्या, और बूलियन, और वह मानता है कि किसी भी वस्तु या सरणी में केवल वही होगा।

हां - और यहां तक ​​​​कि उस आदमी का समाधान भी वास्तव में काफी अच्छा नहीं है। अगर हम इसे सही तरीके से लागू नहीं कर सकते हैं, तो हमें इसे लागू नहीं करना चाहिए।

लेकिन क्या यह वास्तव में उपयोगकर्ताओं के लिए स्वयं को रोल करने के लिए बेहतर है, शायद और भी अधिक टूटा हुआ, कार्यान्वयन?

नहीं -- उपयोगकर्ताओं के लिए यह बेहतर है कि वे जावास्क्रिप्ट में डीप कॉपी न करें। जिस वस्तु की आप पहले से प्रतिलिपि बनाना चाहते हैं उसकी संरचना को जानकर आप आमतौर पर एक मजबूत गहरी प्रतिलिपि फ़ंक्शन के बिना उसी अंत को पूरा करने का एक तरीका ढूंढ सकते हैं।

आह, तो आप सुझाव दे रहे हैं कि उपयोगकर्ता आवश्यक मूल्यों के साथ वस्तु का एक नया उदाहरण हाइड्रेट करता है? मैं देख सकता हु।

Jquery.extend में गहरा विकल्प है।

+1 गहरे विकल्प के लिए, चाहे इसे लागू करना कितना भी कठिन क्यों न हो।

इसके लिए +2 - इसे लागू करना मुश्किल नहीं है, यह सिद्धांत की बात है (यानी कम से कम सही समाधान लागू नहीं करना)। हालांकि, जैसा ऊपर बताया गया है, इसका उपयोग jQuery लाइब्रेरी में किया जाता है और कुछ किनारे के मामलों में काफी उपयोगी होता है। इसे इस तरह के हल्के वजन वाले पुस्तकालय में उपलब्ध कराना अच्छा होगा।

@kmalakoff ने एक कार्यान्वयन लिखा है, आपको उसे कुछ प्रतिक्रिया देनी चाहिए! :)

आप मेरे मूल _.cloneToDepth को _clone के साथ मर्ज भी कर सकते हैं और बस एक गहराई पैरामीटर जोड़ सकते हैं ....

  // Create a duplicate of a container of objects to any zero-indexed depth.
  _.cloneToDepth = _.clone = function(obj, depth) {
    if (typeof obj !== 'object') return obj;
    var clone = _.isArray(obj) ? obj.slice() : _.extend({}, obj);
    if (!_.isUndefined(depth) && (depth > 0)) {
      for (var key in clone) {
        clone[key] = _.clone(clone[key], depth-1);
      }
    }
    return clone;
  };

इसके अलावा, मैंने _.own और _.disown लिखा है जो स्वामित्व के लिए एक सम्मेलन पेश करता है (या तो बनाए रखने/रिलीज या क्लोन/नष्ट करने के जोड़े)। यह केवल एक स्तर नीचे रिकर्स करता है, लेकिन मुझे लगता है कि कुल रिकर्सन के लिए एक विकल्प जोड़ा जा सकता है (मैं एक उपयोग केस देखना चाहता हूं!)

  _.own = function(obj, options) {
    if (!obj || (typeof(obj)!='object')) return obj;
    options || (options = {});
    if (_.isArray(obj)) {
      if (options.share_collection) { _.each(obj, function(value) { _.own(value, {prefer_clone: options.prefer_clone}); }); return obj; }
      else { var a_clone =  []; _.each(obj, function(value) { a_clone.push(_.own(value, {prefer_clone: options.prefer_clone})); }); return a_clone; }
    }
    else if (options.properties) {
      if (options.share_collection) { _.each(obj, function(value, key) { _.own(value, {prefer_clone: options.prefer_clone}); }); return obj; }
      else { var o_clone = {}; _.each(obj, function(value, key) { o_clone[key] = _.own(value, {prefer_clone: options.prefer_clone}); }); return o_clone; }
    }
    else if (obj.retain) {
      if (options.prefer_clone && obj.clone) return obj.clone();
      else obj.retain();
    }
    else if (obj.clone) return obj.clone();
    return obj;
  };

  _.disown = function(obj, options) {
    if (!obj || (typeof(obj)!='object')) return obj;
    options || (options = {});
    if (_.isArray(obj)) {
      if (options.clear_values) { _.each(obj, function(value, index) { _.disown(value); obj[index]=null; }); return obj; }
      else {
        _.each(obj, function(value) { _.disown(value); });
        obj.length=0; return obj;
      }
    }
    else if (options.properties) {
      if (options.clear_values) { _.each(obj, function(value, key) { _.disown(value); obj[key]=null; }); return obj; }
      else {
        _.each(obj, function(value) { _.disown(value); });
        for(key in obj) { delete obj[key]; }
        return obj;
      }
    }
    else if (obj.release) obj.release();
    else if (obj.destroy) obj.destroy();
    return obj;
  };

और यदि आप एक सामान्य उद्देश्य चाहते हैं, तो एक्स्टेंसिबल क्लोन:

  // Create a duplicate of all objects to any zero-indexed depth.
  _.deepClone = function(obj, depth) {
    if (typeof obj !== 'object') return obj;
    if (_.isString(obj)) return obj.splice();
    if (_.isDate(obj)) return new Date(obj.getTime());
    if (_.isFunction(obj.clone)) return obj.clone();
    var clone = _.isArray(obj) ? obj.slice() : _.extend({}, obj);
    if (!_.isUndefined(depth) && (depth > 0)) {
      for (var key in clone) {
        clone[key] = _.deepClone(clone[key], depth-1);
      }
    }
    return clone;
  };

मुझे यकीन नहीं है कि यह एक अच्छा विचार है जब तक कि एक उपयोग का मामला नहीं दिया जाता है जहां एक गहरी प्रति वास्तव में सबसे अच्छा समाधान है। मुझे लगता है कि एक को ढूंढना मुश्किल होगा।

मैं कल अपनी प्रतिक्रिया से पूरी तरह संतुष्ट नहीं था (आधी रात के बाद कोड नहीं लिखना चाहिए) ... मैं दो संस्करणों के साथ आया हूं ( _.cloneToDepth मूल रूप से केवल कंटेनर को क्लोन करता है, मूल वस्तुओं के संदर्भों को बनाए रखता है और _.deepClone जो उदाहरणों की प्रतिलिपि बनाता है):

  // Create a duplicate of a container of objects to any zero-indexed depth.
  _.cloneToDepth = _.containerClone = _.clone = function(obj, depth) {
    if (!obj || (typeof obj !== 'object')) return obj;  // by value
    var clone;
    if (_.isArray(obj)) clone = Array.prototype.slice.call(obj);
    else if (obj.constructor!=={}.constructor) return obj; // by reference
    else clone = _.extend({}, obj);
    if (!_.isUndefined(depth) && (depth > 0)) {
      for (var key in clone) {
        clone[key] = _.clone(clone[key], depth-1);
      }
    }
    return clone;
  };

  // Create a duplicate of all objects to any zero-indexed depth.
  _.deepClone = function(obj, depth) {
    if (!obj || (typeof obj !== 'object')) return obj;  // by value
    else if (_.isString(obj)) return String.prototype.slice.call(obj);
    else if (_.isDate(obj)) return new Date(obj.valueOf());
    else if (_.isFunction(obj.clone)) return obj.clone();
    var clone;
    if (_.isArray(obj)) clone = Array.prototype.slice.call(obj);
    else if (obj.constructor!=={}.constructor) return obj; // by reference
    else clone = _.extend({}, obj);
    if (!_.isUndefined(depth) && (depth > 0)) {
      for (var key in clone) {
        clone[key] = _.deepClone(clone[key], depth-1);
      }
    }
    return clone;
  };

जैसा कि @michaelficarra बताते हैं, उपयोग के मामले अस्पष्ट हो सकते हैं। व्यक्तिगत रूप से, मैं उपयोग करता हूं:

1) _.own / _.disown जब मैं उन वस्तुओं को साझा करना चाहता हूं जिनमें जटिल जीवनचक्र और/या स्वामित्व मॉडल हैं (जैसे संदर्भ गिनती ठीक से साफ करने के लिए)
2) मैंने _.cloneToDepth / _.containerClone (शायद ही कभी!) का उपयोग किया था जब मेरे पास फ़ंक्शन के लिए जटिल, नेस्टेड विकल्प थे।
3) मुझे कभी भी _.deepClone , लेकिन मान लीजिए कि यह सामान्य उद्देश्य के रूप में उपयोगी हो सकता है _.clone यदि आप एक सामान्य फ़ंक्शन लिख रहे हैं जो लचीले ढंग से प्रकारों का समर्थन करता है (उदाहरण के लिए। मैं नहीं करता परवाह है कि आप मुझे क्या देते हैं, लेकिन मैं इसे संशोधित करने जा रहा हूं और मूल पर दुष्प्रभाव नहीं चाहता - हालांकि तार एक विशेष अपरिवर्तनीय मामला है)।

मैंने यहां कोड और परीक्षण सबमिट किए हैं: https://github.com/kmalakoff/underscore-awesomer/commit/0cf6008f16ad6e6daf60caf456021693ef33fec5

नोट: जो लोग एक-पंक्ति की तलाश में अटके हुए हैं, वे अनुमानित शब्दार्थ के साथ साधारण वस्तुओं के लिए अपूर्ण डीप-क्लोन केवल JSON.parse(JSON.stringify(object)) कर सकते हैं।

@adamhooper क्या यह विधि गुण या कुछ खो देती है? अधूरा क्यों है?

@diversario यह ऑब्जेक्ट प्रोटोटाइप की प्रतिलिपि नहीं बनाएगा, और यह फ़ंक्शन की प्रतिलिपि नहीं बनाएगा। यह पुनरावर्ती रूप से लागू होता है - इसलिए यह नेस्टेड ऑब्जेक्ट्स के प्रोटोटाइप या फ़ंक्शंस को ठीक से कॉपी नहीं करेगा।

विशेष रूप से: यह आपके ऑब्जेक्ट ट्री में किसी भी दिनांक को ठीक से कॉपी नहीं करेगा। और यदि आप इसे तिथियों के साथ काम करने के लिए ठीक करना चाहते हैं, तो ठीक है, आप बस एक बहुत बड़ी समस्या के एक छोटे से लक्षण को संबोधित कर रहे हैं।

अरे हां। मैं ज्यादातर इसका उपयोग "टेम्पलेट" ऑब्जेक्ट्स जैसी चीजों के संदर्भ को तोड़ने के लिए करता हूं, इसलिए मैंने ऐसा कुछ भी नहीं किया है। लेकिन मुझे वास्तविक गहरी प्रतिलिपि की आवश्यकता दिखाई देती है।

मैंने कर्ट मिलम के डीपएक्सटेंड मिक्सिन को npm पैकेज में बदल दिया है।

https://github.com/pygy/undescoreDeepExtend/

@michaelficarra , कृपया बताएं कि एक सामान्य वृक्ष संरचना की क्लोनिंग के लिए गहरी-प्रतिलिपि कैसे एक अच्छा समाधान नहीं है?

आप सभी के लिए @adamhooper वन-लाइनर डीप कॉपी का उपयोग करने की कोशिश कर रहे हैं, इस अवगत रहें कि यह तारीखों के लिए काम नहीं करता है
JSON.parse (JSON.stringify (वस्तु))
वास्तव में यह किसी भी वस्तु दिनांक को स्ट्रिंग में परिवर्तित करता है

-1 डीप कॉपी के लिए। कॉन्फ़िगरेशन ऑब्जेक्ट्स के लिए प्रोटोटाइप श्रृंखला का उपयोग करना हमेशा आपके एपीआई को नेस्टेड विकल्पों से बेहतर होगा।

असल में गहरी प्रतिलिपि के लिए एक जगह है, लेकिन इसे टाइप चेकिंग के साथ मेल खाना चाहिए, इसलिए यह मेरी राय में एक बहुत ही विशिष्ट उपयोग केस है, न कि सामान्य उद्देश्य। JSON स्कीमा लाइब्रेरी या कॉन्फ़िगरेशन लोडर के लिए बेहतर अनुकूल है। जावास्क्रिप्ट टूल बेल्ट नहीं।

ज्यादातर मामलों में _.extend({}, obj1, { prop1: 1, prop2: 2 }) वह है जो मुझे वास्तव में करने की ज़रूरत है:

• मुझे एक नई वस्तु देता है
• मेरे स्रोत वस्तु को संशोधित नहीं करता है और
• गहरी नकल नहीं है

_.deepClone = function(obj) {
      return (!obj || (typeof obj !== 'object'))?obj:
          (_.isString(obj))?String.prototype.slice.call(obj):
          (_.isDate(obj))?new Date(obj.valueOf()):
          (_.isFunction(obj.clone))?obj.clone():
          (_.isArray(obj)) ? _.map(obj, function(t){return _.deepClone(t)}):
          _.mapObject(obj, function(val, key) {return _.deepClone(val)});
  };

हम अपने काम के माहौल में उपयोग के मामले में बहुत अधिक भाग लेते हैं जो कि गहरी क्लोनिंग से लाभान्वित होगा।

कभी-कभी, आपको डेटाबेस माइग्रेशन करना पड़ता है, जब एक जटिल वेब ऐप की सुविधाओं को अपडेट किया जाता है और एक नए प्रतिमान में विस्तारित किया जाता है। हमारे डेटा की एक डीप कॉपी तब बहुत मददगार होती है, जब डेटा से हैश जेनरेट करने जैसे ऑपरेशन करने पड़ते हैं, जब मूल रेफरेंस में हेर-फेर न करने को प्राथमिकता दी जाती है। मुझे नहीं लगता कि हमारे विशाल डेटाबेस में एक भी दस्तावेज़ 'फ्लैट' है। नेस्टेड गुण हर जगह मौजूद हैं।

साथ ही, कभी-कभी आप अपने वेब एप्लिकेशन के भीतर किसी ऑब्जेक्ट की एक प्रति किसी भिन्न सेवा को भेजना चाहते हैं, जिसे इसके साथ क्या करना है यह तय करने से पहले संचालित किया जाना है। संदर्भ द्वारा नेस्टेड गुण होने से क्लोन ऑब्जेक्ट होने का उद्देश्य विफल हो जाता है। क्लोन किए गए ऑब्जेक्ट का संपूर्ण बिंदु, इमो, मूल संदर्भ को व्यवहार में छोड़ना है। जैसे ही आप गहरे स्तरों के लिए संदर्भ प्रस्तुत करते हैं, पूरा उद्देश्य व्यर्थ है।

मुझे यकीन है कि इस बारे में जाने का एक अच्छा तरीका है जहां किसी वस्तु को उसकी गहराई तक नेविगेट किया जा सकता है, फिर सबसे गहरी परत से जड़ तक का पुनर्निर्माण किया जा सकता है।

लोडाश के पास है - https://lodash.com/docs/4.17.5#cloneDeep