Ghid pentru începători pentru gestionarea erorilor TypeScript

Gestionarea eficientă a erorilor este crucială în orice limbaj de programare, iar TypeScript nu face excepție. Gestionarea corectă a erorilor ajută la crearea de aplicații robuste și fiabile prin gestionarea cu grație a condițiilor neașteptate. Acest ghid va acoperi elementele de bază ale gestionării erorilor în TypeScript și va oferi exemple practice pentru începători.

Înțelegerea erorilor în TypeScript

Erorile în TypeScript, ca și în JavaScript, apar în timpul rulării sau în timpul compilării. TypeScript oferă siguranța tipului care poate detecta multe probleme potențiale în timpul compilării, dar erorile de rulare încă trebuie gestionate corect.

Tratarea de bază a erorilor cu try și catch

În TypeScript, gestionați erorile de rulare folosind blocurile try și catch. Această abordare vă permite să executați cod care ar putea genera o eroare și să gestionați acea eroare dacă apare.

Exemplu de try și 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

În acest exemplu, funcția divide încearcă să împartă două numere. Dacă divizorul este zero, o eroare este aruncată și prinsă de blocul catch, care înregistrează un mesaj de eroare.

Tipuri de erori personalizate

TypeScript vă permite să definiți tipuri de erori personalizate pentru a reprezenta mai bine condițiile de eroare specifice. Tipurile de erori personalizate ajută la clasificarea erorilor și la tratarea lor mai eficient.

Crearea unui tip de eroare personalizat

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

Aici, definim o clasă de eroare personalizată DivisionError care extinde clasa încorporată Error. Folosim această eroare personalizată în funcția divide pentru a oferi o gestionare mai specifică a erorilor.

Tip Guarding cu instanceof

Protecțiile de tip, cum ar fi instanceof, ajută la restrângerea tipului de obiect de eroare din blocul catch, permițându-vă să gestionați diferite tipuri de erori în mod diferit.

Exemplu de tip de pază

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

Acest exemplu demonstrează protecția tipului în blocul catch pentru a se asigura că obiectul de eroare este o instanță a Eroare, permițând o gestionare precisă a erorilor.

Folosind finally pentru Curățare

Blocul finally poate fi folosit pentru a executa cod care ar trebui să ruleze indiferent dacă a apărut sau nu o eroare. Acest lucru este util pentru operațiuni de curățare, cum ar fi închiderea fișierelor sau eliberarea de resurse.

Exemplu cu 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

În acest exemplu, blocul finally asigură că un mesaj de curățare este înregistrat, indiferent dacă apare o eroare.

Concluzie

Gestionarea eficientă a erorilor este crucială pentru construirea de aplicații TypeScript fiabile. Folosind try și catch, tipuri de erori personalizate, tip de pază și finally, puteți gestiona erorile mai eficient și vă puteți asigura că aplicația dumneavoastră se comportă previzibil chiar și în în fața unor condiții neașteptate.

Cu aceste tehnici, puteți gestiona erorile cu grație și puteți îmbunătăți robustețea codului TypeScript. Exersați aceste concepte pentru a deveni priceput în gestionarea erorilor TypeScript și pentru a scrie aplicații mai rezistente.