web-dev-qa-db-fra.com

Quoi de plus rapide: essayez catch vs Promise

J'ai entendu une telle opinion que vous devriez éviter l'utilisation de try/catch car cela prend beaucoup de ressources. La promesse de traitement des erreurs pourrait-elle donc être plus rapide? Ou cela n'a pas d'importance du tout?

function f(somethingDangerous) {
  return new Promise((resolve, reject) => {
    // try {
    //   somethingDangerous();
    //   resolve();
    // } catch (err) {
    //   reject(err);
    // }

    // VS

    somethingDangerous();
    resolve();
  }).catch((err) => {
    console.error('Catched: ' + err);
  });
}

f(() => {throw 'DANGEROUS THING';});

[~ # ~] upd [~ # ~] : Je sais que try/catch ne fonctionnera pas avec du code asynchrone à l'intérieur. Je me demande simplement s'il y a des raisons d'éviter d'essayer/attraper en raison de problèmes de performances? Et y a-t-il une différence entre les deux approches ci-dessus?

UPD2 : J'ai essayé de courir mes chevaux :) https://jsperf.com/try-catch-vs-promise

javascriptnode.jspromisetry-catches6-promise
10
Alendorff

Vous devez utiliser Promises niquement pour les fonctions asynchrones et rien d'autre. Ne les abusez pas en tant que monade d'erreur, ce serait un gaspillage de ressources et leur asynchronie inhérente rendra tout plus lourd.

Lorsque vous avez du code synchrone, utilisez try/catch pour la gestion des exceptions.

/* Wrong */
return new Promise(function(resolve, reject) {
    resolve(x / y);
}).catch(err => NaN)

/* Right */
try {
    return x / y;
} catch(e) {
    return NaN;
}

Iff vous avez déjà un code de promesse, vous pouvez éviter cela dans certaines situations: lorsque vous voulez que l'exception rejette la promesse. Dans ces cas, vous devez simplement laisser le traitement des erreurs intégré de vos promesses faire son travail, et ne pas tout compliquer par une couche supplémentaire mais inutile try/catch:

/* Wrong */
new Promise(function(resolve, reject) {
    try { // when used synchronous in the executor callback
        …
        resolve(somethingSynchronous());
    } catch (e) {
        reject(e);
    }
});

/* Right */
new Promise(function(resolve, reject) {
    …
    resolve(somethingExceptionally());
});

/* Wrong */
….then(function(res) {
    try {
        …
        return somethingExceptionally();
    } catch(e) {
        return Promise.reject(e);
    }
}).…

/* Right */
….then(function(res) {
    …
    return somethingExceptionally();
}).…
16
Bergi

try/catch l'idiome fonctionne très bien lorsque vous avez du code synchronous complet, mais les opérations asynchronous le rendent inutile, aucune erreur ne sera détectée. c'est-à-dire que la fonction commencera son cours pendant que la pile externe traverse et arrive à la dernière ligne sans aucune erreur. Si une erreur se produit à un certain moment dans le futur à l'intérieur de la fonction asynchrone - rien ne sera intercepté.

Lorsque nous utilisons Promises, "nous avons perdu notre gestion des erreurs", pourriez-vous dire. C'est vrai, nous n'avons pas besoin de faire quoi que ce soit de spécial ici pour propager l'erreur, car nous renvoyons une promesse et il existe un support intégré pour le flux d'erreurs.

2
Lakshmi Swetha G