Est-ce un anti-pattern d'utiliser async / await dans un nouveau constructeur Promise ()?

J'utilise la async.eachLimitfonction pour contrôler le nombre maximum d'opérations à la fois.

const { eachLimit } = require("async");

function myFunction() {
 return new Promise(async (resolve, reject) => {
   eachLimit((await getAsyncArray), 500, (item, callback) => {
     // do other things that use native promises.
   }, (error) => {
     if (error) return reject(error);
     // resolve here passing the next value.
   });
 });
}

Comme vous pouvez le voir, je ne peux pas déclarer la myFunctionfonction asynchrone car je n'ai pas accès à la valeur à l'intérieur du deuxième rappel de la eachLimitfonction.

Vous utilisez effectivement des promesses dans la fonction exécuteur du constructeur de promesse, c'est donc l' anti-modèle du constructeur Promise .

Votre code est un bon exemple du risque principal: ne pas propager toutes les erreurs en toute sécurité. Lisez pourquoi là-bas .

De plus, l'utilisation de async/ awaitpeut rendre les mêmes pièges encore plus surprenants. Comparer:

let p = new Promise(resolve => {
  ""(); // TypeError
  resolve();
});

(async () => {
  await p;
})().catch(e => console.log("Caught: " + e)); // Catches it.

avec un asyncéquivalent naïf (faux) :

let p = new Promise(async resolve => {
  ""(); // TypeError
  resolve();
});

(async () => {
  await p;
})().catch(e => console.log("Caught: " + e)); // Doesn't catch it!

Recherchez le dernier dans la console Web de votre navigateur.

Le premier fonctionne car toute exception immédiate dans une fonction exécuteur de constructeur Promise rejette commodément la promesse nouvellement construite (mais à l'intérieur de celle-ci, .thenvous êtes seul).

Le second ne fonctionne pas car toute exception immédiate dans une asyncfonction rejette la promesse implicite renvoyée par la asyncfonction elle-même .

Puisque la valeur de retour d'une fonction exécuteur de constructeur de promesse n'est pas utilisée, c'est une mauvaise nouvelle!

Votre code

Il n'y a aucune raison pour laquelle vous ne pouvez pas définir myFunctioncomme async:

async function myFunction() {
  let array = await getAsyncArray();
  return new Promise((resolve, reject) => {
    eachLimit(array, 500, (item, callback) => {
      // do other things that use native promises.
    }, error => {
      if (error) return reject(error);
      // resolve here passing the next value.
    });
  });
}

Mais pourquoi utiliser des bibliothèques de contrôle de concurrence obsolètes lorsque vous en avez await?

Je suis d'accord avec les réponses données ci-dessus et quand même, il est parfois plus simple d'avoir l'asynchrone dans votre promesse, surtout si vous voulez enchaîner plusieurs opérations en retournant des promesses et éviter l' then().then()enfer. J'envisagerais d'utiliser quelque chose comme ça dans cette situation:

const operation1 = Promise.resolve(5)
const operation2 = Promise.resolve(15)
const publishResult = () => Promise.reject(`Can't publish`)

let p = new Promise((resolve, reject) => {
  (async () => {
    try {
      const op1 = await operation1;
      const op2 = await operation2;

      if (op2 == null) {
         throw new Error('Validation error');
      }

      const res = op1 + op2;
      const result = await publishResult(res);
      resolve(result)
    } catch (err) {
      reject(err)
    }
  })()
});

(async () => {
  await p;
})().catch(e => console.log("Caught: " + e));

1. La fonction passée à Promise constructeur n'est pas asynchrone, donc les linters ne montrent pas d'erreurs.
2. Toutes les fonctions asynchrones peuvent être appelées dans un ordre séquentiel en utilisant await .
3. Des erreurs personnalisées peuvent être ajoutées pour valider les résultats des opérations asynchrones
4. L'erreur est finalement bien détectée.

Un inconvénient est que vous devez vous rappeler de le mettre try/catchet de le fixer reject.

static getPosts(){
    return new Promise( (resolve, reject) =>{
        try {
            const res =  axios.get(url);
            const data = res.data;
            resolve(
                data.map(post => ({
                    ...post,
                    createdAt: new Date(post.createdAt)
                }))
            )
        } catch (err) {
            reject(err);                
        }
    })
}

supprimer wait et async résoudra ce problème. parce que vous avez appliqué l'objet Promise, cela suffit.