Async: वादा समर्थन

asyncify एक सिंक्रोनस फ़ंक्शन लेगा जो एक वादा लौटाता है और इसके हल/अस्वीकार हैंडलर पर कॉलबैक कॉल करता है:

async.waterfall([
    function (done) {
        // Do something and call done()
        fs.readFile(filepath, done);
    },
    async.asyncify(function(content) {
        // Do something and return Promise
        return mongoose.models.file.create({
            name: filepath,
            content: content
        });
    })
], (err, model) => {
    if (err) {
        console.error(err);
    }
});

लेकिन उस सुविधा का दस्तावेजीकरण नहीं किया गया है ...

मेरे पास एक और विचार भी था - क्या हमें स्वचालित रूप से उन कार्यों को अतुल्यकालिक करना चाहिए जो वादे लौटाते हैं (या उन्हें उचित रूप से संभालते हैं?) ES-जो भी async फ़ंक्शन (जो कि एक वादा लौटाता है) पारित होने पर async को क्या करना चाहिए?

जैसे

async.waterfall([
    function (done) {
        // Do something and call done()
        fs.readFile(filepath, done);
    },
    async function(content) {
        return await mongoose.models.file.create({
            name: filepath,
            content: content
        });
    }
], (err, model) => {
    if (err) {
        console.error(err);
    }
});

व्यक्तिगत रूप से, मुझे लगता है कि async को डिफ़ॉल्ट रूप से वादों को asyncify करना चाहिए। कुछ async फ़ंक्शन हैं जो मैं लिखता हूं कि मुझे async.queue में भी फीड करना है, लेकिन मैं इसे लिखना नहीं चाहता:

import {queue, asyncify} from 'async'

const run = asyncify(async function () {
  await someStuff()
})

const q = async.queue(run)
q.push('asdf')

मैं यह कहाँ लिख सकता था

import {queue} from 'async'

async function run () {
  await someStuff()
}

const q = async.queue(run)
q.push('asdf')

asyncify लिए दस्तावेज़ जोड़े गए। स्वचालित asyncify-ing व्यवहार के लिए इसे खुला रखने जा रहे हैं।

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

async.waterfall([
  function (callback) {
    callback(null, 'one', 'two')
  },
  function (arg1, arg2, callback) {
    // arg1 now equals 'one' and arg2 now equals 'two'
    callback(null, 'three')
  },
  function (arg1, callback) {
    // arg1 now equals 'three'
    callback(null, 'done')
  }
]).then(function (value) {
  console.log(value === 'done')
})

आप इसके बारे में क्या सोचते हैं? मुझे लगता है कि पुस्तकालय को अनुकूलित करना आसान हो सकता है। उदाहरण के लिए देखें कि लाइब्रेरी हैंडल cb और वादा कैसे काम करता है ।

बहुत ही रोचक। यदि Async ने वादे वापस करने वाले कार्यों को ठीक से संभाला है, तो यह वादा-एड Async फ़ंक्शन को बहुत आसानी से स्वीकार कर सकता है। यह काम करेगा:

async.parallel([
  async.waterfall([
    asyncFn1,
    function (result1, next) {
      //...
    }
    asyncFn2,
    //...
  ]), // no callback!
  async.each(arr, function (item, cb) {
    //...
  })
  otherAsyncFn
], done)

Async फ़ंक्शंस को संयोजित करना बहुत आसान होगा।

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

हालांकि, अगर किसी विधि से अंतिम कॉलबैक छोड़ने से यह एक वादा वापस कर देता है, और यदि Async को उन कार्यों को संभालने के लिए सेट किया जाता है जो वादे वापस करते हैं, तो यह एक दिलचस्प कॉम्बो है। एक प्रमुख मुद्दा तब Async को एक वादा पुस्तकालय के साथ एकीकृत करना होगा - कौन सा? क्या हम पुराने इंजनों को पॉलीफ़िल करने के लिए बाध्य करते हुए global.Promise पर भरोसा करते हैं, या हम ब्लूबर्ड जैसी किसी चीज़ का उपयोग करते हैं? इसके अलावा, Async वादों के खिलाफ एक तरह का बयान है - फ्यूचर्स प्रतिमान को अपनाने के बजाय कॉलबैक-स्वीकार करने वाले कार्यों के लिए उच्च-आदेश फ़ंक्शन। मैं सभी वादों के साथ अंतःक्रियाशीलता के लिए हूं, लेकिन मुझे लगता है कि Async वापसी वादे इसके डिजाइन दर्शन से थोड़ा बाहर हैं।

@ अर्ली

मुझे लगता है कि वादे पिछले नोड संस्करणों (>=4) के साथ एक कार्यप्रवाह संरेखित है। इस संस्करण में वादे उपलब्ध हैं, इसलिए, मेरी दृष्टि वैश्विक वातावरण में वादे होने पर वादा कार्यप्रवाह का उपयोग करना है।

यह संभव है कि एक छोटा पॉलीफिल जोड़ें ( पिंकी-वादा जांचें) लेकिन मेरी राय में पॉलीफिल प्रदान करने का कोई मतलब नहीं है। अंतिम नोड सुविधाओं का उपयोग करने के लिए उपयोगकर्ता को नोड संस्करण को अपग्रेड करने के लिए बेहतर बल दें। वास्तव में, जांचें (6 पीआर प्राप्त करें) [https://github.com/sindresorhus/got/pull/140]। बहुत छोटी परियोजना में निर्भरता का स्वागत नहीं है और हर जगह इसका उपयोग किया जाता है।

हो सकता है कि इस सुविधा को async मॉडर्नाइजेशन के बाद शामिल किया जाना अच्छा हो, कि कोडबेस को अनुकूलित करना अधिक आसान होगा।

लेकिन निश्चित रूप से, वादों के साथ async को संरेखित करना पूरी तरह से _must_ है!

@ किकोबीट्स : +1:

वादे प्रथम श्रेणी के एसिंक्स फंक्शन बनते जा रहे हैं। तो उनके पूर्ण समर्थन के बिना एसिंक्रोनस के लिए जरूरी पुस्तकालय की कल्पना करना मुश्किल है।

मुझे लगता है कि इसे पॉलीफिल के बिना लागू किया जा सकता है लेकिन फीचर डिटेक्शन के साथ: अनुमति दें कि resolve विधि के साथ वैश्विक वादा वस्तु है या नहीं।

@aearly bluebird

@martinheidegger Bluebird इसके लिए बहुत बड़ा है। यह वादा विधियों के सरल समर्थन के लिए 76 Kb (मिनीफाइड) डालेगी।

फिर से, अपने बैकएंड वर्कफ़्लो में कॉलबैक या वादों इंटरफ़ेस का उपयोग करें, यह आपके नोड संस्करण पर आधारित एक प्राकृतिक प्रक्रिया है।

• यदि आपके पास अधिक समय बैकएंड (2 वर्ष या अधिक, हो सकता है) है, तो आप 0.10 या 0.12 संस्करण का उपयोग करते हैं, इसलिए, आपका कोड कॉलबैक शैली में लिखा गया है।
• यदि आपके बैकएंड में ~6 महीने से कम का समय है और आप >=4 नोड संस्करण का उपयोग करते हैं तो शायद आप एक वादा शैली का उपयोग करते हैं।

लेकिन किसी भी मामले में आपके पास मिश्रित शैली नहीं है।

तो जरूरी नहीं है समर्थन के लिए एक निर्भरता जोड़ें वादे; यदि भविष्य में एक दिन async वादों का समर्थन करता है, तो आप इसका उपयोग कर सकते हैं यदि आपका नोड संस्करण वादों का समर्थन करता है।

चरम मामला: _मैं पुराने नोड संस्करण का उपयोग कर रहा हूं लेकिन मेरा बैकएंड वादे शैली_ का उपयोग करके लिखा गया है। फिर आपने एक वादा वस्तु को वैश्विक के रूप में परिभाषित किया है या async का उपयोग करने से पहले एक को परिभाषित किया है । जो तुम्हे चाहिये। बस।

फ्रंटएंड साइड के लिए वही व्यवहार। निर्भरता आवश्यक नहीं है।

हम्म, ऐसा लगता है कि वही समस्याएं हैं जो 4-5 साल पहले के वादे अब भी लागू होते हैं। यदि हर कोई नोड 4 या बाद के संस्करण, और ES6 समर्थन वाले आधुनिक ब्राउज़रों का उपयोग कर रहा था, तो मैं जहां लागू हो वहां आंतरिक रूप से वादों का आसानी से उपयोग कर सकता था।

समस्या यह है कि हम अपने नोड 0.12 और पुराने ब्राउज़र उपयोगकर्ताओं को धूल में छोड़ देते हैं, जिससे उन्हें पॉलीफिल करने की आवश्यकता होती है। वे किस पॉलीफिल का उपयोग करते हैं? हम एक को बंडल नहीं करना चाहेंगे, यहां तक ​​​​कि पिंकी-वादे का भी वजन है। साथ ही, जो लोग मानक ES6 प्रॉमिस के बाहर वादों का उपयोग कर रहे हैं, वे ब्लूबर्ड या q आदि का उपयोग करना चाहेंगे, चाहे वह कुछ भी हो। मैं पॉलीफ़िल के उपयोग की आवश्यकता नहीं चाहता - npm i -S async सभी लोगों को करना चाहिए।

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

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

सहमत, वादे बनाने या संसाधित करने के लिए सस्ते नहीं हैं। मैं इसके बजाय एक ऑप्ट इन एक्सटेंशन के रूप में कुछ इस तरह देखना चाहूंगा। वादे महान हैं लेकिन आप उन्हें हमेशा नहीं चाहेंगे

आईएमएचओ, वादों + सह + उपज के लिए बहुत सारे नोड कोड माइग्रेट करने के बाद, मुझे केवल .eachLimit() लिए प्रत्यक्ष प्रतिस्थापन नहीं मिला। संभवतः, उपयोगी मामलों की सूची पहली नज़र में देखने की तुलना में बहुत कम है, और इसे अलग पैकेज के साथ नियंत्रित किया जा सकता है।

मुझे @Kikobeats का छोटा एक्सटेंशन पसंद है , इसे रीडमी (/cc @aearly) में अनुशंसा करना समझ में आता है।

मैं अपने और अन्य उपयोगकर्ताओं द्वारा लाए गए कारणों के लिए एसिंक्स में वादों के आधिकारिक समर्थन का कड़ा विरोध करूंगा।

@megawac उस मामले के बारे में क्या है जहां कोई फ़ंक्शन वादा करता है? उदाहरण के लिए @SEAPUNK का उदाहरण।

@megawac I ने async में कॉलबैक शैली, परीक्षण और ब्राउज़र निर्माण के लिए समर्थन जोड़ा। फिर अगर कोई वादा का उपयोग करना चाहता है, तो मुझे लगता है कि वह तैयार है: +1:

@aearly , यह ठीक होगा मुझे लगता है (इसलिए =) लेकिन मैं इसे प्लगइन में छोड़
व्यक्तिगत रूप से भूमि

शुक्रवार, 22 जनवरी, 2016 दोपहर 2:17 बजे, किको बीट्स नोटिफिकेशन @github.com
लिखा था:

@megawac https://github.com/megawac मैंने कॉलबैक शैली के लिए समर्थन जोड़ा
और वादा-async के लिए परीक्षण
https://github.com/Kikobeats/promise-async#promise -async। तो अगर
कोई भी वादा का उपयोग करना चाहता है, मुझे लगता है कि यह तैयार है [छवि:: +1:]

-
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें
https://github.com/caolan/async/issues/956#issuecomment -174016628।

यहां एक और पैकेज है जो सभी उपलब्ध एसिंक्स विधियों का वादा करता है:
https://github.com/eladnava/koa-async

मुझे लगता है कि जैसे async.asyncify है वैसे ही async.promisify फ़ंक्शन हो सकता है।

तब मैं बस इंतजार कर सकता हूं async.promisify(async.mapLimit(x,10, mapper))

यदि आप पुल अनुरोध बनाना चाहते हैं तो मुझे उस पर कोई आपत्ति नहीं होगी

शनिवार, 17 दिसंबर, 2016 को शाम 4:57 बजे, मनोज पटेल सूचनाएं @github.com
लिखा था:

मुझे लगता है कि जैसे async.asyncify है वैसे ही async.promisify . भी हो सकता है
समारोह।

तब मैं बस इंतजार कर सकता हूं async.promisify(async.mapLimit(x,10, mapper))

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/caolan/async/issues/956#issuecomment-267789633 , या म्यूट करें
सूत्र
https://github.com/notifications/unsubscribe-auth/ADUIEKJIDulPHAn_SeEZbiPb3t7ORGnpks5rJFqvgaJpZM4Gh1fr
.

मैं कॉलबैक को वादों में बदलने के लिए bluebird मॉड्यूल की PromisifyAll विधि का उपयोग कर रहा हूं ताकि async के तरीके बन जाएं:

// adds '<original-method>Async' to class 
Promise.promisifyAll(async);

function somePromise() {
    return async.parallelAsync([
        function(cb) {
            setTimeout(function(){
                cb(new Error('err'), 'foo')
            }, 1000);
        },
        function(cb) {
            setTimeout(function(){
                cb(null, 'bar')
            }, 1000);
        }
    ]);
}

somePromise().then(function(result){
    console.log('result',result);
}).catch(function(err){
    console.log('err',err);
});

JSFiddle उदाहरण