Vlastní chyby, rozšíření třídy Error

Když nÄ›co vyvíjíme, často potÅ™ebujeme, aby naÅ¡e vlastní chybové třídy odrážely specifické záležitosti, které se v naÅ¡ich úlohách mohou pokazit. Pro chyby v síťových operacích můžeme potÅ™ebovat třídu ChybaHttp, pro databázové operace ChybaDb, pro operace hledání ChybaNenalezeno a tak dále.

NaÅ¡e chyby by mÄ›ly podporovat základní vlastnosti chyb jako message, name a pokud možno stack. Mohou vÅ¡ak mít i jiné, své vlastní vlastnosti, napÅ™. objekty třídy ChybaHttp mohou mít vlastnost stavovýKód s hodnotami jako 404 nebo 403 nebo 500.

JavaScript nám umožňuje používat throw s libovolným argumentem, takže technicky naÅ¡e vlastní chybové třídy nemusejí dÄ›dit ze třídy Error. Pokud z ní vÅ¡ak dÄ›díme, bude možné k identifikaci chybových objektů používat obj instanceof Error. Je tedy lepší z ní dÄ›dit.

Když aplikace poroste, naÅ¡e vlastní chyby budou tvoÅ™it pÅ™irozenou hierarchii. Například ChybaHttpTimeout může dÄ›dit z ChybaHttp a tak dále.

Rozšiřování třídy Error

Jako příklad uvažujme funkci načtiUživatele(json), která by mÄ›la načíst JSON s uživatelskými daty.

Zde je příklad, jak může vypadat platný json:

let json = `{ "jméno": "Jan", "věk": 30 }`;

UvnitÅ™ použijeme JSON.parse. Jestliže obdrží poÅ¡kozený json, vyvolá SyntaxError. Ale i když je json syntakticky správnÄ›, neznamená to, že obsahuje platného uživatele, že? Mohou v nÄ›m chybÄ›t nezbytná data. Například nemusí obsahovat vlastnosti jméno a věk, které jsou pro naÅ¡e uživatele nezbytné.

NaÅ¡e funkce načtiUživatele(json) tedy nebude jenom načítat JSON, ale také ověřovat („validovat“) data. Pokud v nich nebudou požadovaná pole nebo formát nebude správný, nastane chyba. A nebude to SyntaxError, protože data jsou syntakticky správnÄ›, ale chyba jiného druhu. Nazveme ji ChybaValidace a vytvoříme pro ni třídu. Chyba tohoto druhu by mÄ›la obsahovat také informaci o vadném poli.

NaÅ¡e třída ChybaValidace by mÄ›la být zdÄ›dÄ›na ze třídy Error.

Třída Error je vestavÄ›ná, ale uvedeme její pÅ™ibližný kód, abychom porozumÄ›li tomu, co rozÅ¡iÅ™ujeme:

// „Pseudokód“ pro vestavěnou třídu Error definovanou samotným JavaScriptem
class Error {
  constructor(zpráva) {
    this.message = zpráva;
    this.name = "Error"; // (různé názvy pro různé vestavěné chybové třídy)
    this.stack = <zásobník volání>; // nestandardní, ale většina prostředí jej podporuje
  }
}

Nyní z ní zděďme třídu ChybaValidace a vyzkouÅ¡ejme ji v akci:

class ChybaValidace extends Error {
  constructor(zpráva) {
    super(zpráva); // (1)
    this.name = "ChybaValidace"; // (2)
  }
}

function test() {
  throw new ChybaValidace("Ouha!");
}

try {
  test();
} catch(err) {
  alert(err.message); // Ouha!
  alert(err.name); // ChybaValidace
  alert(err.stack); // seznam vnořených volání s číslem řádku u každého
}

Prosíme vÅ¡imnÄ›te si: na řádku (1) zavoláme rodičovský konstruktor. JavaScript vyžaduje, abychom v konstruktoru dítÄ›te volali super, takže to je povinné. Rodičovský konstruktor nastaví vlastnost message.

Rodičovský konstruktor také nastaví vlastnost name na "Error", takže ji na řádku (2) pÅ™enastavíme na správnou hodnotu.

Použijme chybu v metodÄ› načtiUživatele(json):

class ChybaValidace extends Error {
  constructor(zpráva) {
    super(zpráva);
    this.name = "ChybaValidace";
  }
}

// Použití
function načtiUživatele(json) {
  let uživatel = JSON.parse(json);

  if (!uživatel.věk) {
    throw new ChybaValidace("Chybí pole: věk");
  }
  if (!uživatel.name) {
    throw new ChybaValidace("Chybí pole: jméno");
  }

  return uživatel;
}

// Příklad fungování s try..catch

try {
  let uživatel = načtiUživatele('{ "věk": 25 }');
} catch (chyba) {
  if (chyba instanceof ChybaValidace) {
    alert("Vadná data: " + chyba.message); // Vadná data: Chybí pole: jméno
  } else if (chyba instanceof SyntaxError) { // (*)
    alert("Syntaktická chyba JSONu: " + chyba.message);
  } else {
    throw chyba; // neznámá chyba, vyvoláme ji znovu (**)
  }
}

V uvedeném kódu blok try..catch oÅ¡etÅ™uje jak naÅ¡i chybu ChybaValidace, tak vestavÄ›nou chybu SyntaxError z JSON.parse.

Prosíme podívejte se, jak na řádku (*) používáme instanceof k ověřování specifického typu chyby.

Můžeme se podívat i do chyba.name, například:

// ...
// namísto (chyba instanceof SyntaxError)
} else if (chyba.name == "SyntaxError") { // (*)
// ...

Verze s instanceof je vÅ¡ak mnohem lepší, protože v budoucnu se chystáme třídu ChybaValidace rozÅ¡iÅ™ovat, vytvářet její podtypy, napÅ™. ChybaPožadovanéVlastnosti. A ověření pomocí instanceof bude fungovat i pro novÄ› zdÄ›dÄ›né třídy. Je tedy dopÅ™ednÄ› kompatibilní.

Je také důležité, že pokud catch zachytí neznámou chybu, na řádku (**) ji opÄ›tovnÄ› vyvolá. Blok catch umí oÅ¡etÅ™it jen validační a syntaktické chyby, ostatní druhy chyb (způsobené pÅ™eklepem v kódu nebo jinými neznámými příčinami) by mÄ›ly vypadnout výš.

Budoucí dědičnost

Třída ChybaValidace je velmi obecná. Pokazit se může spousta vÄ›cí. Vlastnost může chybÄ›t nebo může být v nesprávném formátu (například Å™etÄ›zcová hodnota místo čísla u vlastnosti věk). VytvoÅ™me tedy konkrétnÄ›jší třídu ChybaPožadovanéVlastnosti, která bude sloužit výhradnÄ› pro případy chybÄ›jících vlastností. Bude obsahovat další informace o vlastnosti, která chybí.

class ChybaValidace extends Error {
  constructor(zpráva) {
    super(zpráva);
    this.name = "ChybaValidace";
  }
}

class ChybaPožadovanéVlastnosti extends ChybaValidace {
  constructor(vlastnost) {
    super("Chybí vlastnost: " + vlastnost);
    this.name = "ChybaPožadovanéVlastnosti";
    this.vlastnost = vlastnost;
  }
}

// Použití
function načtiUživatele(json) {
  let uživatel = JSON.parse(json);

  if (!uživatel.věk) {
    throw new ChybaPožadovanéVlastnosti("věk");
  }
  if (!uživatel.jméno) {
    throw new ChybaPožadovanéVlastnosti("jméno");
  }

  return uživatel;
}

// Příklad fungování s try..catch

try {
  let uživatel = načtiUživatele('{ "věk": 25 }');
} catch (chyba) {
  if (chyba instanceof ChybaValidace) {
    alert("Vadná data: " + chyba.message); // Vadná data: Chybí vlastnost: jméno
    alert(chyba.name); // ChybaPožadovanéVlastnosti
    alert(chyba.vlastnost); // jméno
  } else if (chyba instanceof SyntaxError) {
    alert("Syntaktická chyba JSONu: " + chyba.message);
  } else {
    throw chyba; // neznámá chyba, vyvoláme ji znovu
  }
}

Používání nové třídy ChybaPožadovanéVlastnosti je snadné: postačí pÅ™edat název vlastnosti: new ChybaPožadovanéVlastnosti(vlastnost). Konstruktor vygeneruje človÄ›kem čitelnou zprávu message.

Prosíme vÅ¡imnÄ›te si, že this.name v konstruktoru ChybaPožadovanéVlastnosti se opÄ›t pÅ™iÅ™azuje ručnÄ›. To může být ponÄ›kud úmorné – pÅ™iÅ™azovat this.name = <název třídy> v každé vlastní chybové třídÄ›. Můžeme se tomu vyhnout, když si vytvoříme vlastní „základní chybovou“ třídu, která bude pÅ™iÅ™azovat this.name = this.constructor.name, a pak budeme vÅ¡echny naÅ¡e chyby dÄ›dit z ní.

NazvÄ›me ji MojeChyba.

Zde je kód s třídou MojeChyba a dalšími vlastními chybovými třídami, zjednoduÅ¡enÄ›:

class MojeChyba extends Error {
  constructor(zpráva) {
    super(zpráva);
    this.name = this.constructor.name;
  }
}

class ChybaValidace extends MojeChyba { }

class ChybaPožadovanéVlastnosti extends ChybaValidace {
  constructor(vlastnost) {
    super("Chybí vlastnost: " + vlastnost);
    this.vlastnost = vlastnost;
  }
}

// název je správně
alert( new ChybaPožadovanéVlastnosti("pole").name ); // ChybaPožadovanéVlastnosti

Nyní jsou naÅ¡e chyby, konkrétnÄ› ChybaValidace, mnohem kratší, jelikož jsme se zbavili řádku "this.name = ..." v konstruktoru.

Obalování výjimek

Účelem funkce načtiUživatele v uvedeném kódu je „načíst uživatelská data“. PÅ™i tomto procesu mohou nastat chyby různých druhů. MomentálnÄ› máme SyntaxError a ChybaValidace, ale v budoucnu se funkce načtiUživatele může rozrůst a pravdÄ›podobnÄ› bude generovat chyby dalších druhů.

Tyto chyby by mÄ›l oÅ¡etÅ™ovat kód, který funkci načtiUživatele volá. MomentálnÄ› používá v bloku catch nÄ›kolik příkazů if, které prozkoumají třídu, oÅ¡etří známé chyby a opÄ›tovnÄ› vyvolají neznámé.

Schéma je následující:

try {
  ...
  načtiUživatele()  // potenciální zdroj chyb
  ...
} catch (chyba) {
  if (chyba instanceof ChybaValidace) {
    // ošetření validačních chyb
  } else if (chyba instanceof SyntaxError) {
    // ošetření syntaktických chyb
  } else {
    throw chyba; // neznámá chyba, vyvoláme ji znovu
  }
}

V uvedeném kódu vidíme dva typy chyb, ale může jich tam být víc.

Jestliže funkce načtiUživatele generuje chyby nÄ›kolika druhů, mÄ›li bychom se zeptat sami sebe: opravdu chceme pokaždé ověřovat vÅ¡echny typy chyb jeden po druhém?

Odpověď často zní „ne“: chtěli bychom být „o úroveň výš nad tím vším“. Chceme vědět jen to, zda to byla „chyba načítání dat“ – proč přesně se stala, je často nepodstatné (popisuje to chybová zpráva). Nebo ještě lepší by bylo, kdybychom měli způsob, jak získat podrobnosti o chybě, ale jen když je budeme potřebovat.

Technika, kterou tady popisujeme, se nazývá „obalování (wrapping) výjimek“.

1. Vytvoříme novou třídu ChybaČtení, která bude pÅ™edstavovat obecnou chybu „čtení dat“.
2. Funkce načtiUživatele bude zachytávat chyby načítání dat, které nastanou uvnitÅ™ ní, napÅ™. ChybaValidace a SyntaxError, a místo nich generovat chybu ChybaČtení.
3. Objekt ChybaČtení si ve své vlastnosti příčina bude udržovat odkaz na původní chybu.

Pak kód, který volá funkci načtiUživatele, bude muset ověřovat jen chybu ChybaČtení, ne každý druh chyby načítání dat. A pokud bude potÅ™ebovat podrobnosti o chybÄ›, může se podívat na vlastnost příčina.

Zde je kód, který definuje ChybaČtení a demonstruje její použití ve funkci načtiUživatele a try..catch:

class ChybaČtení extends Error {
  constructor(zpráva, příčina) {
    super(zpráva);
    this.příčina = příčina;
    this.name = 'ChybaČtení';
  }
}

class ChybaValidace extends Error { /*...*/ }
class ChybaPožadovanéVlastnosti extends ChybaValidace { /* ... */ }

function validujUživatele(uživatel) {
  if (!uživatel.věk) {
    throw new ChybaPožadovanéVlastnosti("věk");
  }

  if (!uživatel.jméno) {
    throw new ChybaPožadovanéVlastnosti("jméno");
  }
}

function načtiUživatele(json) {
  let uživatel;

  try {
    uživatel = JSON.parse(json);
  } catch (chyba) {
    if (chyba instanceof SyntaxError) {
      throw new ChybaČtení("Syntaktická chyba", chyba);
    } else {
      throw chyba;
    }
  }

  try {
    validujUživatele(uživatel);
  } catch (chyba) {
    if (chyba instanceof ChybaValidace) {
      throw new ChybaČtení("Chyba validace", chyba);
    } else {
      throw chyba;
    }
  }

}

try {
  načtiUživatele('{špatný json}');
} catch (e) {
  if (e instanceof ChybaČtení) {
    alert(e);
    // Původní chyba: SyntaxError: Unexpected token š in JSON at position 1
    alert("Původní chyba: " + e.příčina);
  } else {
    throw e;
  }
}

V uvedeném kódu načtiUživatele funguje pÅ™esnÄ› tak, jak jsme popsali – zachytává syntaktické a validační chyby a místo nich vyvolává chyby ChybaČtení (neznámé chyby se vyvolávají znovu jako obvykle).

VnÄ›jší kód si tedy ověří instanceof ChybaČtení a to je vÅ¡e. Není tÅ™eba vyjmenovávat vÅ¡echny možné typy chyb.

Tento přístup se nazývá „obalování (wrapping) výjimek“, protože pÅ™ejímáme výjimky „nižší úrovně“ a „obalujeme“ (anglicky „wrap“) je do výjimky ChybaČtení, která je abstraktnÄ›jší. V objektovÄ› orientovaném programování se zeÅ¡iroka používá.

Shrnutí

• Ze třídy Error a jiných vestavÄ›ných tříd můžeme dÄ›dit běžným způsobem. Jen se musíme postarat o vlastnost name a nesmíme zapomenout volat super.
• K ověření chyb určitého druhu můžeme použít instanceof. Ten funguje i s dÄ›dičností. NÄ›kdy vÅ¡ak máme chybový objekt pocházející z knihovny tÅ™etí strany a neexistuje žádný snadný způsob, jak získat jeho třídu. Pak můžeme pro taková ověření použít vlastnost name.
• Å iroce používaná technika je obalování výjimek: funkce oÅ¡etří výjimky nižší úrovnÄ› a namísto různých chyb nižší úrovnÄ› vyvolá chybu vyšší úrovnÄ›. Výjimky nižší úrovnÄ› se nÄ›kdy stávají jejími vlastnostmi, například chyba.příčina v uvedených příkladech, ale to není striktnÄ› vyžadováno.