Hibák testreszabása a csomópontban.js

a Javascript beépített Error hasznos információkat nyújt, de gyakran úgy érzi, hiányzik az egyértelműség. Az egy mindenki számára megfelelő nagyszerű a nyelv számára, de a saját alkalmazásainkban jobban teljesíthetünk. Itt jönnek be az egyéni hibák.

lehet, hogy egyéni hibákat látott a csomópont használatakor.js. A csomópont beépített hibatípusai, mint például AssertionError, RangeError, ReferenceError, SyntaxError, és SystemError a natív Error osztály összes kiterjesztése.

a Error használata alapként megadja a Javascript megvalósításának minden erejét, plusz további előnyöket. Itt csak néhány:

• egyéni hibaüzenet formátumok.
• további tulajdonságok a Hibaobjektumon.
• nevű hibák a hibakeresés és a feltételes hibakezelés megkönnyítésére.
• következetes hibák a könyvtárhasználók számára.

a Hibaosztály kiterjesztése

az induláshoz használjunk egy általános példát. Kiterjesztjük a Error osztályt, és a super használatával örököljük annak funkcióit.

class CustomError extends Error { constructor(...params) { super(...params) // We're spreading `params` as a way to bring all of `Error`'s functionality in. }}

Most, amikor throwegy hiba, akkor ezt a throw new CustomError("Something went wrong..."). Azt is lehetővé teszi, hogy ellenőrizze a hibákat a típushoz képest:

try { throw new CustomError("Something went wrong")} catch (error) { if (error instance of CustomError) { // do something specifically for that type of error }}

ez önmagában nem sokat jelent, azon kívül, hogy új hibatípust ad a híváshoz és az ellenőrzéshez. Ahhoz, hogy jobban megértsük, mit lehet tenni, nézzük meg, mi jön szabvány Error.

• Error.name
• Hiba.üzenet
• hiba.prototípus.toString ()
• hiba.prototípus.Kivitelező()

nem sok munka van ott? A konstruktoron és a toString metóduson kívül a hiba neve és a hibát leíró üzenet az egyetlen rész, amelyet valószínűleg használni fogunk. A fenti példában a message értéket úgy állítjuk be, hogy a hiba példányosításakor a “valami rosszul ment” argumentumot adjuk át.

szerencsére a legtöbb javascript platform, mint a böngésző és a Node.a js hozzáadta saját módszereit és tulajdonságait a felsoroltak tetejére. A V8 Hibajavításának néhány aspektusára összpontosítunk, a Javascript motor, amely a Chrome-ot és a Node-ot táplálja.js.

a két érdeklődési terület stack és captureStackTrace. Ahogy a nevük is sugallja, lehetővé teszik a verem nyomának felszínét. Lássuk, hogy néz ki egy példa.

class CustomError extends Error { constructor(...args) { super(...args) if (Error.captureStackTrace) { Error.captureStackTrace(this, CustomError) } this.name = "Our Custom Error" }}try { throw new CustomError("Something went wrong")} catch (err) { console.error(err.stack)}

ebben a példában az Error.captureStackTrace – et hívjuk, ha a platform támogatja, annak biztosítása érdekében, hogy az egyéni hibához teljes nyomkövetés kerüljön hozzáadásra. Ezután throw a hiba a try blokkból származik, amely átadja az irányítást a catch blokknak.

ha a fenti kódot futtatja, látni fogja, hogy a stack első sora a hiba nameés message.

Our Custom Error: Something went wrong

ez a hiba nem túl “mély”, így a verem többnyire csomópont.js belső. Minden sor a verem egy “kerete”. Ezek részleteket tartalmaznak a hiba helyéről a kódbázison belül.

most, hogy tudjuk, hogyan kell egyéni hibát létrehozni és hívni, tegyük hasznossá.

a Hibatartalom testreszabása

az egyéni hiba, amellyel dolgoztunk, rendben van, de változtassuk meg, hogy hasznosabb legyen. Az osztály CircuitErrorlesz. Fogjuk használni, hogy az egyéni hibák érkező megszakító. Ha nem ismeri a mintát, az rendben van. A megszakító megvalósításának részletei nem fontosak. Fontos, hogy bizonyos információkat továbbíthassunk a hibába, és ez az információt bemutatja a felhasználónak.

a megszakítónak van egy “nyitott” állapota, amely nem engedi, hogy rögzített ideig bármi áthaladjon rajta. Állítsuk be a CircuitError értéket úgy, hogy tartalmazzon néhány olyan részletet, amely hasznos lehet azoknak a függvényeknek, amelyek megkapják, ha az állapot OPEN.

class CircuitError extends Error { // 1 constructor(state, nextAttempt, ...params) { super(...params) if (Error.captureStackTrace) { Error.captureStackTrace(this, CircuitError) } this.name = "CircuitError" this.state = state // 2 this.message = `The Circuit is ${state}.` // 3 if (nextAttempt) { this.timestamp = Date.now() this.nextAttempt = nextAttempt this.message += ` Next attempt can be made in ${this.nextAttempt - this.timestamp}ms.` } }}

frissített hibánk néhány új dolgot tesz, mindezt a konstruktoron belül. Az átadott argumentumok megváltoztak (1), hogy tartalmazzák a megszakító state – jét, valamint egy nextAttempt időbélyeget, amely jelzi, hogy a megszakító mikor kezdi újra a kéréseket.

ezután beállít néhány új tulajdonságot, és frissíti az üzenetet a bemutatott értékektől függően. Tesztelhetjük a hiba új verziójának dobásával.

try { throw new CircuitError("OPEN", Date.now() + 8000)} catch (err) { console.error(err)}

Most, amikor eldobjuk a hibát, az állapot az első argumentum, az időbélyeg pedig a második. Erre a demóra a jövőben 8000 milliszekundummal haladunk az időben. Figyeljük meg, hogy mi is naplózás a hiba maga, nem csak a verem.

a kód futtatása a következőket eredményezi:

CircuitError : The Circuit is OPEN. Next attempt can be made in 6000ms. at Object.<anonymous> (/example.js:21:9) at Module._compile (internal/modules/cjs/loader.js:1063:30) at Object.Module._extensions..js (internal/modules/cjs/loader.js:1103:10) at Module.load (internal/modules/cjs/loader.js:914:32) at Function.Module._load (internal/modules/cjs/loader.js:822:14) at Function.Module.runMain (internal/modules/cjs/loader.js:1143:12) at internal/main/run_main_module.js:16:11 { name: 'Circuit Error', state: 'OPEN', message: 'The Circuit is OPEN. Next attempt can be made in 6000ms.', timestamp: 1580242308919, nextAttempt: 1580242314919}

az eredmény a hiba neve, amelyet az első sorban szereplő üzenet követ. Aztán megvan a verem többi része, majd az összes tulajdonság, amelyet a CircuitError – ben állítottunk be. Ennek a hibának a fogyasztói felhasználhatják ezeket az adatokat a hibára való reagálásra. Például:

try { throw new CircuitError("OPEN", Date.now() + 8000)} catch (err) { customLogger(err) if (err.state === "OPEN") { handleOpenState(err.nextAttempt) }}

általános hiba helyett most van valami, amely jobban megfelel alkalmazásunk igényeinek.

reagálás a hibákra

az egyéni hibák nagyszerű módja a hibákra való reagálásnak. Gyakori feltételezni, hogy minden hiba váratlan, de hasznos hibák biztosításával megkönnyítheti létezésük kezelését. Az egyedi hibák felhasználásával nemcsak értékes adatokat tudunk biztosítani alkalmazásaink felhasználóinak, hanem azt is bemutatjuk, hogy képesek vagyunk válaszolni a hibatípusokra a instance of feltételen keresztül.

a Bearernél egyedi hibákat használunk a válaszok szabványosításához a kódunkban, csak a szükséges információkat adjuk meg ügyfelünknél, és hibáinkat cselekvhetővé tesszük.

hogyan használ egyéni hibákat az alkalmazásokban? Lépjen kapcsolatba velünk @BearerSH és tudassa velünk.