L'importance de toujours détecter les erreurs dans les promesses

Question

J'utilise @typescript-eslint/no-floating-promisesrègles dans mes projets. Si j'écris du code comme celui-ci, cette règle se plaindra -

functionReturningPromise()
    .then(retVal => doSomething(retVal));

Il me veut pour ce Promise 添加一个 catch bloc. Cela a du sens pour moi si je souhaite ajouter de la logique dans le bloc de gestion des exceptions. Cependant, il existe de nombreuses situations dans lesquelles je n'en ai pas besoin. Je suis satisfait de l'erreur générée. Donc, pour supprimer l'erreur générée par cette règle, j'ai fini par faire ceci -

functionReturningPromise()
    .then((retVal) => doSomething(retVal))
    .catch((error) => {
        throw error;
    });

Est-ce que ça fait vraiment une différence même si je n'ajoute pas le catch 块，error 仍然会以相同的方式抛出（至少在我的控制台输出中看到它）。因此，我不明白显式指定此 catch 块的意义。我错过了什么吗？如果我添加/不添加 catch 块，抛出 error comme ci-dessus ?

Answer 1

Les commentateurs ont tous bien répondu à votre question - mais pour illustrer par un exemple pourquoi c'est important, imaginez le code suivant :

Promise.reject();
setTimeout(() => console.log('hello'), 1000);

Ce code semble assez inoffensif - il y a un rejet de promesse de non-opération non géré que le programme enregistrera 'hello' 1 seconde après le démarrage.

Dans le navigateur - c'est exactement ce qui se passera - le navigateur enregistrera une erreur "Uncaught Promise Rejection", mais l'ignorera sinon.

Cependant, dans NodeJS (à partir de Node v15), un rejet de promesse non géré est une erreur matérielle - ce qui signifie que le processus se terminera lorsqu'une erreur est détectée !

Vous pouvez le vérifier en exécutant le code dans Terminal (-e signifie "évaluer et exécuter cette chaîne de code")

$ node -e "Promise.reject(); setTimeout(() => console.log('hello'), 1000)"
node:internal/process/promises:288
            triggerUncaughtException(err, true /* fromPromise */);
            ^

[UnhandledPromiseRejection: This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "undefined".] {
  code: 'ERR_UNHANDLED_REJECTION'
}

Node.js v18.12.1

Vous pouvez voir que 'hello' n'est jamais imprimé car le processus s'est terminé avant 1 seconde !

Pour vérifier que tout fonctionne comme prévu, vous pouvez .reject 更改为 .resolve :

$ node -e "Promise.resolve(); setTimeout(() => console.log('hello'), 1000)"
hello

Donc, si vous écrivez une application NodeJS en utilisant une version prise en charge par LTS, vous devez absolument gérer les erreurs, sinon vous courrez le risque de plantages inattendus.

Si votre code ne s'exécute que dans le navigateur, vous vous demandez peut-être si vous devez gérer les échecs. Après tout, vos utilisateurs ne regardent pas la console, ils ne sauront donc pas que quelque chose de grave s'est produit, alors peu importe ? Du point de vue du « code uniquement », vous avez raison. Cependant, vos utilisateurs souhaitent obtenir un retour de leur application en cas de problème.

Imaginez le scénario suivant : votre promesse suit les résultats d'un appel d'API qui soumet certaines données saisies par l'utilisateur dans votre application. Si l'appel API échoue pour une raison quelconque, votre application doit répondre de manière appropriée et informer l'utilisateur que quelque chose s'est mal passé.

D'autres méthodes de gestion peuvent signifier que votre application affiche un compteur de chargement infini ou que l'utilisateur pense que ses données ont été soumises avec succès alors qu'elles ne l'ont pas été. Quoi qu’il en soit, c’est une expérience utilisateur très mauvaise et brisée !

Il vaudrait mieux faire quelque chose de simple comme .catch(e => { throw e }) 这样的事情，你实际上并没有处理错误。当然，这段代码会使 linter 保持沉默 - 但您所做的只是创建一个新的、被拒绝的承诺，该承诺将记录到控制台。相反，您应该以某种方式将错误连接到应用程序的 UI，例如像 .catch(e => {alert(e); throw e }) au final.