Async: यदि कॉलबैक प्रदान नहीं किया जाता है तो वापसी का वादा?

ऐतिहासिक रूप से, async इसके खिलाफ रहा है (देखें #1086)।

हालांकि, नए async/await सिंटैक्स के साथ, नोड भविष्य में वादा एपीआई जोड़ रहा है , और वादों के समर्थन में वृद्धि हुई है, मैं इसे फिर से देखने के लिए तैयार हूं। विचार @aearly @megawac?

मैंने इसके बारे में सोचा है, और इसके साथ थोड़ा प्रयोग किया है। लोग await Async.mapLimit(arr, 10, async foo => {...}) चाहते हैं। यह कुछ ऐसा हो सकता है जिसे हम 3.0 में शामिल करते हैं।

साथ ही, कुछ एसिंक विधियां एसिंक/प्रतीक्षा के साथ बहुत मूर्खतापूर्ण होंगी, उदाहरण के लिए series , waterfall ।

Async का उपयोग करते समय I ने स्वाभाविक रूप से एक वादे की वापसी मान ली। यह केवल मेरे कोड के खराब होने और मेरे नियमित आरटीएफएम पल में था कि मैंने कॉलबैक संरचना पर ध्यान दिया। उपरोक्त का बहुत स्वागत होगा क्योंकि यह कोड को यथासंभव समान ES7 के रूप में रखेगा।

मैं सहमत हूं कि यह उपयोगी होगा।

अंतरिम में, अगर कोई अभी फंस गया है, तो मुझे यह आलेख यह समझाने के लिए अच्छा लगा कि प्रत्येक लूप को प्रतीक्षा के साथ कैसे लिखना है।
https://codeburst.io/javascript-async-await-with-foreach-b6ba62bbf404

अंत में मेरे पुराने प्रयोग को खोज निकाला: #1526

+1

• async विधि में कनवर्ट करें

function makeAsync() {
  if (arguments.length < 3) return; // wrong params, not run or throw exception here!
  let fixParams = {};
  let paramLength = arguments.length;
  let method = arguments[0];
  for (let i = 1; i < arguments.length; i++) {
    fixParams[(i - 1)] = arguments[i];
  }
  return new Promise((resolve, reject) => {
    const callback = (err, result) => {
      if (err) return reject(err);
      return resolve(result);
    };

    fixParams[paramLength - 1] = callback;
    fixParams.length = paramLength;
    method.apply(null, fixParams);
  });
}

उदाहरण 1:

await makeAsync(async.each, openFiles, async (file) => {
  await asyncOperation(file);
});

उदाहरण 2:

const foo = async () => {
    const arr = Array.from({ length: 1000 }, (v, i) => i);
    const transformedArr = await makeAsync(async.mapLimit, arr, 100, async (v) => {
        return await Promise.resolve(v * 2);
    });
    console.log(transformedArr);
}

@tritoanst , आपका वादा कार्य ओवरहेड है। यह आसान हो सकता है:

function promisify(original) {
    return function (...args) {
        return new Promise((resolve, reject) => {
            args.push((err, result) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(result);
                }
            });

            original.apply(this, args);
        });
    };
}

const foo = async () => {
    const arr = Array.from({ length: 1000 }, (v, i) => i);
    const transformedArr = await promisify(async.mapLimit)(arr, 100, async (v) => {
        return v * 2; // `return await` is redundant
    });
    console.log(transformedArr);
};