javascript - जावास्क्रिप्ट एसिंक्रोनस प्रोग्रामिंग: जेनरेटर बनाम वादे



node.js asynchronous (2)

इन दो तकनीकों के बीच कोई विपक्ष नहीं है। वे एक-दूसरे को अच्छी तरह से पूरक बनाने के साथ मिलकर मिलते हैं। वादे आपको असीमित ऑपरेशन के परिणाम प्राप्त करने की क्षमता देते हैं जो अभी तक उपलब्ध नहीं है। यह डूम समस्या का पिरामिड हल करता है। तो इसके बजाए:

function ourImportantFunction(callback) {
  //... some code 1
  task1(function(val1) {
    //... some code 2
    task2(val1, function(val2) {
      //... some code 3
      task3(val2, callback);
    });
  });
}

तुम लिख सकते हो:

function ourImportantFunction() {
  return Promise.resolve()
    .then(function() {
        //... some code 1
        return task1(val3)
    })
    .then(function(val2) {
        //... some code 2
        return task2(val2)
    })
    .then(function(val2) {
        //... some code 3
        return task3(val2);
    });
}

ourImportantFunction().then(callback);

लेकिन वादे के साथ भी आपको एसिंक्रोनस फैशन में कोड लिखना होगा - आपको हमेशा कार्यों में कॉलबैक पास करना होगा। एसिंक्रोनस कोड लिखना सिंक्रोनस के बाद बहुत कठिन है। वादे के साथ भी जब कोड बहुत बड़ा होता है तो एल्गोरिदम को देखना मुश्किल हो जाता है (ठीक है, यह बहुत ही व्यक्तिपरक है, कोई इसके साथ बहस कर सकता है। लेकिन अधिकांश प्रोग्रामर के लिए मुझे लगता है कि यह सच है)। तो हम तुल्यकालिक फैशन में एसिंक्रोनस कोड लिखना चाहते हैं। यही वह जगह है जहां जनरेटर हमारी मदद करने के लिए आ रहे हैं। तो ऊपर दिए गए कोड के बजाय आप लिख सकते हैं:

var ourImportantFunction = spawn(function*() {
    //... some code 1
    var val1 = yield task1();
    //... some code 2
    var val2 = yield task2(val1);
    //... some code 3
    var val3 = yield task3(val2);

    return val3;
});

ourImportantFunction().then(callback);

जहां सबसे आसान संभव spawn प्राप्ति कुछ ऐसा हो सकता है:

function spawn(generator) {
  return function() {    
    var iter = generator.apply(this, arguments);

    return Promise.resolve().then(function onValue(lastValue){
      var result = iter.next(lastValue); 

      var done  = result.done;
      var value = result.value;

      if (done) return value; // generator done, resolve promise
      return Promise.resolve(value).then(onValue, iter.throw.bind(iter)); // repeat
    });
  };
}

जैसा कि आप value देख सकते हैं (कुछ एसिंक्रोनस फ़ंक्शन task{N} का परिणाम) एक वादा होना चाहिए। आप कॉलबैक के साथ ऐसा नहीं कर सकते हैं।

spawn तकनीक को भाषा में ही लागू करना है। तो हम spawn को async साथ बदल रहे हैं और await साथ yield कर रहे हैं और ES7 async / प्रतीक्षा करने के लिए आ रहे हैं:

var ourImportantFunction = async function() {
    //... some code 1
    var val1 = await task1();
    //... some code 2
    var val2 = await task2(val1);
    //... some code 3
    var val3 = await task3(val2);

    return val3;
}

मैं आपको इस वीडियो को और कुछ और आने वाली तकनीकों को समझने के लिए देखने की सलाह देता हूं। यदि लड़का आपके लिए बहुत तेज़ बोलता है, तो खेल की गति को धीमा कर दें (दाएं कोने में "सेटिंग्स", या बस [ shift + < ] दबाएं)

सबसे अच्छा क्या है: जेनरेटर के साथ कॉलबैक, या वादे, या वादे - यह बहुत ही व्यक्तिपरक प्रश्न है। कॉलबैक इस समय सबसे तेज़ समाधान संभव है (मूल वादे का प्रदर्शन अब बहुत खराब है)। जेनरेटर के साथ वादे आपको सिंक्रोनस फैशन में एसिंक्रोनस कोड लिखने का मौका देते हैं। लेकिन अब के लिए वे बहुत धीमे तो सरल कॉलबैक।

https://ffff65535.com

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


वादे और जनरेटर विभिन्न सॉफ्टवेयर पैटर्न (संरचनाएं) हैं:

  1. http://en.wikipedia.org/wiki/Futures_and_promises
  2. http://en.wikipedia.org/wiki/Generator_(computer_programming)

वास्तव में, जेनरेटर असीमित नहीं हैं।

जनरेटर उपयोगी होते हैं जब आपको मूल्यों की एक श्रृंखला को एक साथ नहीं, बल्कि एक प्रति मांग की आवश्यकता होती है। जेनरेटर अनुक्रम के अंत तक पहुंचने तक (या अनंत श्रृंखला के मामले में अंतहीन) तक प्रत्येक कॉल पर तत्काल (सिंक्रनाइज़) अगले मूल्य लौटाएगा।

वादे उपयोगी होते हैं जब आपको मूल्य को "स्थगित" करने की आवश्यकता होती है, जिसे गणना नहीं की जा सकती है (या उपलब्ध नहीं हो सकती है)। जब मान उपलब्ध होता है - यह पूरा मूल्य है (इसका हिस्सा नहीं) यहां तक ​​कि यह एक सरणी या अन्य जटिल मूल्य है।

आप विकिपीडिया लेखों में अधिक जानकारी और उदाहरण देख सकते हैं।






ecmascript-6