Pengendalian Ralat dalam TypeScript

Artikel ini menerangkan pengendalian ralat dalam TypeScript.

YouTube Video

Pengendalian Ralat dalam TypeScript

Pengendalian ralat dalam TypeScript secara asasnya dilakukan menggunakan struktur try...catch, seperti dalam JavaScript. Dalam TypeScript, adalah mungkin untuk mengurus kandungan ralat dengan lebih jelas melalui inferensi jenis. Ini membolehkan pengendalian ralat yang lebih tepat dan boleh dibaca.

Sintaksis try...catch

Sintaks asas untuk pengendalian ralat adalah seperti berikut:.

 1try {
 2    // Code that may throw an error
 3    throw new Error("Something went wrong!");
 4} catch (error) {
 5    // Catch and handle the error
 6    console.error("Error:", error);
 7} finally {
 8    // Code that runs regardless of whether an error occurred
 9    console.log("Finally block executed.");
10}

Pengendalian Ralat Berasaskan Jenis yang Selamat

Dalam TypeScript, ralat yang ditangkap dalam blok catch dianggap sebagai jenis any, tetapi adalah disyorkan untuk menentukan jenis yang sesuai untuk pengendalian ralat yang lebih selamat. Sebagai contoh, anda boleh menakrifkan dan menggunakan jenis ralat tersuai seperti berikut:.

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message);
 4        this.name = "CustomError";
 5    }
 6}
 7
 8try {
 9    throw new CustomError("Invalid operation", 400);
10} catch (error) {
11    if (error instanceof CustomError) {
12        console.error(`Error: ${error.message}, Code: ${error.errorCode}`);
13    } else {
14        console.error("Unknown error occurred");
15    }
16}

Dalam contoh ini, satu kelas bernama CustomError dicipta, dan satu ralat dibuang dengan sifat tersuai seperti errorCode. Dalam blok catch, gunakan instanceof untuk menentukan jenis ralat dan menjalankan pengendalian yang sesuai.

Pengendalian Ralat Asynchronous

try...catch juga digunakan dalam TypeScript untuk menangani ralat semasa menggunakan fungsi asinkron.

 1async function fetchData() {
 2    try {
 3        const response = await fetch("https://api.example.com/data");
 4        if (!response.ok) {
 5            throw new Error(`HTTP error! status: ${response.status}`);
 6        }
 7        const data = await response.json();
 8        console.log(data);
 9    } catch (error) {
10        console.error("Failed to fetch data:", error);
11    }
12}
13
14fetchData();

Dalam contoh ini, data diambil menggunakan fetch, dan response.ok diperiksa untuk melemparkan ralat jika kod status tidak OK. Ralat ditangkap dalam catch, dan log yang sesuai dipaparkan.

Ringkasan

Dalam TypeScript, menggunakan jenis untuk menjelaskan kandungan ralat menjadikan pengendalian ralat lebih selamat dan lebih mudah dibaca. Semasa mengendalikan ralat, adalah penting untuk menjelaskan jenis ralat yang mungkin berlaku dan mengendalikannya dengan sewajarnya.

Ralat

Kelas Error dalam TypeScript melanjutkan kelas Error dalam JavaScript dan merupakan objek asas untuk mewakili ralat. Dengan menggunakan kelas Error, anda boleh membuat objek yang merangkumi mesej ralat dan menjalankan pengendalian ralat.

Asas Kelas Error

Kelas Error digunakan seperti berikut.

1const error = new Error("Something went wrong!");
2console.log(error.message); // "Something went wrong!"
3console.log(error.name);    // "Error"

Sifat

Kelas Error mempunyai sifat-sifat berikut:.

• mesej String yang mewakili mesej ralat.
• nama Nama ralat itu. Secara lalai, ia adalah "Error", tetapi boleh diubah dengan mencipta kelas ralat tersuai.
• jejak Maklumat jejak tumpukan yang digunakan untuk penyahpepijatan. Rentetan yang menunjukkan kod yang menyebabkan ralat berlaku.

Kelas Ralat Tersuai

Ia juga mungkin untuk melanjutkan kelas Error dan mencipta kelas ralat anda sendiri. Ini berguna dalam situasi di mana pengendalian ralat tertentu diperlukan. Sebagai contoh, ia berkesan apabila anda ingin menangani jenis ralat yang berbeza seperti ralat permintaan HTTP atau ralat pangkalan data.

Contoh Mencipta Ralat Tersuai

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message); // Call the constructor of the parent class 'Error'
 4        this.name = "CustomError"; // Set the name of the error
 5    }
 6}
 7
 8const customError = new CustomError("Invalid operation", 400);
 9console.log(customError.message);   // "Invalid operation"
10console.log(customError.name);      // "CustomError"
11console.log(customError.errorCode); // 400

• Dengan mencipta kelas CustomError dan menambah maklumat seperti kod ralat, anda boleh menguruskan maklumat mengenai ralat dengan lebih komprehensif.

Pewarisan Kelas Error

Dalam TypeScript, apabila mencipta kelas ralat tersuai dengan melanjutkan kelas Error, terdapat beberapa perkara yang perlu diberi perhatian.

1. Memanggil super() Dalam pembina kelas ralat tersuai, anda mesti memanggil super() untuk memanggil pembina kelas Error. Ini memastikan bahawa sifat mesej dan stak telah diinisialisasi dengan betul.

2. Menambah Sifat Jika anda ingin menambah maklumat tambahan kepada objek ralat, takrifkan sifat baharu di dalam kelas. Sebagai contoh, dalam CustomError di atas, sifat errorCode ditambah.

Melempar dan Menangkap Ralat

Anda boleh mengendalikan ralat dengan membuang ralat menggunakan kelas Error atau kelas ralat tersuai dan kemudian menangkapnya.

 1function riskyOperation() {
 2    throw new Error("Something went wrong during the operation");
 3}
 4
 5try {
 6    riskyOperation();
 7} catch (error) {
 8    if (error instanceof Error) {
 9        console.error(error.message);  // "Something went wrong during the operation"
10        console.error(error.name);     // "Error"
11    }
12}

Dalam kes ralat tersuai juga, gunakan instanceof untuk mengenal pasti ralat tertentu dan menanganinya dengan sewajarnya.

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message);
 4        this.name = "CustomError";
 5    }
 6}
 7
 8try {
 9    throw new CustomError("Database connection failed", 500);
10} catch (error) {
11    if (error instanceof CustomError) {
12        console.error(`Error: ${error.message}, Code: ${error.errorCode}`);
13    }
14}

Ringkasan

Kelas Error dalam TypeScript adalah kelas asas untuk melaksanakan pengendalian ralat standard. Tambahan pula, dengan melanjutkan kelas Error untuk mencipta ralat tersuai, pengendalian ralat yang fleksibel berdasarkan jenis ralat dan maklumat tambahan menjadi mungkin.

Anda boleh mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Sila lihat juga saluran YouTube kami.

YouTube Video