JavaScript - try...catch : Maîtriser la Gestion des Erreurs pour les Débutants

Bonjour, aspirants programmeurs ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde de la gestion des erreurs en JavaScript. Ne vous inquiétez pas si vous êtes nouveau dans la programmation - je vous guiderai à travers chaque étape avec pleins d'exemples et d'explications. À la fin de ce tutoriel, vous attraperez les erreurs comme un pro !

Déclaration JavaScript try...catch

Imaginez que vous apprenez à rouler à vélo. Vous pourriez tomber quelques fois, mais c'est normal - vous vous levez et essayez à nouveau. En programmation, nous utilisons la déclaration try...catch pour faire quelque chose de similaire. Nous "essayons" d'exécuter du code, et s'il "tombe" (lance une erreur), nous la "attrapons" et la gérons avec grâce.

Regardons un exemple simple :

try {
// Code qui pourrait causer une erreur
console.log(nonExistentVariable);
} catch (error) {
// Code pour gérer l'erreur
console.log("Oops ! Une erreur s'est produite :", error.message);
}

Dans cet exemple, nous essayons de logger une variable qui n'existe pas. Au lieu de faire planter notre programme, le bloc catch attrape l'erreur et logue un message amical.

Déclaration JavaScript try...catch...finally

Parfois, nous voulons exécuter du code indépendamment de l'occurrence ou non d'une erreur. C'est là que le bloc finally devient utile. C'est comme dire, "Quoi qu'il arrive, assurez-vous de faire cela !"

try {
console.log("Essayons de diviser par zéro !");
let result = 10 / 0;
console.log("Résultat :", result);
} catch (error) {
console.log("Oh non ! Une erreur s'est produite :", error.message);
} finally {
console.log("Cela s'exécutera toujours, qu'il y ait une erreur ou non !");
}

Dans cet exemple, bien que la division par zéro cause une erreur, le bloc finally s'exécute toujours.

Déclaration JavaScript Throw

Parfois, nous voulons créer nos propres erreurs. Nous pouvons le faire en utilisant la déclaration throw. C'est comme être l'arbitre d'un jeu et siffler une faute lorsque vous en voyez une.

function checkAge(age) {
if (age < 0) {
throw new Error("L'âge ne peut pas être négatif !");
}
console.log("L'âge est valide :", age);
}

try {
checkAge(-5);
} catch (error) {
console.log("Erreur attrapée :", error.message);
}

Ici, nous lançons notre propre erreur lorsque quelqu'un essaie d'utiliser un âge négatif.

Niveau de Try Blocks

Comme les poupées russes, nous pouvons imbriquer des blocs try...catch les uns dans les autres. Cela est utile lorsque nous voulons gérer des erreurs à différents niveaux de notre code.

try {
try {
throw new Error("Oops !");
} catch (innerError) {
console.log("Bloc catch interne :", innerError.message);
throw innerError; // Relancer l'erreur
}
} catch (outerError) {
console.log("Bloc catch externe :", outerError.message);
}

Dans cet exemple, nous attrapons l'erreur dans le bloc interne, la loguons, puis la relançons pour qu'elle soit attrapée par le bloc externe.

Relancer l'Erreur

Parfois, nous voulons attraper une erreur, faire quelque chose avec elle, puis la transmettre pour qu'elle soit traitée ailleurs. Cela s'appelle relancer une erreur.

function doSomethingRisky() {
throw new Error("Danger, Will Robinson !");
}

try {
doSomethingRisky();
} catch (error) {
console.log("Loguer l'erreur :", error.message);
throw error; // Relancer l'erreur
}

Ici, nous attrapons l'erreur, la loguons, puis la relançons pour qu'une autre partie de notre code la traite.

Blocs catch Conditionnels

Dans certains cas, nous pourrions vouloir gérer différents types d'erreurs de manière différente. Nous pouvons le faire en vérifiant le type d'erreur dans notre bloc catch.

try {
let randomNumber = Math.random();
if (randomNumber < 0.5) {
throw new TypeError("Erreur de type !");
} else {
throw new RangeError("Erreur de plage !");
}
} catch (error) {
if (error instanceof TypeError) {
console.log("Gérer TypeError :", error.message);
} else if (error instanceof RangeError) {
console.log("Gérer RangeError :", error.message);
} else {
console.log("Erreur inconnue :", error.message);
}
}

Cet exemple montre comment nous pouvons gérer différents types d'erreurs de différentes manières.

JavaScript try...catch avec la Méthode setTimeout()

Lorsque nous travaillons avec du code asynchrone, la gestion des erreurs peut être complexe. Regardons comment gérer les erreurs dans une fonction setTimeout().

try {
setTimeout(() => {
throw new Error("Erreur asynchrone !");
}, 1000);
} catch (error) {
console.log("Cela ne catchera pas l'erreur !");
}

// Façon correcte :
setTimeout(() => {
try {
throw new Error("Erreur asynchrone !");
} catch (error) {
console.log("Erreur asynchrone attrapée :", error.message);
}
}, 1000);

La première tentative ne fonctionnera pas car l'erreur est lancée après que le bloc try...catch a terminé son exécution. La seconde tentative attrape correctement l'erreur.

Erreurs Basées sur des Promesses

Lorsque nous travaillons avec des Promesses, nous utilisons .catch() pour gérer les erreurs. C'est comme un bloc catch, mais pour les opérations asynchrones.

function fetchData() {
return new Promise((resolve, reject) => {
setTimeout(() => {
reject(new Error("Échec de la récupération des données"));
}, 1000);
});
}

fetchData()
.then(data => console.log("Données :", data))
.catch(error => console.log("Erreur :", error.message));

Dans cet exemple, nous simulons un échec de la récupération des données et attrapons l'erreur résultante.

Types d'Erreurs en JavaScript

JavaScript a plusieurs types d'erreurs intégrés. Voici un tableau résumant ceux-ci :

Type d'Erreur	Description
Error	Le type d'erreur générique
SyntaxError	Se produit lorsqu'il y a une erreur de syntaxe dans le code
ReferenceError	Se produit lorsqu'on fait référence à une variable inexistante
TypeError	Se produit lorsque une valeur n'est pas du type attendu
RangeError	Se produit lorsque une valeur n'est pas dans la plage attendue
URIError	Se produit lors de l'utilisation incorrecte des fonctions de manipulation URI globales
EvalError	Se produit lors de l'utilisation incorrecte de la fonction eval()

Comprendre ces types d'erreurs peut vous aider à écrire un code de gestion des erreurs plus précis.

Et voilà ! Vous venez de terminer un cours accéléré sur la gestion des erreurs en JavaScript. Souvenez-vous, les erreurs ne sont pas vos ennemis - elles sont un retour d'information précieux qui vous aide à écrire un code meilleur et plus robuste. Continuez à pratiquer, restez curieux, et bon codage !

Credits: Image by storyset