Attraper les erreurs dans les promesses JavaScript avec un premier niveau essayer ... catch

Donc, je veux que mon premier niveau de captures d'être celui qui gère l'erreur. Est-il de toute façon à propager mon erreur jusqu'à la première prise?

Code de référence, ne fonctionne pas (encore):

Promise = require('./framework/libraries/bluebird.js');

function promise() {
    var promise = new Promise(function(resolve, reject) {
        throw('Oh no!');
    });

    promise.catch(function(error) {
        throw(error);
    });
}

try {   
    promise();
}
//I WANT THIS CATCH TO CATCH THE ERROR THROWN IN THE PROMISE
catch(error) {
    console.log('Caught!', error);
}

source d'informationauteur Kirk Ouimet

Avec la nouvelle async/await syntaxe vous pouvez atteindre cet objectif. Veuillez noter qu'au moment de l'écriture, ce n'est pas supportée par tous les navigateurs, vous avez probablement besoin de transpile votre code avec babel (ou quelque chose de similaire).

//Because of the "async" keyword here, calling getSomeValue()
//will return a promise.
async function getSomeValue() {
  if (somethingIsNotOk) {
    throw new Error('uh oh');
  } else {
    return 'Yay!';
  }
}

async function() {
  try {
    //"await" will wait for the promise to resolve or reject
    //if it rejects, an error will be thrown, which you can
    //catch with a regular try/catch block
    const someValue = await getSomeValue();
    doSomethingWith(someValue);
  } catch (error) {
    console.error(error);
  }
}

19

Vous ne pouvez pas utiliser try-catch des instructions permettant de gérer les exceptions levées de manière asynchrone, la fonction a "retourné" avant qu'une exception est levée. Vous devez plutôt utiliser les promise.then et promise.catch méthodes, qui représentent l'asynchrone équivalent de l'instruction try-catch.

Ce que vous devez faire est de retourner la promesse, puis de la chaîne d'un autre .catch:
```
function promise() {
    var promise = new Promise(function(resolve, reject) {
        throw('Oh no!');
    });

    return promise.catch(function(error) {
        throw(error);
    });
}

promise().catch(function(error) {
    console.log('Caught!', error);
});
```
Promesses sont chainable, donc si une promesse renvoie une erreur, il sera délégué à la prochaine .catch.

Par le chemin, vous n'avez pas besoin d'utiliser des parenthèses autour de throw consolidés (throw a est le même que throw(a)).

Si vous exécutez ce code dans Node.js et pour une raison quelconque vous n'êtes pas autorisé à modifier le promise fonction, vous pouvez utiliser des domaines à le faire. Notez que les domaines ne sont pas exactement la meilleure des choses à s'occuper et de ne pas avoir quelques ennuyeux bord des cas dans certaines circonstances. Sauf si vous devez vraiment, je recommande fortement d'utiliser des promesses plutôt.
4

Pas! C'est tout à fait impossible, comme les promesses sont intrinsèquement asynchrone. Le try-catch clause auront fini de l'exécution lorsqu'une exception est levée (et le temps du voyage ne seront toujours pas été inventée).

Au lieu de cela, le retour des promesses de toutes vos fonctions, un crochet et un gestionnaire d'erreur.
2

Je trouve souvent de la nécessité d'assurer une Promesse est retournée et presque aussi souvent avoir besoin de manipuler un local d'erreur et puis éventuellement renvoyer.
```
function doSomeWork() {
  return Promise.try(function() {

    return request.get(url).then(function(response) {
      //... do some specific work
    });

  }).catch(function(err) {
    console.log("Some specific work failed", err);
    throw err; //IMPORTANT! throw unless you intend to suppress the error
  });
}
```
L'avantage de cette technique (Promesse.try/catch) est que vous/assurer une Promesse chaîne sans les résoudre ou de refuser d'exigence qui peut être facilement manqué et créer un débogage cauchemar.

De s'étendre sur les edo's réponse, si vous voulez rattraper les erreurs de l'asynchrone en fonction de ce que vous ne voulez pas attendre pour. Vous pouvez ajouter un attendent déclaration à la fin de votre fonction.

async function() {
  try {
    const asyncResult = someAsyncAction();

    //"await" will wait for the promise to resolve or reject
    //if it rejects, an error will be thrown, which you can
    //catch with a regular try/catch block
    const someValue = await getSomeValue();
    doSomethingWith(someValue);

    await asyncResult;
  } catch (error) {
    console.error(error);
  }
}

Si someAsyncAction échec de l'instruction catch va la traiter.

Vous devez vous connecter pour publier un commentaire.