Paghawak ng Error sa JavaScript

Binibigyang paliwanag ng artikulong ito ang paghawak ng error sa JavaScript.

YouTube Video

Paghawak ng Error sa JavaScript

Ang paghawak ng error sa JavaScript ay isang mahalagang tampok para mahuli at maayos na mahawakan ang mga error kapag nakakaranas ang programa ng mga hindi inaasahang problema. Karaniwan, ginagamit ang sintaks na try...catch upang mahuli at maharap ang mga error. Bukod dito, kapag humaharap sa mga Promises o asynchronous na operasyon, maaaring gawin ang paghawak ng error gamit ang async/await o Promise.prototype.catch.

Sintaks na try...catch

Ginagamit ang try...catch upang mahuli at maharap ang mga error kapag nangyari ang mga ito sa loob ng isang code block.

 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}

• Kung may error na nangyari sa loob ng isang try block, natitigil ang pagpapatakbo ng programa, at ang catch block ang isinasagawa.
• Ang finally block ay laging isinasagawa, kahit pa may error o wala. Ito ay kapaki-pakinabang para sa pagpapalaya ng mga resources at panghuling proseso, bukod sa iba pang bagay.

Pagbuga ng Error (throw)

Sa JavaScript, maaari kang mag-trigger ng error nang hayagan gamit ang keyword na throw. Ginagamit ito kapag nagbubuga ng mga custom na mensahe ng error o mga custom na error.

 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}

Paghawak ng Error sa Asynchronous na Operasyon (Promise at async/await)

Kapag gumagawa ng mga asynchronous na operasyon, bahagyang naiiba ang paghawak ng error. Kapag gumagamit ng Promises, nahuhuli ang mga error gamit ang metodo na 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!"

Kapag gumagawa ng mga asynchronous na operasyon gamit ang async/await, maaari mong harapin ang mga error gamit ang 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();

Buod

• Maaari mong mahuli ang mga synchronous na error gamit ang sintaks na try...catch.
• Maaari kang magbuga ng sarili mong mga error gamit ang throw.
• Ang mga error sa asynchronous na operasyon ay maaaring hawakan gamit ang metodo na catch ng Promise, o gamit ang async/await at try...catch.

Sa pamamagitan ng paggamit ng mga pamamaraang ito, masisiguro mo na gumagana nang maayos ang iyong programa kahit na may mga error na nangyayari.

Error

Ang Error class ay ginagamit para sa paghawak ng error. Nagbibigay ito ng kakayahang lumikha ng mga error at magbigay ng mga error na mensahe at stack trace.

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

Pangunahing Paggamit

Maaaring lumikha ng isang Error object nang tahasan kapag naganap ang isang error. Lumikha ka ng isang instance gamit ang new Error() at magpasa ng mensahe ng error.

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)

Pagpapasa ng Mga Error gamit ang throw

Sa JavaScript, maaari kang magpasa ng error gamit ang keyword na throw. Ginagamit ito upang mahinto ang proseso sa partikular na sitwasyon at ipasa ang kontrol sa isang error handler.

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}

Ang mga error na ipinasa gamit ang throw ay maaaring mahuli gamit ang syntax na try...catch.

Paglikha ng Mga Custom na Error

Sa JavaScript, maaari kang lumikha ng sarili mong mga custom na error sa pamamagitan ng pagpapalawig sa klase ng Error. Pinapayagan ka nitong lumikha ng mga error na angkop sa partikular na mga sitwasyon.

 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}

Mga Built-in na Klase ng Error

Ang JavaScript ay may ilang built-in na klase ng error na nagpapalawig sa klase ng Error. Ginagamit ang mga ito upang kumatawan sa mga partikular na error.

• ReferenceError: Nangyayari kapag nag-reference ka ng isang variable na hindi umiiral.
• TypeError: Nangyayari kapag ang uri ng isang halaga ay iba sa inaasahang uri.
• RangeError: Nangyayari kapag ang isang numero ay nasa labas ng pinapahintulutang saklaw.
• SyntaxError: Nangyayari kapag ang isang code na hindi tama ang syntax ay na-execute.
• EvalError: Mga error na may kaugnayan sa paggamit ng function na eval(). Bihira na itong ginagamit sa kasalukuyan.
• URIError: Nangyayari kapag gumamit ng isang invalid na URI (mga error sa encoding o decoding).

Halimbawa: ReferenceError

Narito ang halimbawa ng isang 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}

Halimbawa: TypeError

Narito ang halimbawa ng isang 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}

Block na finally

Sa syntax na try...catch, gamitin ang block na finally para sa mga operasyon na nais mong isagawa kahit na may maganap na error o wala.

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}

Sa halimbawang ito, ang mga operasyon sa finally block ay isinasagawa kahit na may error na nangyari.

Mga Katangian ng Error Object

Ang Error object ay may mga sumusunod na katangian.

• message: Ito ang mensahe ng error.
• name: Ang pangalan ng error, na karaniwang itinatakda sa "Error".
• stack: Isang stack trace na naglalaman kung saan naganap ang error, kapaki-pakinabang para sa pag-debug.

Mga Benepisyo ng Exception Handling

Kapag maayos ang implementasyon ng error handling, maiiwasan mong mag-crash ang aplikasyon kahit na may di-inaasahang pagkilos na maganap. Sa wastong paggamit ng try...catch na syntax at mga error object, makakagawa ka ng mas matibay na code.

 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}

Buod

• Ang Error class ay ginagamit upang kumatawan sa sanhi ng error at upang magsagawa ng error handling.
• Gamitin ang syntax na try...catch...finally upang ma-handle ang mga error at maiwasan ang di-inaasahang pagtigil ng aplikasyon.
• Maaari ring i-extend ang Error class upang makagawa ng mga custom na error.
• Maaari mong i-handle ang iba't ibang uri ng error sa pamamagitan ng paggamit ng mga built-in error class tulad ng TypeError at ReferenceError.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video