Tout d’abord, il est nécessaire de comprendre ce qu’est une erreur et ses types.
Types d'erreurs
Lorsque vous travaillez dans n'importe quel langage de programmation, deux types d'erreurs peuvent généralement survenir :
Erreur opérationnelle
Une erreur opérationnelle se produit lorsque l’application est confrontée à une exception non gérée ou à un problème dans le code. Ce type d'erreur est généralement difficile à repérer car il existe de nombreuses causes à son origine, par ex. fuite de mémoire, boucles sans fin, conception de système inexacte, etc.
Un moyen efficace de traiter les erreurs opérationnelles consiste à utiliser une stratégie de gestion des erreurs optimale pour repérer l'erreur à son origine et en informer le développeur afin qu'elle puisse être résolue à temps.
Erreur fonctionnelle
Les erreurs fonctionnelles sont celles qui interrompent le fonctionnement normal du code d’application. Comme ces erreurs se comportent différemment, elles peuvent nécessiter davantage de réflexion pour déterminer leur origine, car elles peuvent se comporter différemment au cours du cycle de vie de l'application.
Un cas simple peut être un programme dans lequel l'utilisateur a implémenté une mauvaise logique, ce qui peut entraîner une boucle infinie et finalement faire planter le programme.
Les développeurs doivent creuser profondément dans la base de code pour identifier d'éventuelles erreurs fonctionnelles en utilisant des techniques telles que le débogage et les traces de pile, etc.
Maintenant que nous connaissons le type d’erreur qui peut survenir dans notre script de code, il est nécessaire de comprendre pourquoi il est nécessaire de gérer l’erreur.
Insistance à gérer les erreurs dans Node.js
Avant d'expliquer le concept de gestion des erreurs dans Node.js à l'aide de try-catch ; il est nécessaire de comprendre pourquoi il est nécessaire de gérer les erreurs. La gestion des erreurs dans le code de l’application est cruciale pour établir une application d’expérience utilisateur fiable et améliorée pour les utilisateurs.
Améliorer l'expérience utilisateur
C'est une bonne pratique d'éviter l'utilisation de messages génériques et d'afficher des messages d'erreur conviviaux pour une meilleure expérience utilisateur.
Construire une base de code plus solide
Lorsque les erreurs sont gérées de manière optimale, les fondements du code semblent plus réalistes. Il capture et gère efficacement les erreurs souhaitées, réduisant ainsi le risque de crash de l'application.
Détection de bogues
La gestion des erreurs permet de repérer facilement les bogues pendant la phase de développement et de les supprimer le plus tôt possible. Cela permet aux utilisateurs d'optimiser plus précisément leurs applications pendant la phase de développement, permettant ainsi au code de circuler sans aucune interruption.
Crash d'application
Ne pas gérer les erreurs peut entraîner une interruption soudaine du flux de code et finalement un blocage de l'application. L'utilisation d'un ' essayer-attraper Le bloc « » nous permet de gérer les erreurs en douceur.
Maintenant, commençons par examiner la structure/syntaxe du bloc try-catch que nous allons déployer dans notre code.
Structure du bloc try-catch
La structure du bloc try-catch est assez simple et c'est l'outil de base pour gérer efficacement les erreurs.
La structure du bloc try-catch est :
essayer {} attraper ( erreur ) {
console. erreur ( ) ;
} enfin {
}
Le fonctionnement du code ci-dessus est le suivant :
- Le ' essayer Le bloc ' contient tout le code de fonctionnement et des erreurs peuvent survenir dans ce bloc. Si une erreur survient dans ce bloc, elle déclenche le ' attraper ' bloc.
- Le ' attraper ' Le bloc est l'endroit où toutes les erreurs nécessaires sont traitées. Les utilisateurs peuvent modifier ses propriétés et effectuer les actions souhaitées.
- Le ' enfin ' Le bloc est un bloc facultatif et il s'exécute à chaque fois, qu'une erreur se produise ou non. Il effectue l'opération de nettoyage.
La compréhension du bloc try-catch pourrait être pratiquement comprise dans un cas dans lequel nous essayons d'accéder à un fichier qui peut exister ou non. S'il n'existe pas, il peut générer une erreur. Afin d'éviter cette erreur, l'utilisateur peut la gérer en utilisant le concept try-catch.
Erreurs de gestion de fichiers à l'aide du bloc « try-catch » dans Node.js
Tout d’abord, examinons un problème sans utiliser de « essayer-attraper ' bloc. Dans l'exemple de code ci-dessous, un fichier est ouvert sans gestion appropriée des erreurs :
const fs = exiger ( 'fs' ) ;const Info = fs. readFileSync ( '/Utilisateurs/Lenovo/file.txt' ) ;
console. enregistrer ( 'Un morceau de code important qui devrait être exécuté à la fin' ) ;
L'explication par le code ci-dessus est la suivante :
- ' const fs = exiger('fs') ' importe le module Node.js 'fs' (système de fichiers) qui permet à l'utilisateur de travailler avec le système de fichiers, y compris toutes les opérations sur les fichiers comme la lecture ou l'écriture de fichiers.
- ' const data = fs.readFileSync('/Users/Lenovo/file.txt') » lit le contenu du fichier au chemin spécifié. Le ' readFileSync ' est une opération synchrone, ce qui signifie qu'elle arrête l'exécution ultérieure du code jusqu'à ce que le fichier soit lu au chemin spécifié et que les informations soient stockées dans le ' Info » variables.
- ' console.log('Un morceau de code important qui doit être exécuté à la fin') ' imprime un message dans le terminal mais cette ligne n'est exécutée que lorsque le fichier n'est pas lu à l'étape précédente.
Sortir
L'erreur résultant du code ci-dessus apparaîtra comme :
On peut voir que l’exécution de ce code sans aucune gestion appropriée des erreurs entraîne des erreurs. Refactorisez maintenant le code ci-dessus en utilisant le bloc « try-catch » :
const fs = exiger ( 'fs' ) ;essayer {
const Info = fs. readFileSync ( '/Utilisateurs/Lenovo/file.txt' ) ;
console. enregistrer ( Info ) ;
} attraper ( erreur ) {
console. erreur ( ` Erreur lire le fichier : $ { erreur. message } ` ) ;
}
Le fonctionnement du code ci-dessus est le suivant :
- Le processus de lecture des fichiers est placé dans la zone « essayer 'Bloquer car il est possible que l'erreur se produise ici.
- ' console.log(infos) ' enregistre le contenu du fichier et l'imprime dans la console.
- Le ' attraper Le bloc ' détecte toute erreur possible qui pourrait survenir dans le ' essayer ' bloque pendant l'exécution du code et enregistre le message d'erreur sur le terminal.
- ' console.error(`Erreur de lecture du fichier : ${error.message}`) » enregistre le message d'erreur spécifié obtenu à la suite de l'erreur détectée.
Sortir
La sortie du code efficacement refactorisé affichera un message d'erreur optimal, comme indiqué ci-dessous dans la capture d'écran ci-jointe :
L'utilisation du try-catch nous permet de gérer l'erreur possible qui pourrait survenir, mais pour une meilleure compréhension, certaines pratiques efficaces sont répertoriées et peuvent être utiles.
Meilleures pratiques pour la gestion des erreurs
L'utilisateur peut suivre les pratiques suivantes pour gérer les erreurs dans ses codes d'application :
Utiliser try-catch à bon escient
Il faut utiliser « essayer-attraper » uniquement là où il doit être utilisé, en particulier dans les parties importantes du code où il existe un risque d'erreur potentielle. En utiliser trop dans le code peut rendre le code complexe.
Utiliser du code asynchrone
Lorsque le code doit être traité avec du code asynchrone, essayez d'utiliser ' essayer-attraper ' avec des promesses et async/wait pour gérer l'erreur de manière optimale.
Consigner et signaler les erreurs
Enregistrez et signalez toujours correctement l'erreur spécifique dans le bloc catch, car des messages d'erreur clairs aident à identifier la cause première des erreurs.
Réduire la complexité
Gérez les situations où les erreurs ne sont pas critiques. La suppression de cette partie spécifique (si cela n'est pas nécessaire) peut réduire la complexité du code.
Éviter les erreurs silencieuses
Écrivez le code de manière à afficher le message d'erreur si nécessaire, sinon si le message d'erreur n'est pas indiqué, il deviendra alors difficile de gérer l'erreur sans identification appropriée.
Tout dépend du fonctionnement du bloc try-catch et de la façon dont il peut être utilisé efficacement pour gérer les erreurs dans Node.js.
Conclusion
Devenir compétent dans la gestion des erreurs dans Node.js est l'étape de base pour développer des applications solides et cohérentes. L’utilisation optimale du « essayer-attraper ' Le bloc ainsi que diverses pratiques telles que les techniques asynchrones et la journalisation appropriée des erreurs peuvent aider à établir des applications Node.js stables et conviviales. Cet article a expliqué la structure, l'application pratique et les pratiques de manipulation qui peuvent être utilisées selon les besoins des utilisateurs.