Eksepsi #

Di TypeScript, penanganan kesalahan atau exception handling merupakan bagian penting untuk memastikan aplikasi berjalan dengan baik dan dapat menangani situasi tak terduga. TypeScript menyediakan beberapa mekanisme untuk menangani exception yang mirip dengan JavaScript, tetapi dengan keuntungan tambahan dari tipe statis. Berikut adalah berbagai macam implementasi exception pada TypeScript:

try...catch Statement #

Ini adalah cara paling umum untuk menangani exception. Blok try digunakan untuk menulis kode yang mungkin menyebabkan kesalahan, sementara blok catch digunakan untuk menangani kesalahan tersebut.

try {
    let result = riskyOperation();
    console.log(result);
} catch (error) {
    console.error("Terjadi kesalahan:", error);
}

• Penggunaan: Blok try...catch digunakan ketika Anda ingin menangkap dan menangani kesalahan secara langsung dalam alur program.

finally Clause #

Blok finally digunakan untuk menjalankan kode yang akan dieksekusi setelah blok try dan catch, terlepas dari apakah ada kesalahan atau tidak. Ini berguna untuk membersihkan resource atau menjalankan aksi tertentu yang harus terjadi tanpa mempedulikan hasil dari try...catch.

try {
    let data = fetchData();
    console.log(data);
} catch (error) {
    console.error("Error fetching data:", error);
} finally {
    console.log("Cleaning up...");
}

• Penggunaan: Blok finally digunakan ketika ada aksi yang harus dilakukan setelah try...catch, seperti menutup koneksi atau membersihkan resource.

Custom Error Classes #

Anda dapat membuat kelas kesalahan khusus (custom error classes) untuk mewakili jenis kesalahan tertentu dalam aplikasi Anda. Ini berguna untuk mengklasifikasikan kesalahan dan memberikan informasi yang lebih spesifik.

class ValidationError extends Error {
    constructor(message: string) {
        super(message);
        this.name = "ValidationError";
    }
}

function validateInput(input: string) {
    if (input.length < 5) {
        throw new ValidationError("Input terlalu pendek!");
    }
    return true;
}

try {
    validateInput("abc");
} catch (error) {
    if (error instanceof ValidationError) {
        console.error("Validation Error:", error.message);
    } else {
        console.error("Unknown Error:", error);
    }
}

• Penggunaan: Custom error classes digunakan untuk membuat kesalahan yang lebih terstruktur dan deskriptif, yang dapat membantu dalam debugging dan logging.

Throwing Errors #

Anda dapat secara eksplisit melemparkan kesalahan dengan menggunakan kata kunci throw. Kesalahan ini dapat berupa instance dari Error atau kelas kesalahan khusus yang telah Anda buat.

function divide(a: number, b: number): number {
    if (b === 0) {
        throw new Error("Pembagian dengan nol tidak diperbolehkan.");
    }
    return a / b;
}

try {
    let result = divide(10, 0);
} catch (error) {
    console.error("Error:", error.message);
}

• Penggunaan: Gunakan throw untuk menghentikan eksekusi program saat terjadi kondisi yang tidak valid dan berikan informasi tentang kesalahan tersebut.

Re-throwing Errors #

Dalam beberapa kasus, Anda mungkin ingin menangkap kesalahan, menangani bagian tertentu dari kesalahan tersebut, lalu melemparkannya kembali untuk ditangani di tempat lain.

function processData(data: any) {
    try {
        // Proses data
        throw new Error("Error dalam memproses data");
    } catch (error) {
        console.error("Logging error:", error.message);
        throw error; // Melempar kembali error untuk penanganan lebih lanjut
    }
}

try {
    processData(null);
} catch (error) {
    console.error("Penanganan error di tingkat yang lebih tinggi:", error.message);
}

• Penggunaan: Re-throwing digunakan saat Anda perlu menangani sebagian kesalahan tetapi tetap ingin menginformasikan kesalahan tersebut ke lapisan yang lebih tinggi dalam aplikasi.

Union Types with Error Handling #

Terkadang, Anda mungkin ingin menandai sebuah nilai sebagai bisa menjadi tipe yang valid atau sebuah kesalahan. Ini dapat dilakukan menggunakan union types bersama dengan penanganan manual.

type Result<T> = T | Error;

function parseJson(jsonString: string): Result<object> {
    try {
        return JSON.parse(jsonString);
    } catch (error) {
        return new Error("JSON tidak valid");
    }
}

let result = parseJson('{"name": "John"}');
if (result instanceof Error) {
    console.error("Failed to parse JSON:", result.message);
} else {
    console.log("Parsed JSON:", result);
}

• Penggunaan: Union types dengan penanganan kesalahan manual digunakan ketika Anda ingin nilai yang dikembalikan bisa menjadi data yang valid atau kesalahan yang perlu ditangani.

Assertion Functions #

TypeScript memungkinkan Anda untuk membuat fungsi assertion yang melempar kesalahan jika suatu kondisi tidak terpenuhi. Ini sangat berguna dalam memastikan bahwa data atau kondisi tertentu selalu valid sebelum melanjutkan eksekusi.

function assertIsString(value: any): asserts value is string {
    if (typeof value !== 'string') {
        throw new Error('Value is not a string');
    }
}

function processString(input: any) {
    assertIsString(input);
    // Setelah assert, TypeScript tahu bahwa 'input' pasti string
    console.log(input.toUpperCase());
}

try {
    processString(123);
} catch (error) {
    console.error("Assertion failed:", error.message);
}

• Penggunaan: Assertion functions digunakan untuk memastikan tipe atau kondisi tertentu sebelum melanjutkan eksekusi program.

Kesimpulan #

Dengan memahami berbagai macam implementasi exception handling ini, Anda dapat menulis kode TypeScript yang lebih tangguh, menangani kesalahan dengan lebih baik, dan menyediakan pengalaman pengguna yang lebih baik dalam aplikasi Anda.