מדריך למתחילים לטיפול בשגיאות TypeScript

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

הבנת שגיאות ב-TypeScript

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

טיפול בשגיאות בסיסי עם try ו-catch

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

דוגמה של try ו-catch

function divide(a: number, b: number): number {
  try {
    if (b === 0) {
      throw new Error("Cannot divide by zero");
    }
    return a / b;
  } catch (error) {
    console.error(error.message);
    return NaN; // Return NaN to indicate an error
  }
}

console.log(divide(10, 2)); // Output: 5
console.log(divide(10, 0)); // Output: Cannot divide by zero

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

סוגי שגיאות מותאמים אישית

TypeScript מאפשר לך להגדיר סוגי שגיאה מותאמים אישית כדי לייצג טוב יותר תנאי שגיאה ספציפיים. סוגי שגיאות מותאמים אישית עוזרים לסווג שגיאות וטיפול בהן בצורה יעילה יותר.

יצירת סוג שגיאה מותאם אישית

class DivisionError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "DivisionError";
  }
}

function divide(a: number, b: number): number {
  try {
    if (b === 0) {
      throw new DivisionError("Cannot divide by zero");
    }
    return a / b;
  } catch (error) {
    if (error instanceof DivisionError) {
      console.error(`Custom Error: ${error.message}`);
    } else {
      console.error("An unexpected error occurred");
    }
    return NaN; // Return NaN to indicate an error
  }
}

console.log(divide(10, 2)); // Output: 5
console.log(divide(10, 0)); // Output: Custom Error: Cannot divide by zero

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

הקלד Guarding עם instanceof

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

דוגמה לשמירה על סוג

function processInput(input: string | number) {
  try {
    if (typeof input === "string") {
      console.log(input.toUpperCase());
    } else {
      throw new Error("Input must be a string");
    }
  } catch (error) {
    if (error instanceof Error) {
      console.error(`Error: ${error.message}`);
    } else {
      console.error("An unknown error occurred");
    }
  }
}

processInput("hello"); // Output: HELLO
processInput(42); // Output: Error: Input must be a string

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

שימוש ב-finally לניקוי

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

דוגמה עם סוף סוף

function readFile(filePath: string): string {
  try {
    // Simulate reading a file
    if (filePath === "") {
      throw new Error("File path cannot be empty");
    }
    return "File content";
  } catch (error) {
    console.error(`Error: ${error.message}`);
    return "";
  } finally {
    console.log("Cleanup: Closing file");
  }
}

console.log(readFile("path/to/file")); // Output: File content
console.log(readFile("")); // Output: Error: File path cannot be empty
                            //         Cleanup: Closing file

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

מַסְקָנָה

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

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