JavaScript - Extending Errors (ID)

Halo, para ahli JavaScript masa depan! Hari ini, kita akan melompat ke dunia yang menarik dari pengembangan error di JavaScript. Jangan khawatir jika Anda baru belajar pemrograman - saya akan menjadi panduan ramah Anda dalam perjalanan ini. Pada akhir pelajaran ini, Anda akan menciptakan error khusus Anda sendiri seperti seorang pro!

Mengembangkan Kelas Error: Membuat Error Khusus

Ayo mulai dari dasar. Di JavaScript, kita memiliki kelas bawaan Error yang kita dapat gunakan untuk membuat objek error. Tetapi kadang-kadang, kita butuh error yang lebih spesifik untuk aplikasi kita. Itu di mana pengembangan kelas Error berguna!

Mengapa Mengembangkan Error?

Imagin Anda sedang membuat aplikasi memasak, dan Anda ingin membuat error khusus untuk kecelakaan dapur. Anda bisa menggunakan Error umum, tapi tidaklah buruk jika kita memiliki BurnedFoodError atau OverseasonedError, kan? Itu apa yang kita akan belajar!

Sintaks Dasar untuk Mengembangkan Error

Ayo mulai dengan contoh sederhana:

class KitchenError extends Error {
constructor(message) {
super(message);
this.name = 'KitchenError';
}
}

Ayoongkan ini:

1. Kita gunakan kata kunci class untuk mendefinisikan kelas error baru kita.
2. extends Error memberitahu JavaScript bahwa kelas baru kita harus mewarisi dari kelas Error bawaan.
3. Dalam constructor, kita panggil super(message) untuk memastikan kelas induk Error diinisialisasi dengan benar.
4. Kita set this.name untuk memberikan error kita nama khusus.

Sekarang, lihatlah bagaimana kita dapat menggunakannya:

try {
throw new KitchenError("The spaghetti is stuck to the ceiling!");
} catch (error) {
console.log(error.name); // Output: KitchenError
console.log(error.message); // Output: The spaghetti is stuck to the ceiling!
}

Menambah Properti Khusus

Salah satu hal yang menarik tentang mengembangkan error adalah kita dapat menambah properti khusus. Ayo tingkatkan KitchenError kita:

class KitchenError extends Error {
constructor(message, dish) {
super(message);
this.name = 'KitchenError';
this.dish = dish;
}
}

try {
throw new KitchenError("It's burning!", "lasagna");
} catch (error) {
console.log(`Oh no! The ${error.dish} is in trouble: ${error.message}`);
// Output: Oh no! The lasagna is in trouble: It's burning!
}

Dalam contoh ini, kita menambahkan properti dish ke error kita. Ini memungkinkan kita untuk memberikan lebih banyak konteks tentang apa yang benar-benar salah di kecelakaan dapur kita!

Membuat Tipe Error Khusus

Sekarang kita tahu bagaimana mengembangkan kelas Error, ayo buat beberapa tipe error khusus untuk aplikasi dapur kita:

class BurnedFoodError extends KitchenError {
constructor(dish) {
super(`The ${dish} is burned to a crisp!`, dish);
this.name = 'BurnedFoodError';
}
}

class OverseasonedError extends KitchenError {
constructor(dish, seasoning) {
super(`The ${dish} is over-seasoned with ${seasoning}!`, dish);
this.name = 'OverseasonedError';
this.seasoning = seasoning;
}
}

Sekarang kita dapat menggunakan tipe error spesifik ini dalam kode kita:

function cookDinner(dish, seasoning) {
if (Math.random() < 0.5) {
throw new BurnedFoodError(dish);
} else if (Math.random() < 0.5) {
throw new OverseasonedError(dish, seasoning);
}
console.log(`Your ${dish} is perfectly cooked!`);
}

try {
cookDinner("steak", "salt");
} catch (error) {
if (error instanceof BurnedFoodError) {
console.log(`Oops! ${error.message} Time to order takeout.`);
} else if (error instanceof OverseasonedError) {
console.log(`Yikes! ${error.message} Maybe use less ${error.seasoning} next time.`);
} else {
console.log("Something went wrong in the kitchen!");
}
}

Kode ini mensimulasikan nature tak tentu dari memasak (setidaknya bagi beberapa dari kita!) dan menunjukkan bagaimana kita dapat menangani error berbeda dalam cara yang berbeda.

Pewarisan Multilevel

Sekarang, mari kita naikkan tingkat pewarisan error kita - secara harfiah! Kita dapat menciptakan rantai tipe error, masing-masing mewarisi dari yang sebelumnya. Ini disebut pewarisan multilevel.

Ayo luaskan sistem error dapur kita:

class KitchenApplianceError extends KitchenError {
constructor(message, appliance) {
super(message);
this.name = 'KitchenApplianceError';
this.appliance = appliance;
}
}

class OvenError extends KitchenApplianceError {
constructor(message) {
super(message, 'oven');
this.name = 'OvenError';
}
}

class MicrowaveError extends KitchenApplianceError {
constructor(message) {
super(message, 'microwave');
this.name = 'MicrowaveError';
}
}

Dalam contoh ini:

• KitchenApplianceError mewarisi KitchenError
• OvenError dan MicrowaveError keduanya mewarisi KitchenApplianceError

Ayo lihat bagaimana kita dapat menggunakannya:

function useAppliance(appliance) {
if (appliance === 'oven') {
throw new OvenError("The oven won't heat up!");
} else if (appliance === 'microwave') {
throw new MicrowaveError("The microwave is making strange noises!");
}
}

try {
useAppliance('oven');
} catch (error) {
if (error instanceof OvenError) {
console.log(`Oven problem: ${error.message}`);
} else if (error instanceof MicrowaveError) {
console.log(`Microwave issue: ${error.message}`);
} else if (error instanceof KitchenApplianceError) {
console.log(`General appliance error with the ${error.appliance}: ${error.message}`);
} else if (error instanceof KitchenError) {
console.log(`Kitchen error: ${error.message}`);
} else {
console.log(`Unexpected error: ${error.message}`);
}
}

Pewarisan multilevel ini memungkinkan kita untuk menciptakan tipe error yang sangat spesifik saat masih menjaga hierarki logis. Kita dapat menangkap error pada tingkat kekerasan yang berbeda, dari yang paling spesifik (OvenError) ke yang paling umum (Error).

Tabel Metode

Berikut adalah tabel yang menggabungkan metode dan properti kunci yang kita gunakan dalam error khusus kita:

Metode/Properti	Deskripsi	Contoh
constructor()	Inisialisasi objek error	constructor(message, dish)
super()	Memanggil kontruktur kelas induk	super(message)
this.name	Mengatur nama error	this.name = 'KitchenError'
this.[custom]	Menambah properti khusus	this.dish = dish
instanceof	Memeriksa jika objek adalah instance kelas	if (error instanceof OvenError)

Ingat, mengembangkan error tidak hanya tentang menciptakan nama keren untuk kesalahan Anda - itu tentang menciptakan cara yang terstruktur untuk menangani berbagai jenis error dalam kode Anda. Ini bisa membuat penelusuran kesalahan mudah dan pesan kesalahan Anda lebih informatif dan spesifik.

Jadi, berikut kali Anda sedang mengoding dan sesuatu salah, jangan hanya lempar error umum - buat yang khusus! Siapa tahu, mungkin CodeSpaghettiError Anda akan menjadi pembicaraan di tim pengembangan Anda. Selamat coding, dan semoga kesalahan Anda semua terkembang dengan baik!

Credits: Image by storyset