Penanganan Kesalahan dalam JavaScript

Artikel ini menjelaskan penanganan kesalahan dalam JavaScript.

YouTube Video

Penanganan Kesalahan dalam JavaScript

Penanganan kesalahan dalam JavaScript adalah fitur penting untuk menangkap dan menangani kesalahan dengan tepat ketika program menghadapi masalah yang tidak terduga. Pada dasarnya, sintaks try...catch sering digunakan untuk menangkap dan menangani kesalahan. Selain itu, dalam menangani Promises atau operasi asinkron, penanganan kesalahan dapat dilakukan menggunakan async/await atau Promise.prototype.catch.

Sintaks try...catch

try...catch digunakan untuk menangkap dan menangani kesalahan ketika terjadi dalam blok kode.

 1try {
 2    // Code that may throw an error
 3    let result = riskyFunction();
 4    console.log(result);
 5} catch (error) {
 6    // Catch and handle the error
 7    console.error("An error occurred:", error.message);
 8} finally {
 9    // Code that will always execute
10    console.log("Error handling has completed.");
11}

• Jika sebuah kesalahan terjadi di dalam blok try, eksekusi program akan dihentikan, dan blok catch akan dijalankan.
• Blok finally selalu dijalankan, terlepas dari apakah ada kesalahan atau tidak. Blok ini berguna untuk melepaskan sumber daya dan melakukan pemrosesan akhir, serta keperluan lainnya.

Melempar Kesalahan (throw)

Dalam JavaScript, Anda dapat secara eksplisit memicu kesalahan menggunakan kata kunci throw. Ini digunakan untuk melempar pesan kesalahan khusus atau kesalahan khusus.

 1function checkAge(age) {
 2    if (age < 18) {
 3        throw new Error("You are under 18 years old.");
 4    }
 5    return "Age verification completed.";
 6}
 7
 8try {
 9    let result = checkAge(15);
10    console.log(result);
11} catch (error) {
12    console.error(error.message);  // Displays "You are under 18 years old."
13}

Penanganan Kesalahan dalam Operasi Asinkron (Promise dan async/await)

Ketika melakukan operasi asinkron, penanganan kesalahan sedikit berbeda. Ketika menggunakan Promises, kesalahan ditangkap dengan metode catch.

1let promise = new Promise((resolve, reject) => {
2    // Asynchronous operation
3    setTimeout(() => reject(new Error("An issue has occurred!")), 1000);
4});
5
6promise
7    .then(result => console.log(result))
8    .catch(error => console.error(error.message));  // Displays "An issue has occurred!"

Ketika melakukan operasi asinkron menggunakan async/await, Anda dapat menangani kesalahan dengan try...catch.

 1async function fetchData() {
 2    try {
 3        let response = await fetch('https://api.example.com/data');
 4        let data = await response.json();
 5        console.log(data);
 6    } catch (error) {
 7        console.error("An error occurred while fetching data:", error.message);
 8    }
 9}
10
11fetchData();

Ringkasan

• Anda dapat menangkap kesalahan sinkron menggunakan sintaks try...catch.
• Anda dapat melempar kesalahan Anda sendiri menggunakan throw.
• Kesalahan dalam operasi asinkron dapat ditangani menggunakan metode catch dari Promise, atau dengan async/await dan try...catch.

Dengan memanfaatkan metode-metode ini, Anda dapat memastikan bahwa program Anda berfungsi dengan benar bahkan ketika terjadi kesalahan.

Error

Kelas Error digunakan untuk penanganan kesalahan. Kelas ini menyediakan kemampuan untuk membuat kesalahan dan memberikan pesan kesalahan serta jejak tumpukan (stack trace).

1try {
2    throw new Error("Something went wrong");
3} catch (e) {
4    console.log(e.message); // Something went wrong
5}

Penggunaan Dasar

Objek Error dapat dibuat secara eksplisit saat terjadi kesalahan. Anda membuat instance dengan new Error() dan memberikan pesan kesalahan.

1const error = new Error("Something went wrong");
2console.log(error.message);  // "Something went wrong"
3console.log(error.name);     // "Error"
4console.log(error.stack);    // Stack trace (information about where the error occurred)

Melempar Kesalahan dengan throw

Dalam JavaScript, Anda dapat melemparkan kesalahan menggunakan kata kunci throw. Ini digunakan untuk menghentikan pemrosesan dalam situasi tertentu dan menyerahkan kontrol ke penangan kesalahan.

1function doSomething() {
2    throw new Error("This function is not yet implemented");
3}
4
5try {
6    doSomething();
7} catch (e) {
8    console.error(e.message);  // "This function is not yet implemented"
9}

Kesalahan yang dilemparkan dengan throw dapat ditangkap dengan menggunakan sintaks try...catch.

Membuat Kesalahan Kustom

Dalam JavaScript, Anda dapat membuat kesalahan khusus sendiri dengan memperluas kelas Error. Ini memungkinkan Anda untuk membuat kesalahan yang disesuaikan untuk situasi tertentu.

 1class CustomError extends Error {
 2    constructor(message) {
 3        super(message);  // Call the parent class constructor
 4        this.name = "CustomError";  // Set the error name
 5    }
 6}
 7
 8try {
 9    throw new CustomError("A custom error has occurred");
10} catch (e) {
11    console.error(e.name);    // "CustomError"
12    console.error(e.message); // "A custom error has occurred"
13}

Kelas Kesalahan Bawaan

JavaScript memiliki beberapa kelas kesalahan bawaan yang memperluas kelas Error. Ini digunakan untuk merepresentasikan kesalahan tertentu.

• ReferenceError: Terjadi ketika Anda merujuk ke variabel yang tidak ada.
• TypeError: Terjadi ketika jenis nilai berbeda dari jenis yang diharapkan.
• RangeError: Terjadi ketika sebuah angka berada di luar rentang yang diizinkan.
• SyntaxError: Terjadi ketika kode yang tidak sesuai sintaks dieksekusi.
• EvalError: Kesalahan yang terkait dengan penggunaan fungsi eval(). Ini jarang digunakan saat ini.
• URIError: Terjadi ketika URI yang tidak valid (kesalahan pengkodean atau dekode) digunakan.

Contoh: ReferenceError

Berikut adalah contoh dari ReferenceError.

1try {
2    console.log(undefinedVariable);  // Undefined variable
3} catch (e) {
4    console.error(e.name);    // "ReferenceError"
5    console.error(e.message); // "undefinedVariable is not defined"
6}

Contoh: TypeError

Berikut adalah contoh dari TypeError.

1try {
2    null.f();  // Attempting to call a function on null
3} catch (e) {
4    console.error(e.name);    // "TypeError"
5    console.error(e.message); // "Cannot read properties of null (reading 'f')"
6}

Blok finally

Dalam sintaks try...catch, gunakan blok finally untuk operasi yang ingin Anda jalankan terlepas dari apakah terjadi kesalahan atau tidak.

1try {
2    throw new Error("An issue has occurred");
3} catch (e) {
4    console.error(e.message);  // "An issue has occurred"
5} finally {
6    console.log("Performing cleanup");
7}

Dalam contoh ini, operasi dalam blok finally dieksekusi bahkan jika terjadi kesalahan.

Properti dari Objek Error

Objek Error memiliki properti-properti berikut.

• message: Ini adalah pesan kesalahan.
• name: Nama kesalahan, yang secara default adalah "Error".
• stack: Sebuah jejak tumpukan yang menunjukkan di mana kesalahan terjadi, berguna untuk debugging.

Manfaat Penanganan Pengecualian

Dengan menerapkan penanganan kesalahan dengan benar, Anda dapat mencegah aplikasi mengalami crash ketika terjadi perilaku yang tidak terduga. Dengan menggunakan sintaks try...catch dan objek kesalahan dengan tepat, Anda dapat menulis kode yang lebih andal.

 1function divide(a, b) {
 2    if (b === 0) {
 3        throw new Error("Cannot divide by zero");
 4    }
 5    return a / b;
 6}
 7
 8try {
 9    console.log(divide(4, 0));  // An error will occur
10} catch (e) {
11    console.error(e.message);   // "Cannot divide by zero"
12}

Ringkasan

• Kelas Error digunakan untuk merepresentasikan penyebab kesalahan dan melakukan penanganan kesalahan.
• Gunakan sintaks try...catch...finally untuk menangani kesalahan dan mencegah penghentian aplikasi yang tidak terduga.
• Dimungkinkan juga untuk memperluas kelas Error untuk membuat kesalahan khusus.
• Anda dapat menangani berbagai jenis kesalahan dengan menggunakan kelas kesalahan bawaan seperti TypeError dan ReferenceError.

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

YouTube Video