जनरेटर के साथ async / प्रतीक्षा और ES6 उपज के बीच अंतर

Question 1

मैं सिर्फ इस शानदार लेख « जनरेटर » को पढ़ रहा था और यह इस फ़ंक्शन को स्पष्ट रूप से उजागर करता है, जो जनरेटर कार्यों को संभालने के लिए एक सहायक कार्य है:

function async(makeGenerator){
  return function () {
    var generator = makeGenerator.apply(this, arguments);

    function handle(result){
      // result => { done: [Boolean], value: [Object] }
      if (result.done) return Promise.resolve(result.value);

      return Promise.resolve(result.value).then(function (res){
        return handle(generator.next(res));
      }, function (err){
        return handle(generator.throw(err));
      });
    }

    try {
      return handle(generator.next());
    } catch (ex) {
      return Promise.reject(ex);
    }
  }
}

जो मैं परिकल्पना बनाना कम या ज्यादा तरीका है asyncखोजशब्द के साथ लागू किया गया है async/ await। तो सवाल यह है कि अगर ऐसा है, तो क्या बिल्ली awaitऔर कीवर्ड में अंतर है yield? क्या awaitहमेशा किसी वादे में कुछ बदल जाता है, जबकि yieldऐसी कोई गारंटी नहीं है? यह मेरा सबसे अच्छा अनुमान है!

आप यह भी देख सकते हैं कि इस लेख में जनरेटर के साथ कैसे async/ awaitके समान है yieldजहां वह 'स्पॉन' फ़ंक्शन ES7 async फ़ंक्शन का वर्णन करता है ।

Question 2

yieldका बिल्डिंग ब्लॉक माना जा सकता है await। yieldइसके द्वारा दिया गया मान लेता है और इसे कॉलर को पास कर देता है। कॉल करने वाला फिर उस मान (1) के साथ जो चाहे कर सकता है। बाद में कॉलर जनरेटर (थ्रू generator.next()) को एक मान वापस दे सकता है जो yieldअभिव्यक्ति (2) का परिणाम बन जाता है , या एक त्रुटि जो yieldअभिव्यक्ति (3) द्वारा फेंक दी जाएगी ।

async- awaitउपयोग करने के लिए माना जा सकता है yield। At (1) कॉलर (यानी async- awaitड्राइवर - आपके द्वारा पोस्ट किए गए फ़ंक्शन के समान) एक समान एल्गोरिथ्म new Promise(r => r(value)(नोट, नहीं Promise.resolve , लेकिन यह एक बड़ी बात नहीं है) का उपयोग करके एक वादा में मूल्य लपेट देगा । यह तब हल करने के वादे की प्रतीक्षा करता है। यदि यह पूरा हो जाता है, तो यह पूरा हुआ मान वापस (2) पर आ जाता है। यदि यह अस्वीकार करता है, तो यह अस्वीकृति कारण को (3) में त्रुटि के रूप में फेंकता है।

तो async- की उपयोगिता awaitयह मशीनरी है जो yieldउपज के मूल्य को एक वादा के रूप में अनप्लग करने के लिए उपयोग करती है और अपने हल किए गए मूल्य को वापस करती है, जब तक कि फ़ंक्शन अपना अंतिम मूल्य वापस नहीं करता है।

Question 3

खैर, यह पता चला है कि async/ awaitऔर जनरेटर के बीच बहुत करीबी रिश्ता है । और मेरा मानना है कि async/ awaitहमेशा जनरेटर पर बनाया जाएगा। यदि आप बैबिल ट्रांसपाइल्स async/ जिस तरह से देखते हैं await:

बबेल यह लेता है:

this.it('is a test', async function () {

    const foo = await 3;
    const bar = await new Promise(resolve => resolve('7'));
    const baz = bar * foo;
    console.log(baz);

});

और इसे इस में बदल देता है

function _asyncToGenerator(fn) {
    return function () {
        var gen = fn.apply(this, arguments);
        return new Promise(function (resolve, reject) {
            function step(key, arg) {
                try {
                    var info = gen[key](arg);
                    var value = info.value;
                } catch (error) {
                    reject(error);
                    return;
                }
                if (info.done) {
                    resolve(value);
                } else {
                    return Promise.resolve(value).then(function (value) {
                        return step("next", value);
                    }, function (err) {
                        return step("throw", err);
                    });
                }
            }

            return step("next");
        });
    };
}


this.it('is a test', _asyncToGenerator(function* () {   // << now it's a generator

    const foo = yield 3;    //  <<< now it's yield, not await
    const bar = yield new Promise(resolve => resolve(7));
    const baz = bar * foo;
    console.log(baz);

}));

आपने गणित कर दिया।

इससे ऐसा लगता है कि asyncकीवर्ड सिर्फ रैपर फ़ंक्शन है, लेकिन अगर ऐसा है तो awaitबस चालू हो जाता है yield, संभवत: बाद में तस्वीर में कुछ और होगा जब वे मूल निवासी हो जाएंगे।

आप इसके लिए और अधिक स्पष्टीकरण यहाँ देख सकते हैं: https://www.promisejs.org/generators/

Question 4

awaitकीवर्ड और कीवर्ड के बीच क्या अंतर है yield?

awaitकीवर्ड केवल में प्रयोग की जाने वाली है async function, रों जबकि yieldकीवर्ड केवल जनरेटर में इस्तेमाल किया जा रहा है function*है। और वे स्पष्ट रूप से अलग हैं - एक रिटर्न का वादा करता है, दूसरा जनरेटर लौटाता है।

क्या awaitहमेशा किसी वादे में कुछ बदल जाता है, जबकि yieldऐसी कोई गारंटी नहीं है?

हां, प्रतीक्षित मूल्य पर awaitकॉल करेगा Promise.resolve।

yield बस जनरेटर के बाहर मूल्य देता है।

Question 5

tl; डॉ

उपयोग async/ awaitजनरेटर से अधिक समय के 99%। क्यों?

async/ awaitसीधे कोड्स को घोषित करने की अनुमति देने वाले सबसे आम वर्कफ़्लो की जगह कोड को घोषित करता है जैसे कि यह तुल्यकालिक था, नाटकीय रूप से इसे सरल बनाना।
जेनरेटर उपयोग के मामले को समाप्त कर देते हैं, जहां आप एक-दूसरे पर निर्भर होने वाले एस्किं-ऑपरेशंस की एक श्रृंखला कहेंगे और अंततः "किया" स्थिति में होंगे। सबसे सरल उदाहरण उन परिणामों के माध्यम से होगा जो अंततः अंतिम सेट लौटाते हैं लेकिन आप केवल एक पृष्ठ को आवश्यकता के रूप में कहेंगे, न कि तुरंत उत्तराधिकार में।
async/ awaitवास्तव में वादों को आसान बनाने के लिए जनरेटर के शीर्ष पर निर्मित एक अमूर्तता है।

Async / Await बनाम जनरेटर के बहुत गहराई से स्पष्टीकरण देखें

Question 6

इस परीक्षण कार्यक्रमों को आज़माएं, जिसे मैं वादों के साथ समझता await/ समझता था async।

कार्यक्रम # 1: वादों के बिना यह क्रम में नहीं चलता है

function functionA() {
    console.log('functionA called');
    setTimeout(function() {
        console.log('functionA timeout called');
        return 10;
    }, 15000);

}

function functionB(valueA) {
    console.log('functionB called');
    setTimeout(function() {
        console.log('functionB timeout called = ' + valueA);
        return 20 + valueA;
    }, 10000);
}

function functionC(valueA, valueB) {

    console.log('functionC called');
    setTimeout(function() {
        console.log('functionC timeout called = ' + valueA);
        return valueA + valueB;
    }, 10000);

}

async function executeAsyncTask() {
    const valueA = await functionA();
    const valueB = await functionB(valueA);
    return functionC(valueA, valueB);
}
console.log('program started');
executeAsyncTask().then(function(response) {
    console.log('response called = ' + response);
});
console.log('program ended');

कार्यक्रम # 2: वादों के साथ

function functionA() {
    return new Promise((resolve, reject) => {
        console.log('functionA called');
        setTimeout(function() {
            console.log('functionA timeout called');
            // return 10;
            return resolve(10);
        }, 15000);
    });   
}

function functionB(valueA) {
    return new Promise((resolve, reject) => {
        console.log('functionB called');
        setTimeout(function() {
            console.log('functionB timeout called = ' + valueA);
            return resolve(20 + valueA);
        }, 10000);

    });
}

function functionC(valueA, valueB) {
    return new Promise((resolve, reject) => {
        console.log('functionC called');
        setTimeout(function() {
            console.log('functionC timeout called = ' + valueA);
            return resolve(valueA + valueB);
        }, 10000);

    });
}

async function executeAsyncTask() {
    const valueA = await functionA();
    const valueB = await functionB(valueA);
    return functionC(valueA, valueB);
}
console.log('program started');
executeAsyncTask().then(function(response) {
    console.log('response called = ' + response);
});
console.log('program ended');

Question 7

कई मायनों में, जनरेटर async / प्रतीक्षा का एक सुपरसेट हैं। अभी async / wait में सह की तुलना में क्लीनर स्टैक के निशान हैं , सबसे लोकप्रिय async / प्रतीक्षारत जनरेटर आधारित lib है। आप अपने स्वयं के स्वाद को लागू कर सकते हैं async / प्रतीक्षा में जनरेटर का उपयोग कर सकते हैं और नई सुविधाओं को जोड़ सकते हैं, जैसे अंतर्निहित समर्थन के लिएyield गैर-वादों के या इसे RxJS वेधशालाओं पर बनाना।

तो, संक्षेप में, जनरेटर आपको अधिक लचीलापन देते हैं और जनरेटर-आधारित कामों में आम तौर पर अधिक विशेषताएं होती हैं। लेकिन async / इंतजार भाषा का एक मुख्य हिस्सा है, यह मानकीकृत है और यह आपके तहत नहीं बदलेगा, और आपको इसका उपयोग करने के लिए किसी पुस्तकालय की आवश्यकता नहीं है। मेरे पास async / प्रतीक्षा और जनरेटर के अंतर पर अधिक विवरण के साथ एक ब्लॉग पोस्ट है ।