Async: Promesse de retour si le rappel n'est pas fourni ?

Créé le 27 févr. 2018 · 8Commentaires · Source: caolan/async

C'est bien d'avoir dans ES2017 un développement asynchrone / en attente

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

feature feedback-wanted

Source

rocketspacer

👍27

Commentaire le plus utile

J'y ai pensé et j'ai un peu expérimenté. Les gens vont vouloir await Async.mapLimit(arr, 10, async foo => {...}) . Cela pourrait très bien être quelque chose que nous incluons dans la version 3.0.

De plus, certaines méthodes Async seraient assez idiotes avec async/await, par exemple series , waterfall .

aearly le 2 mars 2018

👍10 😕1 😄1

Tous les 8 commentaires

Historiquement, async s'y est opposé (voir #1086).

Cependant, avec la nouvelle syntaxe async/await , le nœud ajoutant des API promises à l'avenir et la prise en charge des promesses ayant augmenté, je serais prêt à revoir cela. Pensées @aearly @megawac?

hargasinski le 2 mars 2018

De plus, certaines méthodes Async seraient assez idiotes avec async/await, par exemple series , waterfall .

aearly le 2 mars 2018

👍10 😕1 😄1

Lors de l'utilisation d'Async, j'ai en quelque sorte naturellement supposé le retour d'une promesse. Ce n'est qu'au dysfonctionnement de mon code et de mon moment de routine rtfm que j'ai remarqué la structure de rappel. Ce qui précède serait le bienvenu car il garderait le code ES7 aussi uniforme que possible.

ralphdas le 6 mars 2018

👍2

Je suis d'accord que ce serait utile.

En attendant, si quelqu'un est bloqué en ce moment, j'ai trouvé cet article utile pour expliquer comment écrire une boucle forEach avec await.
https://codeburst.io/javascript-async-wait-with-foreach-b6ba62bbf404

rorymadden le 14 mars 2018

Enfin déterré mon ancienne expérience : #1526

aearly le 15 avr. 2018

👍1

rodrigogs le 19 juil. 2018

Convertir en méthode asynchrone

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);
  });
}

Exemple 1:

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

exemple2 :

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);
}

anytool le 26 juil. 2018

@tritoanst , votre fonction promisify est en surcharge. C'est peut-être plus simple :

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);
};