Corrigez Essayez ... Syntaxe de capture en utilisant Async / Await

Question

J'aime la planéité de la nouvelle - Async/Await fonctionnalité disponible en caractères d'imprimerie, etc. Cependant, je ne suis pas sûr que j'aime le fait que je dois déclarer la variable, je suis awaiting sur le côté extérieur de l' try...catch bloc afin de l'utiliser plus tard. Comme suit:

let createdUser
try {
    createdUser = await this.User.create(userInfo)
} catch (error) {
    console.error(error)
}

console.log(createdUser)
// business
// logic
// goes
// here

S'il vous plaît corrigez-moi si je me trompe, mais il semble être la meilleure pratique pas à placer plusieurs lignes de la logique métier dans l' try corps, donc je suis reste que l'alternative de déclarer createdUser à l'extérieur du bloc, l'affectant dans le bloc, puis à l'utiliser après.

Quelles sont les meilleures pratiques dans ce cas?

Answer 1

Il semble préférable de ne pas placer plusieurs lignes de la logique métier dans le try corps

En fait, je dirais que c'est. Vous voulez généralement à l' catch toutes les exceptions de travailler avec la valeur:

try {
    const createdUser = await this.User.create(userInfo);

    console.log(createdUser)
    // business logic goes here
} catch (error) {
    console.error(error) // from creation or business logic
}

Si vous voulez attraper et à manipuler que les erreurs de la promesse, vous avez trois choix:

• Déclarer la variable en dehors, et de la direction générale selon qu'il y a une exception ou pas. Qui peut prendre diverses formes, comme

  • attribuer une valeur par défaut à la variable dans l' catch bloc
  • return début ou re-throw une exception à l' catch bloc
  • définir un indicateur de savoir si l' catch bloc pris une exception, et de tester pour elle à un if condition
  • tester la valeur de la variable d'avoir été assigné

  let createdUser; // or use `var` inside the block
  try {
      createdUser = await this.User.create(userInfo);
  } catch (error) {
      console.error(error) // from creation
  }
  if (createdUser) { // user was successfully created
      console.log(createdUser)
      // business logic goes here
  }
  

• Test de l'exception interceptée à son type, et la poignée ou le renvoyer sur la base que.

  try {
      const createdUser = await this.User.create(userInfo);
      // user was successfully created
      console.log(createdUser)
      // business logic goes here
  } catch (error) {
      if (error instanceof CreationError) {
          console.error(error) // from creation
      } else {
          throw error;
      }
  }
  

  Malheureusement, JavaScript standard (encore) n'ont pas de charge de la syntaxe pour des exemptions conditionnelles.

• Utiliser then avec deux rappels au lieu de try/catch. C'est vraiment le moins laid et ma recommandation personnelle aussi pour sa simplicité et sa justesse, en ne s'appuyant pas sur tagged des erreurs ou des regards de la valeur du résultat de la distinction entre la réalisation et le rejet de la promesse:

  await this.User.create(userInfo).then(createdUser => {
      // user was successfully created
      console.log(createdUser)
      // business logic goes here
  }, error => {
      console.error(error) // from creation
  });
  

  Bien sûr, il est livré avec l'inconvénient d'introduire des fonctions de rappel, ce qui signifie que vous ne peut pas aussi facilement break/continue boucles ou de faire le début returns à partir de l'extérieur de la fonction.

Answer 2

Une autre approche plus simple consiste à ajouter .catch à la fonction promesse. ex:

 const createdUser = await this.User.create(userInfo).catch( error => {
// handle error
})
 

Answer 3

@Bergi Réponse est bonne, mais je pense que ce n'est pas la meilleure façon parce que vous avez à revenir à l'ancienne méthode, donc je pense que la meilleure voie est de rattraper l'erreur dans la fonction async

async function someAsyncFunction(){
    const createdUser = await this.User.create(userInfo);

    console.log(createdUser)
}

someAsyncFunction().catch(console.log);

• Mais que faire si nous avons beaucoup d' await dans la même fonction et le besoin de rattraper toutes les erreurs?

Vous pouvez déclarer l' to() fonction

function to(promise) {
    return promise.then(data => {
        return [null, data];
    })
    .catch(err => [err]);
}

Et puis

async function someAsyncFunction(){
    let err, createdUser, anotherUser;

    [err, createdUser] = await to(this.User.create(userInfo));

    if (err) console.log(`Error is ${err}`);
    else console.log(`createdUser is ${createdUser}`);


    [err, anotherUser] = await to(this.User.create(anotherUserInfo));

    if (err) console.log(`Error is ${err}`);
    else console.log(`anotherUser is ${anotherUser}`);
}

someAsyncFunction();

Lors de la lecture de ce son: "Attendre à ce.De l'utilisateur.créer".

Enfin, vous pouvez créer le module "to.js" ou tout simplement utiliser les attendent-à-js module.

Vous pouvez obtenir plus d'informations sur l' to fonction dans ce post