29. Knihovna cs_Util: výjimka cs_Error s parametry

Ilustrační obrázek k článku: Knihovna cs_Util: výjimka cs_Error s parametry
Vysvětlím, jak v PHP a JS vytvořit třídu výjimky, která kromě kódu nese i seznam parametrů. Tento princip využijete nejen v CombiScriptu, ale i ve svých aplikacích.

V minulém článku jsme skončili u toho, že bychom chtěli výjimky psát přibližně takto:

  1. if (...) throw new cs_Error('kod', [parametr1, parametr2, ...]);

Tento zápis funguje, protože v obou jazycích se výjimky vyvolávají přes throw, nové objekty přes new a pole se zapisují pomocí hranatých závorek.

Pro tento příkaz si potřebujeme připravit příslušné třídy v obou jazycích. Uložíme je do knihovny cs_Util. Na rozdíl od knihoven jako nm_Util, st_Util nebo ar_Util nepokrývá jeden konkrétní typ, ale tvoří jádro CombiScriptu. Chybové třídy vytvoříme jako potomky (děděním) existujících tříd, abychom mohli využít vestavěnou detekci místa chyby. Tu bychom jinak museli složitě programovat sami.

Vytvořit třídu, která rozšiřuje zabudovanou třídu Exception je v PHP docela běžná věc. Budeme postupovat zcela klasickým způsobem. A naše rozšiřující data si uložíme do privátní property $_data. V konstruktoru nezapomeneme zavolat mateřský konstruktor.

  1. class cs_Error extends Exception
  2. {
  3. private $_data = '';
  4. public function __construct($message, $data=[])
  5. {
  6. $this->_data = $data;
  7. parent::__construct($message);
  8. }
  9. public function getData()
  10. {
  11. return $this->_data;
  12. }
  13. }

I v JS může být parametrem throw objekt, který dědí ze zabudované třídy Error. Návod na rozšíření najdete přímo zde. Podle tohoto návodu budeme postupovat a vytvoříme:

  1. class cs_Error extends Error
  2. {
  3. constructor($message, $data=[])
  4. {
  5. super($message);
  6. if (Error.captureStackTrace) Error.captureStackTrace(this, cs_Error);
  7. this.data = $data;
  8. }
  9. getData()
  10. {
  11. return this.data;
  12. }
  13. }

Nadřazenou třídu voláme pomocí super. Jestliže to náš browser podporuje, tak si uložíme i celý stack chyby a to pomocí nestandardní V8 funkce captureStackTrace.

Do knihovny cs_Util patří i funkce cs_Type, která vrací typ proměnné. Protože zatím nemáme všechny potřebné typy, začneme jednoduchou, provizorní verzí:

  1. function cs_Type($var)
  2. {
  3. if ($var === null) return 'Null';
  4. if (nm_IsNumber($var)) return 'Number';
  5. //if (bl_IsBoolean($var)) return 'Boolean'; //TODO next
  6. //if (st_IsString($var)) return 'String';
  7. //if (ar_IsArray($var)) return 'Array';
  8. return 'Unknown';
  9. }

Zatím si jen připravíme detekci dalších typů. Finální verze funkce cs_Type ale bude jiná - umožní nám registrovat i uživatelské typy. K tomu se dostaneme později.

Naše knihovna cs_Util tedy zatím nějak provizorně vypadá takto:

cs_Util.php.js
  1. <!-- --><?php /*
  2. "use strict";
  3. class cs_Error extends Error
  4. {
  5. constructor($message, $data=[])
  6. {
  7. super($message);
  8. if (Error.captureStackTrace) Error.captureStackTrace(this, cs_Error);
  9. this.data = $data;
  10. }
  11. getData()
  12. {
  13. return this.data;
  14. }
  15. }
  16. /*/
  17. class cs_Error extends Exception
  18. {
  19. private $_data = '';
  20. public function __construct($message, $data=[])
  21. {
  22. $this->_data = $data;
  23. parent::__construct($message);
  24. }
  25. public function getData()
  26. {
  27. return $this->_data;
  28. }
  29. }
  30. //*/
  32. function cs_Type($var)
  33. {
  34. if ($var === null) return 'Null';
  35. if (nm_IsNumber($var)) return 'Number';
  36. //if (bl_IsBoolean($var)) return 'Boolean'; //TODO next
  37. //if (st_IsString($var)) return 'String';
  38. //if (ar_IsArray($var)) return 'Array';
  39. return 'Unknown';
  40. }

Nyní už tedy můžeme začít používat výjimky v našich funkcích. V příštím článku se vrátíme ke knihovně nm_Util.

Předchozí