Tipurile de erori

În blocul catch, putem obține informații despre eroare, care este reprezentată printr-un obiect. Toate erorile generate de interpretorul JavaScript oferă un obiect de tip Error, care are o serie de proprietăți:

• message: mesajul despre eroare
• name: tipul de eroare

Trebuie menționat că unele browsere suportă și alte proprietăți, dar comportamentul lor poate varia în funcție de browser:

• fileName: numele fișierului cu cod JavaScript în care a apărut eroarea
• lineNumber: linia în fișierul în care a apărut eroarea
• columnNumber: coloana în linia în care a apărut eroarea
• stack: stiva de eroare

Vom obține datele erorii, de exemplu, în cazul apelului unei funcții care nu există:

try {
   callSomeFunc();
}
catch (error) {
   console.log("Tipul erorii:", error.name);
   console.log("Eroare:", error.message);
}

Ieșire în Consolă:

Tipul erorii: ReferenceError
Eroare: callSomeFunc is not defined

Tipuri de erori

Mai sus am menționat că eroarea generată de interpretor reprezintă un tip Error, însă atunci când se apelează o funcție inexistentă, se generează o eroare de tip ReferenceError. Motivul este că tipul Error reprezintă un tip general de erori. În același timp, există tipuri specifice de erori pentru situații particulare:

• EvalError: reprezintă o eroare generată la executarea funcției globale eval()
• RangeError: eroare generată atunci când un parametru sau o variabilă reprezintă un număr care se află în afara unui anumit interval permis
• ReferenceError: eroare generată atunci când se face referire la o referință inexistentă
• SyntaxError: reprezintă o eroare de sintaxă
• TypeError: eroare generată atunci când valoarea unei variabile sau a unui parametru reprezintă un tip incorect sau în încercarea de a modifica o valoare care nu poate fi modificată
• URIError: eroare generată atunci când funcțiile encodeURI() și decodeURI() primesc valori incorecte
• AggregateError: furnizează o eroare care combină mai multe erori apărute

De exemplu, încercarea de a asigna o valoare unei constante pentru a doua oară generează o eroare de tip TypeError:

try{
   const num = 9;
   num = 7;
}
catch(error){
   console.log(error.name);        // TypeError
   console.log(error.message);     // Assignment to constant variable.
}

Utilizarea tipurilor de erori

La generarea erorilor, putem utiliza tipuri de erori încorporate. De exemplu:

class Person {

   constructor(name, age) {
       if (age < 0) throw new Error("Vârsta trebuie să fie pozitivă");
       this.name = name;
       this.age = age;
   }

   print() {
       console.log(`Nume: ${this.name}  Vârstă: ${this.age}`);
   }
}

try {
   const tom = new Person("Tom", -45);
   tom.print();
} catch (error) {
   console.log(error.message); // Vârsta trebuie să fie pozitivă
}

Aici, constructorul clasei Person primește valorile pentru nume și vârstă. Dacă este furnizată o vârstă negativă, se generează o eroare sub formă de obiect Error. Mesajul de eroare este transmis ca parametru în constructorul Error:

if (age < 0) throw new Error("Vârsta trebuie să fie pozitivă");

Prin urmare, la gestionarea excepției în blocul catch, vom putea obține mesajul de eroare transmis.

Toate celelalte tipuri de erori, de asemenea, primesc un mesaj de eroare ca prim parametru în constructor. Astfel, generăm câteva tipuri diferite de erori:

class Person {

   constructor(pName, pAge) {

       const age = parseInt(pAge);
       if (isNaN(age)) throw new TypeError("Vârsta trebuie să fie un număr");
       if (age < 0 || age > 120) throw new RangeError("Vârsta trebuie să fie între 0 și 120");
       this.name = pName;
       this.age = age;
   }

   print() {
       console.log(`Nume: ${this.name}  Vârstă: ${this.age}`);
   }
}

Întrucât pentru vârstă se pot furniza nu numai numere, ci și orice alt tip de valoare, la început încercăm să convertim această valoare într-un număr folosind funcția parseInt():

const age = parseInt(pAge);
if (isNaN(age)) throw new TypeError("Vârsta trebuie să fie un număr");

Cu ajutorul funcției isNaN(age), verificăm dacă numărul obținut este, de fapt, un număr. Dacă age NU este un număr, această funcție returnează true. Prin urmare, se generează o eroare de tip TypeError.

Apoi verificăm dacă numărul obținut se încadrează în intervalul permis. În caz contrar, generăm o eroare de tip RangeError:

if (age < 0 || age > 120) throw new RangeError("Vârsta trebuie să fie între 0 și 120");

Vom verifica generarea excepțiilor:

try {
   const tom = new Person("Tom", -45);
}
catch (error) {
   console.log(error.message); // Vârsta trebuie să fie între 0 și 120
}

try {
   const bob = new Person("Bob", "bla bla");
}
catch (error) {
   console.log(error.message); // Vârsta trebuie să fie un număr
}

try {
   const sam = new Person("Sam", 23);
   sam.print();    // Nume: Sam  Vârstă: 23
}
catch (error) {
   console.log(error.message);
}

Ieșire în Consolă:

Vârsta trebuie să fie între 0 și 120
Vârsta trebuie să fie un număr
Nume: Sam  Vârstă: 23

Gestionarea Mai Multor Tipuri de Erori

În timpul execuției aceluiași cod, pot apărea erori de tipuri diferite.

lass Person {

   constructor(pName, pAge) {

       const age = parseInt(pAge);
       if (isNaN(age)) throw new TypeError("Vârsta trebuie să fie un număr");
       if (age < 0 || age > 120) throw new RangeError("Vârsta trebuie să fie între 0 și 120");
       this.name = pName;
       this.age = age;
   }

   print() {
       console.log(`Nume: ${this.name}  Vârstă: ${this.age}`);
   }
}

try {
   const tom = new Person("Tom", -45);
   const bob = new Person("Bob", "bla bla");
}
catch (error) {
   if (error instanceof TypeError) {
       console.log("Tip de date incorect.");
   } else if (error instanceof RangeError) {
       console.log("Valoare incorectă");
   }
   console.log(error.message);
}

Crearea propriilor tipuri de erori

Nu suntem limitați doar la tipurile de erori încorporate și, la nevoie, putem crea propriile tipuri de erori destinate anumitor situații specifice. De exemplu:

class PersonError extends Error {
 constructor(value, ...params) {
   // restul parametrilor sunt transmiși constructorului clasei de bază
   super(...params)
   this.name = "PersonError"
   this.argument = value;
 }
}

class Person {
 constructor(pName, pAge) {
   const age = parseInt(pAge);
   if (isNaN(age)) throw new PersonError(pAge, "Vârsta trebuie să fie un număr");
   if (age < 0 || age > 120) throw new PersonError(pAge, "Vârsta trebuie să fie între 0 și 120");
   this.name = pName;
   this.age = age;
 }
 print() { console.log(`Nume: ${this.name}  Vârstă: ${this.age}`); }
}

try {
 // const tom = new Person("Tom", -45);
 const bob = new Person("Bob", "bla bla");
}
catch (error) {
 if (error instanceof PersonError) {
   console.log("Eroare de tip Person. Valoare incorectă:", error.argument);
 }
 console.log(error.message);
}

Afișare în consolă:

Eroare de tipul Person

Pentru reprezentarea erorii clasei Person, aici este definit tipul PersonError, care moștenește clasa Error:

class PersonError extends Error {
 constructor(value, ...params) {
   // restul parametrilor sunt transmiși constructorului clasei de bază
   super(...params)
   this.name = "PersonError"
   this.argument = value;
 }
}

În constructor, definim o proprietate suplimentară - argument. Aceasta va stoca valoarea care a generat eroarea. Cu ajutorul parametrului value al constructorului, obținem această valoare. În plus, suprascriem numele tipului cu ajutorul proprietății this.name.

În clasa Person, folosim acest tip, transmițând în constructorul PersonError valorile corespunzătoare:

if (isNaN(age))  throw new PersonError(age, "Vârsta trebuie să fie un număr");
if (age < 0 || age > 120) throw new PersonError(age, "Vârsta trebuie să fie între 0 și 120");

Apoi, în timpul gestionării excepției, putem verifica tipul, iar dacă acesta reprezintă clasa PersonError, putem accesa proprietatea sa argument:

catch(error){  
   if (error instanceof PersonError) {
       console.log("Eroare de tipul Person. Valoare incorectă:", error.argument);
   }
   console.log(error.message);
}