Bagaimana untuk menyelesaikan terlalu banyak tangkapan percubaan dalam Typescript?

Kami boleh menggunakan pernyataan cuba-tangkap untuk menyelesaikan ralat dalam TypeScript. Kadangkala, kita perlu menambah berbilang blok cuba-tangkap dalam kod untuk mengendalikan berbilang ralat.

Apabila kami menambah berbilang kenyataan cuba-tangkap pada kod, kod menjadi tidak boleh dibaca dan pemfaktoran semula menjadi pening bagi pembangun. Dalam tutorial ini, kita akan belajar untuk menukar blok cuba-tangkap yang berlebihan kepada satu blok cuba-tangkap tunggal yang boleh menguruskan berbilang ralat.

Tatabahasa

Pengguna boleh menggunakan satu blok cuba-tangkap dalam TypeScript mengikut sintaks berikut.

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

Dalam sintaks di atas, kami membuang ralat ke dalam blok cuba dan menangkap ralat dalam blok tangkapan.

Setiap kali kami menghadapi sebarang ralat dalam blok cuba, kawalan pelaksanaan pergi terus ke kenyataan tangkapan tanpa melaksanakan kod blok cuba yang lain.

Contoh 1: Terlalu banyak blok cuba-tangkap

Dalam contoh di bawah, kami telah menambah empat blok cuba-tangkap. Kami membuang ralat dengan mesej berbeza dari setiap blok cuba-tangkap.

Pengguna boleh melihat mesej ralat yang dicetak oleh setiap blok tangkapan dalam output.

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

Apabila disusun, ia akan menjana kod JavaScript berikut.

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

Output

Kod di atas akan menghasilkan output berikut -

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

Daripada contoh di atas, pengguna boleh memahami cara kod menjadi tidak boleh dibaca dan tidak jelas apabila kami menggunakan terlalu banyak pernyataan cuba-tangkap dalam satu kod.

Kini, kita akan belajar menggunakan satu blok cuba-tangkap untuk mengendalikan berbilang blok kod dengan ralat yang berbeza.

Contoh 2

Dalam contoh di bawah, kami telah mencipta fungsi solveProblems(). Ia menerima fungsi sebagai parameter dan memanggil fungsi dalam blok percubaan. Jika fungsi melemparkan sebarang ralat, kita boleh menangkapnya dalam satu blok.

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

Apabila disusun, ia akan menjana kod JavaScript berikut -

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

Output

Kod di atas akan menghasilkan output berikut -

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

Daripada contoh di atas, pengguna boleh memahami cara mengalih keluar berbilang blok cuba-tangkap dengan menggantikan berbilang blok cuba-tangkap dengan satu blok cuba-tangkap. Pengguna hanya perlu mencipta fungsi berasingan untuk setiap blok kod yang berasingan dan boleh memanggil setiap fungsi satu demi satu dalam satu blok percubaan.

Atas ialah kandungan terperinci Bagaimana untuk menyelesaikan terlalu banyak tangkapan percubaan dalam Typescript?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!