Gestion des erreurs avec les promesses JavaScript
Gestion des erreurs avec les promesses JavaScript : .catch(), propagation des rejets, rethrow, récupération, .finally(), unhandledrejection et try/catch avec async/await.
Les promesses JavaScript constituent un élément fondamental de la gestion des opérations asynchrones, permettant aux développeurs de traiter les événements asynchrones avec plus de souplesse et de facilité (voir JavaScript : les promesses). La gestion des erreurs dans les promesses est essentielle pour écrire du code JavaScript robuste, capable de faire face à des problèmes imprévus sans faire planter l'application.
Ce chapitre explique comment les rejets sont interceptés, comment les erreurs se propagent dans une chaîne, comment les renvoyer ou les récupérer, le crochet de nettoyage .finally(), le filet de sécurité global unhandledrejection, et comment les mêmes schémas s'appliquent à async/await. Si vous débutez avec l'enchaînement des appels .then(), lisez d'abord Enchaînement des promesses.
Une promesse peut se terminer dans l'un de deux états : remplie (elle a produit une valeur) ou rejetée (quelque chose s'est mal passé). Un rejet survient lorsque vous appelez reject(...), lorsque vous faites un throw dans un exécuteur ou un rappel .then(), ou lorsqu'une API asynchrone intégrée échoue. La gestion des erreurs consiste à acheminer ces rejets vers un gestionnaire plutôt que de laisser le programme planter.
La gestion des erreurs dans les promesses s'effectue à l'aide de la méthode .catch() ou en passant un deuxième argument à la méthode .then(). Ces deux méthodes permettent de gérer et de récupérer les erreurs survenant lors de l'exécution d'opérations asynchrones.
Utilisation de la méthode .catch()
La méthode .catch() est utilisée pour intercepter toutes les erreurs survenant lors de l'exécution de la chaîne de promesses.
Utilisation du deuxième argument de .then()
On peut également passer un deuxième argument à .then() pour gérer les erreurs survenant après l'exécution du rappel du premier argument.
Techniques avancées de gestion des erreurs
Flux d'erreurs dans les chaînes
Les erreurs doivent se propager correctement dans la chaîne de promesses afin d'être traitées au niveau approprié. Par exemple, si vous placez le bloc .catch() avant le bloc .then(), le bloc .then() s'exécutera quand même. En effet, .catch() résout la chaîne de promesses (sauf s'il renvoie une erreur), et le .then() suivant reçoit undefined comme argument.
Lorsque vous placez le bloc .catch() avant le bloc .then(), toute erreur levée dans le .then() ne sera pas interceptée par le .catch() précédent. Elle ne sera traitée que si vous ajoutez un autre bloc .catch() après.
Propagation des rejets
Il n'est pas nécessaire d'ajouter un .catch() après chaque .then(). Un rejet saute tous les gestionnaires de succès (le premier argument de .then()) et parcourt la chaîne jusqu'au premier .catch(). Cela vous permet d'écrire une longue chaîne d'étapes et de traiter tous les échecs en un seul endroit à la fin.
Dans l'exemple ci-dessous, le rejet se produit dès le début, mais aucun des trois rappels .then() ne s'exécute — le contrôle passe directement au seul .catch() :
Renvoi et récupération des erreurs
Un gestionnaire .catch() remplit deux fonctions selon ce qu'il fait :
- Récupérer — s'il retourne une valeur (ou ne retourne rien), la chaîne redevient remplie et le prochain
.then()s'exécute avec cette valeur. C'est ainsi que l'on fournit une valeur de repli. - Renvoyer — s'il fait un
throw(ou retourne une promesse rejetée), l'erreur continue à se propager vers le prochain.catch(). Utilisez cela lorsqu'un gestionnaire ne peut pas traiter complètement l'erreur et souhaite qu'un gestionnaire ultérieur termine le travail.
Gestion des erreurs spécifiques
JavaScript permet des stratégies de gestion des erreurs plus nuancées, notamment le filtrage des erreurs selon leur type ou les circonstances particulières de l'erreur. Dans l'exemple suivant, nous traitons un TypeError. Un TypeError se produit généralement lorsqu'une valeur n'est pas du type attendu, ce qui empêche l'opération souhaitée.
Bonnes pratiques pour la gestion des erreurs dans les promesses
- Toujours retourner ou relancer les erreurs dans les blocs catch afin que les erreurs ne soient pas ignorées silencieusement.
- Enchaîner les promesses correctement pour s'assurer que les erreurs sont interceptées et traitées.
- Utiliser les blocs finally lorsque nécessaire pour effectuer des tâches de nettoyage, indépendamment du résultat de la promesse.
Implémentation d'un bloc finally
La méthode finally() est utilisée pour exécuter un bloc de code après le règlement des promesses, quel qu'en soit le résultat.
Interception des rejets non gérés
Si une promesse est rejetée et qu'aucun .catch() ne la traite, l'erreur est perdue silencieusement — il n'y a pas de try/catch englobant comme avec le code synchrone. Pour éviter que des bugs ne disparaissent, l'environnement déclenche un événement global unhandledrejection que vous pouvez écouter. Il s'agit d'un filet de sécurité de dernier recours pour la journalisation et le signalement, et non d'un substitut à un véritable .catch().
Dans le navigateur :
Dans Node.js, l'équivalent est process.on('unhandledrejection', (reason) => { ... }).
Gestion des erreurs avec async/await
async/await est construit sur les promesses, donc les mêmes rejets se produisent — mais vous les interceptez avec un bloc try/catch ordinaire, qui se lit comme du code synchrone. Un await sur une promesse rejetée lève une exception à l'intérieur de la fonction async, et try/catch l'intercepte. Consultez JavaScript : async/await pour une vue d'ensemble complète.
Un try/catch à l'intérieur d'une fonction async n'intercepte que les erreurs des promesses que vous await. Si vous appelez une fonction retournant une promesse sans await, son rejet échappe au try/catch — vous devez soit l'awaiter, soit lui attacher un .catch().
Conclusion
Une gestion efficace des erreurs dans les promesses JavaScript est indispensable pour développer des applications web fiables et résilientes. En maîtrisant la méthode .catch(), le deuxième argument de .then(), la propagation des rejets, le renvoi des erreurs et le crochet de nettoyage .finally(), les développeurs peuvent s'assurer que leurs applications gèrent les erreurs asynchrones avec élégance et se rétablissent plutôt que de planter. Lorsque vous travaillez avec async/await, encapsulez les appels de promesses attendus dans des blocs try/catch pour une gestion des erreurs à l'allure synchrone, et conservez un écouteur global unhandledrejection comme filet de sécurité pour les cas que vous auriez manqués.
Pour approfondir, continuez avec Enchaînement des promesses et l'API Promise.