Error Handling dan Exception di TypeScript: try…catch dan Custom Error

Dalam pemrograman, kesalahan atau error tidak bisa dihindari. Bisa jadi karena input pengguna yang salah, koneksi server gagal, atau data yang tidak valid. Oleh karena itu, error handling menjadi bagian penting dalam pengembangan aplikasi modern, termasuk saat menggunakan TypeScript. Dengan pendekatan yang tepat, aplikasi bisa tetap berjalan dengan baik meskipun terjadi kesalahan.

Error handling dalam TypeScript membantu developer mendeteksi, menangani, dan memberikan respon yang tepat terhadap error tanpa menghentikan seluruh eksekusi program. Konsep ini mencakup penggunaan blok try...catch, perintah throw untuk melempar error secara manual, serta custom error class untuk membuat jenis kesalahan yang lebih spesifik dan mudah diidentifikasi.

Apa Itu Error Handling dalam TypeScript?

Error handling adalah mekanisme untuk mendeteksi dan menangani kesalahan saat aplikasi berjalan (runtime errors). Alih-alih membiarkan aplikasi berhenti secara tiba-tiba, developer dapat mengontrol alur dengan menambahkan blok kode yang menangani situasi tak terduga.

TypeScript memperkuat konsep ini dengan sistem type checking, sehingga error bisa dideteksi bahkan sebelum kode dijalankan (saat kompilasi). Namun, tetap ada kesalahan yang hanya bisa ditangani di waktu runtime — di sinilah peran exception handling dengan try...catch menjadi penting.

Menggunakan try…catch

Blok try...catch digunakan untuk membungkus kode yang berpotensi menghasilkan error. Jika ada kesalahan di dalam blok try, maka eksekusi akan dialihkan ke blok catch tanpa menghentikan program.

Contoh:

try {
  const data = JSON.parse('{"nama": "Arvian"}'); // valid
  console.log(data.nama);
  
  const invalidData = JSON.parse('invalid JSON'); // error
  console.log(invalidData);
} catch (error) {
  console.error("Terjadi kesalahan saat parsing JSON:", error);
}

Output:

Arvian  
Terjadi kesalahan saat parsing JSON: SyntaxError: Unexpected token i in JSON

Dengan try…catch, aplikasi tidak berhenti meski terjadi kesalahan pada satu bagian kode.

Menggunakan throw untuk Melempar Error

Keyword throw digunakan untuk melempar kesalahan secara manual. Hal ini berguna ketika Anda ingin memvalidasi kondisi tertentu sebelum melanjutkan proses program.

Contoh:

function bagi(a: number, b: number): number {
  if (b === 0) {
    throw new Error("Tidak bisa membagi dengan nol!");
  }
  return a / b;
}

try {
  console.log(bagi(10, 2)); // 5
  console.log(bagi(10, 0)); // error
} catch (error) {
  console.error("Kesalahan:", (error as Error).message);
}

Output:

5  
Kesalahan: Tidak bisa membagi dengan nol!

throw membantu mencegah eksekusi kode yang salah dan memungkinkan developer memberikan pesan error yang jelas kepada pengguna atau log sistem.

Membuat Custom Error Class

TypeScript memungkinkan pembuatan custom error class agar error lebih spesifik dan mudah diidentifikasi. Ini sangat berguna dalam aplikasi besar dengan berbagai jenis kesalahan (misalnya validasi data, koneksi server, atau otentikasi).

Contoh:

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

function validateEmail(email: string) {
  if (!email.includes("@")) {
    throw new ValidationError("Format email tidak valid!");
  }
  return true;
}

try {
  validateEmail("userexample.com");
} catch (error) {
  if (error instanceof ValidationError) {
    console.error("Validasi gagal:", error.message);
  } else {
    console.error("Kesalahan tidak terduga:", error);
  }
}

Output:

Validasi gagal: Format email tidak valid!

Dengan custom error class, Anda bisa membedakan antara kesalahan umum dan kesalahan tertentu, lalu menanganinya secara spesifik sesuai kebutuhan aplikasi.

Kombinasi try…catch, throw, dan Custom Error

Dalam aplikasi nyata, teknik error handling biasanya digunakan secara bersamaan. Misalnya, validasi input di lapisan service, dan penanganan kesalahan di lapisan controller:

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

function login(username: string, password: string) {
  if (username !== "admin" || password !== "12345") {
    throw new AuthError("Username atau password salah!");
  }
  return "Login berhasil!";
}

try {
  console.log(login("user", "1234"));
} catch (error) {
  if (error instanceof AuthError) {
    console.error("Autentikasi gagal:", error.message);
  } else {
    console.error("Kesalahan sistem:", error);
  }
}

Output:

Autentikasi gagal: Username atau password salah!

Kesimpulan

Error handling dalam TypeScript adalah aspek penting untuk menjaga aplikasi tetap stabil dan mudah dipelihara. Dengan menggunakan try...catch, kita bisa menangani error tanpa menghentikan eksekusi program. Keyword throw memungkinkan developer melempar error secara manual, sementara custom error class memberikan fleksibilitas untuk membuat tipe kesalahan yang lebih spesifik.

Dengan memahami dan menerapkan konsep error handling dan exception dengan baik, Anda dapat membangun aplikasi TypeScript yang lebih aman, tangguh, dan mudah untuk di-debug di berbagai situasi.