Qu'est-ce qu'un rejet de promesse non géré?

Question

Pour apprendre Angular 2, j'essaie leur tutoriel.

Je reçois une erreur comme celle-ci:

 (node:4796) UnhandledPromiseRejectionWarning: Unhandled promise rejection (r                                                                                                     ejection id: 1): Error: spawn cmd ENOENT
[1] (node:4796) DeprecationWarning: Unhandled promise rejections are deprecated.
In the future, promise rejections that are not handled will terminate the Node.
js process with a non-zero exit code.
 

Je suis passé par différentes questions et réponses dans SO mais ne pouvais pas savoir ce qu'est un "rejet de promesse non gérée".

Quelqu'un peut-il simplement m'expliquer ce que c'est et aussi ce que Error: spawn cmd ENOENT est, quand il se produit et ce que je dois vérifier pour me débarrasser de cet avertissement?

Answer 1

L'origine de cette erreur réside dans le fait que chaque promesse est prévu pour gérer la promesse de rejet c'est à dire .catch(...) . vous pouvez éviter de faire de même en ajoutant .catch(...) à une promesse dans le code donné ci-dessous.

par exemple, la fonction PTest() permettra de résoudre ou de rejeter une promesse basée sur la valeur d'une variable globale somevar

var somevar = false;
var PTest = function () {
    return new Promise(function (resolve, reject) {
        if (somevar === true)
            resolve();
        else
            reject();
    });
}
var myfunc = PTest();
myfunc.then(function () {
     console.log("Promise Resolved");
}).catch(function () {
     console.log("Promise Rejected");
});

Dans certains cas, le "non gérée promesse de rejet" message vient même si nous avons .catch(..) écrit pour des promesses. Il est tout au sujet de la façon dont vous écrivez votre code. Le code suivant va générer des "non gérée promesse de rejet" même si nous sommes de manutention catch.

var somevar = false;
var PTest = function () {
    return new Promise(function (resolve, reject) {
    if (somevar === true)
        resolve();
    else
        reject();
});
}
var myfunc = PTest();
myfunc.then(function () {
     console.log("Promise Resolved");
});
// See the Difference here
myfunc.catch(function () {
     console.log("Promise Rejected");
});

La différence est que vous ne traitez .catch(...) chaîne mais séparée. Pour une raison quelconque moteur JavaScript traite comme promesse sans non-traitée promesse de rejet.

Answer 2

C'est quand un Promise est complété par .reject() ou une exception a été levée dans un async code exécuté et n' .catch() n'a gérer le rejet.

Le refus de la promesse, c'est comme une exception que les bulles vers l'application de point d'entrée et les causes de la racine du gestionnaire d'erreur pour produire cette sortie.

Voir aussi - https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise/reject - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch

Answer 3

Les promesses peuvent être "gérée" après ils sont rejetés. C'est, on peut appeler une promesse de rejet du rappel avant de fournir un gestionnaire catch. Ce comportement est un peu gênant pour moi car on peut écrire...

var promise = new Promise(function(resolve) {
kjjdjf(); // this function does not exist });

... et dans ce cas, la Promesse est rejeté en silence. Si on oublie d'ajouter un gestionnaire catch, code continuera à exécuter silencieusement sans erreurs. Cela pourrait conduire à la longue et dur-à-trouver des bugs.

Dans le cas de Node.js on parle de la manipulation de ces non gérée Promesse de rejets et de reporting les problèmes. Ce qui m'amène à ES7 async/await. Considérons cet exemple:

async function getReadyForBed() {
  let teethPromise = brushTeeth();
  let tempPromise = getRoomTemperature();

  // Change clothes based on room temperature
  let temp = await tempPromise;
  // Assume `changeClothes` also returns a Promise
  if(temp > 20) {
    await changeClothes("warm");
  } else {
    await changeClothes("cold");
  }

  await teethPromise;
}

Dans l'exemple ci-dessus, supposons que teethPromise a été rejetée (Erreur: de dentifrice!) avant getRoomTemperature a été remplies. Dans ce cas, il y aurait un non gérée Promesse de rejet jusqu'à ce attendent teethPromise.

Mon point est ceci... si l'on considère non gérée Promesse de rejets d'être un problème, des Promesses qui sont ensuite traitées par une attendent peut obtenir, par inadvertance, a rapporté que les bogues. Là encore, si l'on considère non gérée Promesse de rejets de ne pas être problématique, légitime les bugs ne sont pas signalés.

Pensées à ce sujet?

Ceci est lié à la discussion trouvés dans le Node.js projet ici:

Par Défaut Non Gérée Rejet De Détection De Comportement

si vous écrivez le code de cette façon:

function getReadyForBed() {
  let teethPromise = brushTeeth();
  let tempPromise = getRoomTemperature();

  // Change clothes based on room temperature
  return Promise.resolve(tempPromise)
    .then(temp => {
      // Assume `changeClothes` also returns a Promise
      if (temp > 20) {
        return Promise.resolve(changeClothes("warm"));
      } else {
        return Promise.resolve(changeClothes("cold"));
      }
    })
    .then(teethPromise)
    .then(Promise.resolve()); // since the async function returns nothing, ensure it's a resolved promise for `undefined`, unless it's previously rejected
}

Lorsque getReadyForBed est invoqué, il sera en mode synchrone créer de la finale (pas retourné) promesse - qui aura le même "non gérée rejet" erreur comme toute autre promesse (peut-être pour rien, bien sûr, en fonction du moteur). (Je trouve ça très bizarre votre fonction ne retourne rien, ce qui signifie que votre async fonction produit une promesse pour non-défini.

Si je fais une Promesse sans un hic, et ajouter un plus tard, la plupart des "non gérée rejet d'erreur" implémentations en se rétracter de l'avertissement quand je le fais plus tard le gérer. En d'autres termes, async/await ne modifie pas le "non gérée rejet" de discussion en quelque sorte que je peux voir.

pour éviter cet écueil, veuillez écrire le code de cette façon:

async function getReadyForBed() {
  let teethPromise = brushTeeth();
  let tempPromise = getRoomTemperature();

  // Change clothes based on room temperature
  var clothesPromise = tempPromise.then(function(temp) {
    // Assume `changeClothes` also returns a Promise
    if(temp > 20) {
      return changeClothes("warm");
    } else {
      return changeClothes("cold");
    }
  });
  /* Note that clothesPromise resolves to the result of `changeClothes`
     due to Promise "chaining" magic. */

  // Combine promises and await them both
  await Promise.all(teethPromise, clothesPromise);
}

Notez que cela devrait empêcher toute non gérée promesse de rejet.

Answer 4

"DeprecationWarning: les rejets de promesses non gérées sont obsolètes"

TLDR: Une promesse a resolve et reject , faire un reject sans prise à manipuler est obsolète, vous devrez donc au moins avoir un catch au plus haut niveau.