Comment résoudre trop de tentatives de captures dans Typescript ?

Nous pouvons utiliser des instructions try-catch pour résoudre les erreurs dans TypeScript. Parfois, nous devons ajouter plusieurs blocs try-catch dans le code pour gérer plusieurs erreurs.

Lorsque nous ajoutons plusieurs instructions try-catch au code, le code devient illisible et le refactoring devient un casse-tête pour les développeurs. Dans ce didacticiel, nous apprendrons à convertir des blocs try-catch excessifs en un seul bloc try-catch capable de gérer plusieurs erreurs.

Grammaire

Les utilisateurs peuvent utiliser un seul bloc try-catch dans TypeScript en suivant la syntaxe suivante.

try {
   throw new Error("error_message");
   // this code will not be executed
}
catch (error) {
   // manage the error
}

Dans la syntaxe ci-dessus, nous lançons l'erreur dans le bloc try et captons l'erreur dans le bloc catch.

Chaque fois que nous rencontrons une erreur dans le bloc try, le contrôle d'exécution passe directement à l'instruction catch sans exécuter d'autre code de bloc try.

Exemple 1 : Trop de blocs try-catch

Dans l'exemple ci-dessous, nous avons ajouté quatre blocs try-catch. Nous lançons des erreurs avec des messages différents de chaque bloc try-catch.

Les utilisateurs peuvent voir le message d'erreur imprimé par chaque bloc catch dans la sortie.

try {
   console.log("Inside the first try block");
   throw new Error("first error message");
} catch (error) {
   console.log(error.message);
}

try {
   console.log("Inside the second try block");
   throw new Error("second error message");
} catch (error) {
   console.log(error.message);
}

try {
   console.log("Inside the third try block");
   throw new Error("Third error message");
} catch (error) {
   console.log(error.message);
}

try {
   console.log("Inside the fourth try block");
   throw new Error("Fourth error message");
} catch (error) {
   console.log(error.message);
}

Une fois compilé, il générera le code JavaScript suivant.

try {
   console.log("Inside the first try block");
   throw new Error("first error message");
}
catch (error) {
   console.log(error.message);
}
try {
   console.log("Inside the second try block");
   throw new Error("second error message");
}
catch (error) {
   console.log(error.message);
}
try {
   console.log("Inside the third try block");
   throw new Error("Third error message");
}
catch (error) {
   console.log(error.message);
}
try {
   console.log("Inside the fourth try block");
   throw new Error("Fourth error message");
}
catch (error) {
   console.log(error.message);
}

Sortie

Le code ci-dessus produira la sortie suivante -

Inside the first try block
first error message
Inside the second try block
second error message
Inside the third try block
Third error message
Inside the fourth try block
Fourth error message

À partir de l'exemple ci-dessus, les utilisateurs peuvent comprendre comment le code devient illisible et peu clair lorsque nous utilisons trop d'instructions try-catch dans un seul code.

Maintenant, nous allons apprendre à utiliser un seul bloc try-catch pour gérer plusieurs blocs de code avec différentes erreurs.

Exemple 2

Dans l'exemple ci-dessous, nous avons créé la fonction solveProblems(). Il accepte une fonction en paramètre et appelle la fonction dans un bloc try. Si la fonction génère une erreur, nous pouvons la détecter en un seul bloc.

function func2() {
   throw new Error("This error is from second function!");
}

function func3() {
   let num = 10;
   num.toPrecision(1000);
}
function solveProblems(func: any) {
   // calling the callback function in the try block
   try {
      func();
   } catch (error) {
      console.log(error.message);
   }
}

// calling functions
solveProblems(func2);
solveProblems(func3);

Une fois compilé, il générera le code JavaScript suivant -

function func2() {
   throw new Error("This error is from second function!");
}
function func3() {
   var num = 10;
   num.toPrecision(1000);
}
function solveProblems(func) {
   // calling the callback function in the try block
   try {
      func();
   }
   catch (error) {
      console.log(error.message);
   }
}
// calling functions
solveProblems(func2);
solveProblems(func3);

Sortie

Le code ci-dessus produira la sortie suivante -

This error is from second function!
toPrecision() argument must be between 1 and 100

À partir de l'exemple ci-dessus, les utilisateurs peuvent comprendre comment supprimer plusieurs blocs try-catch en remplaçant plusieurs blocs try-catch par un seul bloc try-catch. Les utilisateurs doivent uniquement créer une fonction distincte pour chaque bloc de code distinct et peuvent appeler chaque fonction une par une dans un seul bloc try.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!