Pengendalian Ralat dalam JavaScript

Artikel ini menerangkan pengendalian ralat dalam JavaScript.

YouTube Video

Pengendalian Ralat dalam JavaScript

Pengendalian ralat dalam JavaScript adalah ciri penting untuk menangkap dan mengendalikan ralat dengan sewajarnya apabila program menghadapi isu yang tidak dijangka. Utamanya, adalah biasa untuk menggunakan sintaks try...catch bagi menangkap dan mengendalikan ralat. Tambahan pula, apabila berurusan dengan Promises atau operasi tak segerak, pengendalian ralat juga boleh dilakukan menggunakan async/await atau Promise.prototype.catch.

Sintaks try...catch

try...catch digunakan untuk menangkap dan mengendalikan ralat apabila ia berlaku dalam blok kod.

 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 ralat berlaku dalam blok try, pelaksanaan program akan terganggu dan blok catch akan dijalankan.
• Blok finally sentiasa dijalankan, tidak kira sama ada terdapat ralat atau tidak. Ia berguna untuk melepaskan sumber dan pemprosesan akhir, antara lain.

Membuang Ralat (throw)

Dalam JavaScript, anda boleh mencetuskan ralat secara eksplisit menggunakan kata kunci throw. Ia digunakan untuk membuang mesej ralat tersuai atau ralat tersuai.

 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}

Pengendalian Ralat dalam Operasi Tak Segerak (Promise dan async/await)

Apabila menjalankan operasi tak segerak, pengendalian ralat agak berbeza. Apabila menggunakan Promises, ralat ditangkap dengan kaedah 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!"

Apabila menjalankan operasi tak segerak menggunakan async/await, anda boleh mengendalikan ralat 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 boleh menangkap ralat segerak menggunakan sintaks try...catch.
• Anda boleh membuang ralat anda sendiri menggunakan throw.
• Ralat dalam operasi tak segerak boleh dikendalikan menggunakan kaedah catch dari Promise, atau dengan async/await dan try...catch.

Dengan menggunakan kaedah-kaedah ini, anda boleh memastikan program anda berfungsi dengan betul walaupun ralat berlaku.

Error

Kelas Error digunakan untuk pengendalian ralat. Ia menyediakan keupayaan untuk mencipta ralat dan memberi mesej ralat serta jejak tumpukan.

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

Penggunaan Asas

Objek Error boleh dicipta secara eksplisit apabila ralat berlaku. Anda mencipta satu instans dengan new Error() dan memberikan mesej ralat.

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)

Melontar Ralat dengan throw

Dalam JavaScript, anda boleh melontar ralat menggunakan kata kunci throw. Ini digunakan untuk mengganggu pemprosesan dalam situasi tertentu dan menyerahkan kawalan kepada pengendali ralat.

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}

Ralat yang dilontar dengan throw boleh ditangkap menggunakan sintaks try...catch.

Mencipta Ralat Khusus

Dalam JavaScript, anda boleh mencipta ralat khusus dengan memperluas kelas Error. Ini membolehkan anda mencipta ralat yang sesuai dengan 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 Ralat Terbina Dalam

JavaScript mempunyai beberapa kelas ralat terbina dalam yang memperluas kelas Error. Ini digunakan untuk mewakili ralat tertentu.

• ReferenceError: Berlaku apabila anda merujuk kepada pembolehubah yang tidak wujud.
• TypeError: Berlaku apabila jenis nilai berbeza daripada jenis yang dijangkakan.
• RangeError: Berlaku apabila nombor berada di luar julat yang dibenarkan.
• SyntaxError: Berlaku apabila kod yang tidak betul secara sintaks dilaksanakan.
• EvalError: Ralat yang berkaitan dengan penggunaan fungsi eval(). Ia jarang digunakan pada masa kini.
• URIError: Berlaku apabila URI yang tidak sah digunakan (ralat pengekodan atau penyahkodan).

Contoh: ReferenceError

Berikut adalah contoh 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 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 anda ingin laksanakan tanpa mengira sama ada ralat berlaku 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 akhirnya akan dilaksanakan walaupun terdapat ralat yang dilemparkan.

Sifat-sifat Objek Error

Objek Error mempunyai sifat-sifat berikut.

• message: Ini adalah mesej ralat.
• name: Nama bagi ralat, yang secara lalai adalah "Error".
• stack: Jejak tumpukan yang mengandungi lokasi berlakunya ralat, berguna untuk penyahpepijatan.

Kelebihan Pengendalian Pengecualian

Dengan melaksanakan pengendalian ralat dengan betul, anda dapat mengelakkan aplikasi daripada ranap apabila tingkah laku yang tidak dijangka berlaku. Dengan menggunakan sintaks cuba...tangkap dan objek ralat dengan sewajarnya, anda dapat menulis kod yang lebih kukuh.

 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 mewakili punca ralat dan melaksanakan pengendalian ralat.
• Gunakan sintaks cuba...tangkap...akhirnya untuk mengendali ralat dan mengelakkan penamatan aplikasi yang tidak dijangka.
• Ia juga boleh untuk melanjutkan kelas Error bagi mencipta ralat khusus.
• Anda boleh mengendalikan pelbagai jenis ralat dengan menggunakan kelas ralat bina-dalam seperti TypeError dan ReferenceError.

Anda boleh mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Sila lihat juga saluran YouTube kami.

YouTube Video