Wie kann man zu viele Try-Fänge in Typescript lösen?

Wir können Try-Catch-Anweisungen verwenden, um Fehler in TypeScript zu beheben. Manchmal müssen wir dem Code mehrere Try-Catch-Blöcke hinzufügen, um mehrere Fehler zu behandeln.

Wenn wir dem Code mehrere Try-Catch-Anweisungen hinzufügen, wird der Code unlesbar und die Umgestaltung bereitet den Entwicklern Kopfzerbrechen. In diesem Tutorial lernen wir, übermäßige Try-Catch-Blöcke in einen einzigen Try-Catch-Block umzuwandeln, der mehrere Fehler verwalten kann.

Grammatik

Benutzer können einen einzelnen Try-Catch-Block in TypeScript verwenden, indem sie der folgenden Syntax folgen.

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

In der obigen Syntax werfen wir den Fehler in den Try-Block und fangen den Fehler im Catch-Block ab.

Immer wenn im Try-Block ein Fehler auftritt, geht die Ausführungssteuerung direkt zur Catch-Anweisung über, ohne dass anderer Try-Block-Code ausgeführt wird.

Beispiel 1: Zu viele Try-Catch-Blöcke

Im folgenden Beispiel haben wir vier Try-Catch-Blöcke hinzugefügt. Wir werfen Fehler mit unterschiedlichen Nachrichten aus jedem Try-Catch-Block aus.

Benutzer können die von jedem Catch-Block ausgegebene Fehlermeldung in der Ausgabe sehen.

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);
}

Beim Kompilieren wird der folgende JavaScript-Code generiert.

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);
}

Ausgabe

Der obige Code erzeugt die folgende Ausgabe -

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

Anhand des obigen Beispiels können Benutzer verstehen, wie der Code unlesbar und unklar wird, wenn wir zu viele Try-Catch-Anweisungen in einem einzigen Code verwenden.

Jetzt lernen wir, einen einzelnen Try-Catch-Block zu verwenden, um mehrere Codeblöcke mit unterschiedlichen Fehlern zu verarbeiten.

Beispiel 2

Im folgenden Beispiel haben wir die FunktionsolveProblems() erstellt. Es akzeptiert eine Funktion als Parameter und ruft die Funktion in einem Try-Block auf. Wenn die Funktion einen Fehler auslöst, können wir ihn in einem einzigen Block abfangen.

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);

Beim Kompilieren wird der folgende JavaScript-Code generiert:

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);

Ausgabe

Der obige Code erzeugt die folgende Ausgabe -

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

Anhand des obigen Beispiels können Benutzer verstehen, wie sie mehrere Try-Catch-Blöcke entfernen, indem sie mehrere Try-Catch-Blöcke durch einen einzelnen Try-Catch-Block ersetzen. Benutzer müssen lediglich für jeden einzelnen Codeblock eine separate Funktion erstellen und können jede Funktion einzeln in einem einzigen Try-Block aufrufen.

Das obige ist der detaillierte Inhalt vonWie kann man zu viele Try-Fänge in Typescript lösen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!