ניהול שגיאות בג'אווה-סקריפט

מאמר זה מסביר על ניהול שגיאות בג'אווה-סקריפט.

YouTube Video

ניהול שגיאות בג'אווה-סקריפט

ניהול שגיאות בג'אווה-סקריפט הוא תכונה חשובה ללכידת שגיאות וטיפול בהן כראוי כאשר התוכנה נתקלת בתקלות בלתי צפויות. בעיקרון, נהוג להשתמש בתחביר try...catch ללכידת שגיאות וטיפול בהן. בנוסף, בעת טיפול ב-Promises או בפעולות אסינכרוניות, ניתן לנהל שגיאות גם באמצעות async/await או Promise.prototype.catch.

תחביר try...catch

try...catch משמש ללכידת שגיאות וטיפול בהן כאשר הן קורות בתוך בלוק קוד.

 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}

• אם שגיאה מתרחשת בתוך בלוק try, ביצוע התוכנית מופרע והבלוק של catch מופעל.
• בלוק finally מתבצע תמיד, ללא קשר אם התרחשה שגיאה או לא. הוא שימושי לשחרור משאבים ולעיבוד סופי, בין היתר.

השלכת שגיאות (throw)

בג'אווה-סקריפט, ניתן להפעיל שגיאה במפורש באמצעות מילת המפתח throw. משמש להשלכת הודעות שגיאה מותאמות אישית או שגיאות מותאמות אישית.

 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}

ניהול שגיאות בפעולות אסינכרוניות (Promise ו-async/await)

כאשר מבצעים פעולות אסינכרוניות, ניהול השגיאות הוא מעט שונה. כאשר משתמשים ב-Promises, שגיאות נתפסות עם המתודה 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!"

כאשר מבצעים פעולות אסינכרוניות באמצעות async/await, ניתן לטפל בשגיאות עם 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();

סיכום

• ניתן לתפוס שגיאות סינכרוניות באמצעות תחביר try...catch.
• ניתן להשליך שגיאות מותאמות אישית באמצעות throw.
• ניתן לנהל שגיאות בפעולות אסינכרוניות באמצעות מתודת catch של Promise, או עם async/await ו-try...catch.

באמצעות שימוש בשיטות אלה, ניתן להבטיח שהתוכנית תפעל כראוי גם כאשר מתרחשות שגיאות.

Error

המחלקה Error משמשת לניהול שגיאות. היא מספקת את היכולת ליצור שגיאות ולספק הודעות שגיאה ועקיבות מחסנית.

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

שימוש בסיסי

ניתן ליצור אובייקט Error באופן מפורש כאשר מתרחשת שגיאה. יוצרים מופע עם new 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)

זריקת שגיאות עם throw

ב-JavaScript, ניתן לזרוק שגיאה באמצעות מילת המפתח throw. זה משמש לעצירת עיבוד במצבים מסוימים ולהעברת השליטה למטפל בשגיאה.

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}

שגיאות הנזרקות עם throw ניתנות ללכידה באמצעות תחביר try...catch.

יצירת שגיאות מותאמות אישית

ב-JavaScript, ניתן ליצור שגיאות מותאמות אישית על ידי הרחבת המחלקה Error. זה מאפשר ליצור שגיאות המותאמות למצבים מסוימים.

 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}

מחלקות שגיאה מובנות

ל-JavaScript מספר מחלקות שגיאה מובנות שמרחיבות את המחלקה Error. אלו משמשות לייצוג שגיאות מסוימות.

• ReferenceError: מתרחשת כאשר מתייחסים למשתנה שאינו קיים.
• TypeError: מתרחשת כאשר הסוג של ערך שונה מהסוג המצופה.
• RangeError: מתרחשת כאשר מספר נמצא מחוץ לטווח המותר.
• SyntaxError: מתרחשת כאשר מבוצע קוד שאינו נכון תחבירית.
• EvalError: שגיאות הקשורות לשימוש בפונקציה eval(). כיום נעשה בו שימוש לעיתים רחוקות.
• URIError: מתרחשת כאשר נעשה שימוש ב-URI שגוי (שגיאות קידוד או פענוח).

דוגמה: ReferenceError

להלן דוגמה ל-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}

דוגמה: TypeError

להלן דוגמה ל-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}

בלוק finally

בתחביר try...catch, יש להשתמש בבלוק finally לפעולות שברצונך לבצע ללא תלות אם מתרחשת שגיאה.

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}

בדוגמה זו, הפעולות בבלוק finally מתבצעות גם אם נזרקה שגיאה.

מאפייני אובייקט ה-Error

לאובייקט ה-Error יש את המאפיינים הבאים.

• message: זהו הודעת השגיאה.
• name: שם השגיאה, שבברירת מחדל הוא "Error".
• stack: מעקב מחסנית שמכיל מידע על מיקום התרחשות השגיאה, שימושי לניפוי באגים.

יתרונות בטיפול ביוצאים מן הכלל

על ידי יישום נכון של טיפול בשגיאות, ניתן למנוע מהתוכנה לקרוס כאשר מתרחש התנהגות בלתי צפויה. בשימוש נכון בתחביר של try...catch ובאובייקטי שגיאות, תוכלו לכתוב קוד חזק יותר.

 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}

סיכום

• מחלקת ה-Error משמשת לייצוג גורם שגיאה ולביצוע טיפול בשגיאות.
• השתמשו בתחביר try...catch...finally לטיפול בשגיאות ולמניעת סיום בלתי צפוי של התוכנה.
• ניתן גם להרחיב את מחלקת ה-Error ליצירת שגיאות מותאמות אישית.
• ניתן לטפל בסוגים שונים של שגיאות על ידי שימוש במחלקות שגיאה מובנות כמו TypeError ו-ReferenceError.

תוכלו לעקוב אחר המאמר שלמעלה באמצעות Visual Studio Code בערוץ היוטיוב שלנו. נא לבדוק גם את ערוץ היוטיוב.

YouTube Video