Panduan Pemula Penanganan Kesalahan TypeScript

Penanganan kesalahan yang efektif sangat penting dalam bahasa pemrograman apa pun, dan TypeScript tidak terkecuali. Penanganan kesalahan yang tepat membantu dalam menciptakan aplikasi yang tangguh dan andal dengan mengelola kondisi yang tidak terduga dengan baik. Panduan ini akan membahas dasar-dasar penanganan kesalahan dalam TypeScript dan memberikan contoh praktis untuk pemula.

Memahami Kesalahan dalam TypeScript

Kesalahan dalam TypeScript, seperti dalam JavaScript, terjadi selama runtime atau waktu kompilasi. TypeScript menyediakan keamanan tipe yang dapat menangkap banyak masalah potensial pada waktu kompilasi, tetapi kesalahan runtime masih perlu dikelola dengan benar.

Penanganan Kesalahan Dasar dengan try dan catch

Dalam TypeScript, Anda menangani kesalahan saat proses berjalan menggunakan blok try dan catch. Pendekatan ini memungkinkan Anda untuk mengeksekusi kode yang mungkin memunculkan kesalahan dan menangani kesalahan tersebut jika terjadi.

Contoh try dan catch

function divide(a: number, b: number): number {
  try {
    if (b === 0) {
      throw new Error("Cannot divide by zero");
    }
    return a / b;
  } catch (error) {
    console.error(error.message);
    return NaN; // Return NaN to indicate an error
  }
}

console.log(divide(10, 2)); // Output: 5
console.log(divide(10, 0)); // Output: Cannot divide by zero

Dalam contoh ini, fungsi divide mencoba membagi dua angka. Jika pembaginya nol, kesalahan akan muncul dan ditangkap oleh blok catch, yang mencatat pesan kesalahan.

Jenis Kesalahan Kustom

TypeScript memungkinkan Anda menentukan jenis kesalahan khusus untuk merepresentasikan kondisi kesalahan tertentu dengan lebih baik. Jenis kesalahan khusus membantu dalam mengkategorikan kesalahan dan menanganinya dengan lebih efektif.

Membuat Jenis Kesalahan Kustom

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

function divide(a: number, b: number): number {
  try {
    if (b === 0) {
      throw new DivisionError("Cannot divide by zero");
    }
    return a / b;
  } catch (error) {
    if (error instanceof DivisionError) {
      console.error(`Custom Error: ${error.message}`);
    } else {
      console.error("An unexpected error occurred");
    }
    return NaN; // Return NaN to indicate an error
  }
}

console.log(divide(10, 2)); // Output: 5
console.log(divide(10, 0)); // Output: Custom Error: Cannot divide by zero

Di sini, kami mendefinisikan kelas kesalahan khusus DivisionError yang memperluas kelas bawaan Error. Kami menggunakan kesalahan khusus ini dalam fungsi divide untuk menyediakan penanganan kesalahan yang lebih spesifik.

Ketik Penjagaan dengan instanceof

Pelindung tipe seperti instanceof membantu mempersempit tipe objek kesalahan dalam blok catch, sehingga memungkinkan Anda menangani berbagai tipe kesalahan secara berbeda.

Contoh Tipe Penjagaan

function processInput(input: string | number) {
  try {
    if (typeof input === "string") {
      console.log(input.toUpperCase());
    } else {
      throw new Error("Input must be a string");
    }
  } catch (error) {
    if (error instanceof Error) {
      console.error(`Error: ${error.message}`);
    } else {
      console.error("An unknown error occurred");
    }
  }
}

processInput("hello"); // Output: HELLO
processInput(42); // Output: Error: Input must be a string

Contoh ini menunjukkan penjagaan tipe dalam blok catch untuk memastikan objek kesalahan merupakan contoh dari Error, yang memungkinkan penanganan kesalahan secara akurat.

Menggunakan finally untuk Pembersihan

Blok finally dapat digunakan untuk mengeksekusi kode yang harus dijalankan terlepas dari apakah terjadi kesalahan atau tidak. Ini berguna untuk operasi pembersihan seperti menutup file atau melepaskan sumber daya.

Contoh dengan finally

function readFile(filePath: string): string {
  try {
    // Simulate reading a file
    if (filePath === "") {
      throw new Error("File path cannot be empty");
    }
    return "File content";
  } catch (error) {
    console.error(`Error: ${error.message}`);
    return "";
  } finally {
    console.log("Cleanup: Closing file");
  }
}

console.log(readFile("path/to/file")); // Output: File content
console.log(readFile("")); // Output: Error: File path cannot be empty
                            //         Cleanup: Closing file

Dalam contoh ini, blok finally memastikan bahwa pesan pembersihan dicatat terlepas dari terjadinya kesalahan.

Kesimpulan

Penanganan kesalahan yang efektif sangat penting untuk membangun aplikasi TypeScript yang andal. Dengan menggunakan try dan catch, tipe kesalahan khusus, penjagaan tipe, dan finally, Anda dapat mengelola kesalahan dengan lebih efektif dan memastikan bahwa aplikasi Anda berperilaku sesuai prediksi bahkan dalam menghadapi kondisi yang tidak terduga.

Dengan teknik ini, Anda dapat menangani kesalahan dengan baik dan meningkatkan ketahanan kode TypeScript Anda. Praktikkan konsep ini untuk menjadi ahli dalam penanganan kesalahan TypeScript dan menulis aplikasi yang lebih tangguh.