Penanganan Kesalahan di TypeScript

Artikel ini menjelaskan tentang penanganan kesalahan di TypeScript.

YouTube Video

Penanganan Kesalahan di TypeScript

Penanganan kesalahan di TypeScript pada dasarnya dilakukan menggunakan konstruksi try...catch, seperti pada JavaScript. Di TypeScript, dimungkinkan untuk mengelola konten kesalahan dengan lebih jelas melalui penafsiran tipe. Hal ini memungkinkan penanganan kesalahan yang lebih tepat dan mudah dibaca.

Sintaks try...catch

Sintaks dasar untuk penanganan kesalahan adalah sebagai 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}

Penanganan Kesalahan dengan Tipe Aman

Di TypeScript, kesalahan yang tertangkap dalam blok catch dianggap sebagai tipe any, tetapi disarankan untuk menentukan tipe yang sesuai untuk penanganan kesalahan yang lebih aman. Sebagai contoh, Anda dapat mendefinisikan dan menggunakan tipe kesalahan khusus 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, sebuah kelas bernama CustomError dibuat, dan sebuah error dilemparkan dengan properti khusus seperti errorCode. Di blok catch, gunakan instanceof untuk menentukan tipe kesalahan dan melakukan penanganan yang sesuai.

Penanganan Kesalahan Asinkron

Di TypeScript, try...catch juga digunakan untuk menangani error saat 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 melempar kesalahan jika kode status tidak OK. Kesalahan ditangkap di catch, dan log yang sesuai dikeluarkan.

Ringkasan

Di TypeScript, menggunakan tipe untuk memperjelas konten kesalahan membuat penanganan kesalahan menjadi lebih aman dan mudah dibaca. Saat menangani kesalahan, penting untuk memperjelas jenis-jenis kesalahan yang mungkin terjadi dan menangani mereka dengan sesuai.

Kesalahan

Kelas Error di TypeScript memperluas kelas Error dalam JavaScript dan merupakan objek dasar untuk merepresentasikan kesalahan. Dengan menggunakan kelas Error, Anda dapat membuat objek yang mencakup pesan kesalahan dan melakukan penanganan kesalahan.

Dasar-dasar Kelas Error

Kelas Error digunakan sebagai berikut.

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

Properti

Kelas Error memiliki properti berikut:.

• pesan Sebuah string yang mewakili pesan error.
• nama Nama dari error. Secara default, nilainya adalah "Error", tetapi dapat diubah dengan membuat kelas kesalahan khusus.
• stack Informasi jejak stack yang digunakan untuk debugging. Sebuah string yang menunjukkan kode mana yang menyebabkan kesalahan terjadi.

Kelas Kesalahan Khusus

Anda juga dapat memperluas kelas Error dan membuat kelas kesalahan Anda sendiri. Ini berguna dalam situasi di mana penanganan kesalahan tertentu diperlukan. Sebagai contoh, ini efektif ketika Anda ingin menangani berbagai jenis kesalahan seperti kesalahan permintaan HTTP atau kesalahan basis data.

Contoh Pembuatan Kesalahan Khusus

 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 membuat kelas CustomError dan menambahkan informasi seperti kode kesalahan, Anda dapat mengelola informasi yang lebih komprehensif tentang kesalahan.

Pewarisan Kelas Error

Dalam TypeScript, ketika membuat kelas kesalahan khusus dengan memperluas kelas Error, ada beberapa hal yang perlu diperhatikan.

1. Memanggil super() Di konstruktor kelas error kustom, Anda harus memanggil super() untuk memanggil konstruktor dari kelas Error. Ini memastikan bahwa properti message dan stack diinisialisasi dengan benar.

2. Menambahkan Properti Jika Anda ingin menambahkan informasi tambahan pada objek error, definisikan properti baru di dalam kelas. Sebagai contoh, dalam CustomError di atas, sebuah properti errorCode ditambahkan.

Melempar dan Menangkap Kesalahan

Anda dapat menangani error dengan melempar error menggunakan kelas Error atau kelas error kustom, lalu menanganinya dengan catch.

 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 kasus kesalahan khusus juga, gunakan instanceof untuk mengidentifikasi kesalahan tertentu dan menangani mereka dengan tepat.

 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 dasar untuk melakukan penanganan kesalahan standar. Selain itu, dengan memperluas kelas Error untuk membuat kesalahan khusus, penanganan kesalahan yang fleksibel berdasarkan jenis kesalahan dan informasi tambahan menjadi mungkin.

Anda dapat mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Silakan periksa juga saluran YouTube kami.

YouTube Video