ce este o eroare de programare?

lucrurile nu merg întotdeauna bine în programele noastre.în special, există situații în care este posibil să dorim să oprim programul sau să informăm utilizatorul dacă se întâmplă ceva rău.

de exemplu:

  • programul a încercat să deschidă un fișier inexistent.
  • conexiunea la rețea este întreruptă.
  • utilizatorul a introdus o intrare nevalidă.,în toate aceste cazuri noi, ca programatori, creăm erori sau lăsăm motorul de programare să creeze unele pentru noi.

    după crearea erorii putem informa utilizatorul cu un mesaj sau putem opri execuția cu totul.

    ce este o eroare în JavaScript?

    o eroare în JavaScript este un obiect, care este ulterior aruncat pentru a opri programul.

    pentru a crea o nouă eroare în JavaScript, numim funcția constructor corespunzătoare., De exemplu, pentru a crea un nou, eroare generic putem face:

    const err = new Error("Something bad happened!");

    atunci Când se creează un obiect de eroare este, de asemenea, posibil să se omită new cuvinte cheie:

    const err = Error("Something bad happened!");

    după ce a creat, la eroare obiectul prezintă trei proprietăți:

    • message: un șir de caractere cu un mesaj de eroare.
    • name: tipul erorii.
    • stack: o urmă stivă de execuție funcții.,

    De exemplu, dacă vom crea o nouă TypeError obiect cu mesaj adecvat, message va efectua eroarea reală șir, în timp ce name va fi "TypeError":

    Firefox implementează, de asemenea, o grămadă pe non-standard proprietate ca columnNumber, filename și lineNumber.,

    Many types of errors in JavaScript

    There are many types of errors in JavaScript, namely:

    • Error
    • EvalError
    • InternalError
    • RangeError
    • ReferenceError
    • SyntaxError
    • TypeError
    • URIError

    Remember, all these error types are actual constructor functions meant to return a new error object.,

    în codul dvs. veți folosi mai ales Error și TypeError, două dintre cele mai comune tipuri, pentru a crea propriul obiect de eroare.

    de cele Mai multe ori, majoritatea erorilor va veni direct de la motor JavaScript, cum ar fi InternalError sau SyntaxError., 

    va x = '33';// SyntaxError: Unexpected identifier

    Sau când utilizați cuvinte cheie rezervate în locuri nepotrivite, cum ar fi await in afara de un async funcția:

    function wrong(){ await 99;}wrong();// SyntaxError: await is only valid in async function

    un Alt exemplu de TypeError apare atunci când vom selecta inexistente elemente HTML în pagina:

    Uncaught TypeError: button is null

    În plus față de aceste tradițional de eroare obiecte, un AggregateError obiect este de gând să aterizeze în curând în JavaScript., AggregateError este convenabil pentru împachetarea mai multor erori împreună, așa cum vom vedea mai târziu.pe langa aceste erori incorporate, in browser putem gasi si:

    • DOMException.
    • DOMError, învechit și nu mai este utilizat astăzi.

    DOMException este o familie de erori legate de API-uri Web., Ele sunt aruncate atunci când facem lucruri stupide în browser-ul, cum ar fi:

    document.body.appendChild(document.cloneNode(true));

    rezultat:

    Uncaught DOMException: Node.appendChild: May not add a Document as a child

    Pentru o listă completă a vedea această pagină pe MDN.

    ce este o excepție?

    majoritatea dezvoltatorilor cred că eroarea și excepțiile sunt același lucru. În realitate, un obiect de eroare devine o excepție numai atunci când este aruncat.,

    Pentru a arunca o excepție în JavaScript vom folosi throw, urmat de eroare obiect:

    const wrongType = TypeError("Wrong type given, expected number");throw wrongType;

    forma scurtă este mai frecvent, în cele mai multe cod baze veți găsi:

    throw TypeError("Wrong type given, expected number");

    sau

    throw new TypeError("Wrong type given, expected number");

    este puțin probabil pentru a arunca excepții, în afara de o funcție sau o condiționată de bloc. În schimb, luați în considerare următorul exemplu:

    aici verificăm dacă argumentul funcției este un șir., Dacă nu este vom arunca o excepție.

    din punct de vedere Tehnic, ai putea arunca ceva în JavaScript, nu numai de eroare obiecte:

    throw Symbol();throw 33;throw "Error!";throw null;

    cu toate Acestea, este mai bine pentru a evita aceste lucruri: arunca mereu corectă eroare de obiecte, nu primitive.

    procedând astfel, vă păstrați eroare de manipulare consecventă prin codebase. Alți membri ai echipei se pot aștepta întotdeauna să acceseze error.messagesau error.stack pe obiectul de eroare.

    ce se întâmplă când aruncăm o excepție?,

    excepțiile sunt ca un lift care urcă: odată ce arunci unul, acesta se bulează în stiva programului, cu excepția cazului în care este prins undeva.

    luați în considerare următorul cod:

    dacă rulați acest cod într-un browser sau într-un nod.js, programul se oprește și raportează eroarea:

    în plus, puteți vedea linia exactă în care sa produs eroarea.

    Acest raport este o urmărire a stivei și este util pentru depistarea problemelor din codul tău.

    trasarea stivei merge de jos în sus., Deci, aici:

     toUppercase http://localhost:5000/index.js:3 <anonymous> http://localhost:5000/index.js:9

    putem spune:

    • ceva în programul de la linia de 9 m-a sunat toUppercase
    • toUppercase explodat la linia 3

    În plus față de a vedea acest stack trace-ul în browser-ul consola, puteți accesa pe stack proprietatea de eroare obiect.dacă excepția nu este luată, adică programatorul nu face nimic pentru ao prinde, programul se va prăbuși.,

    când și unde capturați o excepție în codul dvs. depinde de cazul de utilizare specific.de exemplu, poate doriți să propagați o excepție în stivă pentru a bloca programul cu totul. Acest lucru s-ar putea întâmpla pentru erori fatale, atunci când este mai sigur să opriți programul decât să lucrați cu date nevalide.

    după ce am introdus elementele de bază, să ne îndreptăm atenția asupra manipulării erorilor și a excepțiilor atât în codul JavaScript sincron, cât și asincron.

    manipularea erorilor sincrone

    Codul sincron este de cele mai multe ori simplu, și astfel manipularea erorilor sale.,

    manipularea erorilor pentru funcțiile obișnuite

    Codul sincron este executat în aceeași ordine în care este scris. Să luăm din nou exemplul anterior:

    aici motorul apelează și executătoUppercase. Totul se întâmplă sincron. Pentru a prinde o excepție originare de astfel de sincron funcția putem folosi try/catch/finally:

    try { toUppercase(4);} catch (error) { console.error(error.message); // or log remotely} finally { // clean up}

    de Obicei, try oferte cu happy calea, sau cu apel de funcție care ar putea arunca.,

    catch în schimb, surprinde excepția reală. Acesta primește obiectul de eroare, pe care îl putem inspecta (și trimite de la distanță la un logger în producție).

    finally declarație pe de altă parte se execută indiferent de funcția rezultat: dacă a reușit sau nu a reușit, nici în codul finally va rula.

    amintiți-vă: try/catch/finally este un construct sincron: are acum Mod de a prinde excepții provenind din Codul asincron.,

    gestionarea erorilor pentru funcțiile generatorului

    o funcție generator în JavaScript este un tip special de funcție.acesta poate fi întrerupt și reluat după bunul plac, în afară de furnizarea unui canal de comunicare bidirecțional între domeniul său interior și consumator.,

    Pentru a crea un generator de funcții-am pus o stea * dupa function cuvinte cheie:

    function* generate() {//}

    Odată ce în interiorul funcția putem folosi yield pentru a reveni la valorile:

    function* generate() { yield 33; yield 99;}

    valoarea returnată dintr-un generator de funcție este un obiect iterator. Pentru a trage valorile un generator putem folosi două metode:

    • de asteptare next() pe obiect iterator.,
    • iterație cu for...of.

    Dacă luăm exemplul nostru, pentru a obține valori de la generator putem face:

    function* generate() { yield 33; yield 99;}const go = generate();

    Aici go devine obiect iterator, atunci când numim generator de funcție.

    De acum ne putem numi go.next() pentru a avansa executie:

    function* generate() { yield 33; yield 99;}const go = generate();const firstStep = go.next().value; // 33const secondStep = go.next().value; // 99

    Generatoare, de asemenea, funcționează invers: ei pot accepta valori și excepții de la abonat.,

    În plus față de next(), obiecte iterator întors de la generatoarele au un throw() metoda.

    Cu această metodă putem opri program prin injectarea de o excepție de la generator:

    Pentru a prinde o astfel de eroare ar wrap cod în interiorul generatorului cu try/catch (și finally dacă este necesar):

    function* generate() { try { yield 33; yield 99; } catch (error) { console.error(error.message); }}

    Generator de funcții poate arunca, de asemenea, excepții de la exterior., Mecanismul de capturare a acestor excepții este același pentru captarea excepțiilor sincrone: try/catch/finally.

    Aici e un exemplu de generator de funcție consumat din exterior cu for...of:

    Aici vom repeta fericit calea în interiorul unui try bloc. Dacă apar excepții, îl oprim cu catch.

    manipularea erorilor asincrone

    JavaScript este Sincron prin natura sa, fiind un limbaj cu un singur fir.,mediile gazdă, cum ar fi motoarele de browsere, măresc JavaScript cu un număr de API Web pentru interacțiunea cu sistemele externe și pentru a face față operațiunilor legate de I/O.exemple de asincronitate în browser sunt timeout-uri, evenimente, Promise.manipularea erorilor în lumea asincronă este diferită de omologul său sincron.

    Să vedem câteva exemple.

    Eroare de manipulare pentru cronometre

    la începutul explorărilor cu JavaScript, după ce a aflat despre try/catch/finally, ai putea fi tentat să-l pună în jurul valorii de orice bloc de cod.,

    luați în Considerare următorul fragment:

    function failAfterOneSecond() { setTimeout(() => { throw Error("Something went wrong!"); }, 1000);}

    Această funcție aruncă după aproximativ 1 secundă. Care este modul corect de a gestiona această excepție?

    următorul exemplu nu funcționează:

    așa cum am spus, try/catch este Sincron. Pe de altă parte, avem setTimeout, un API de browser pentru cronometre.

    până când apelul a trecut la setTimeout rulează, try/catch a dispărut de mult. Programul se va prăbuși pentru că nu am reușit să capturăm excepția.,

    Au călătorit pe două trasee diferite:

    Track A: --> try/catchTrack B: --> setTimeout --> callback --> throw

    Dacă nu vrem să se prăbușească programul, să se ocupe de eroare corect trebuie să ne mișcăm try/catch în interiorul callback for setTimeout.

    dar, această abordare nu are prea mult sens de cele mai multe ori. După cum vom vedea mai târziu, manipularea erorilor asincrone cu promisiuni oferă o ergonomie mai bună.,

    manipularea erorilor pentru evenimente

    nodurile HTML din modelul obiectului documentului sunt conectate laEventTarget, strămoșul comun pentru orice emițător de evenimente din browser.asta înseamnă că putem asculta evenimente pe orice element HTML din pagină.

    (nod.js va sprijini EventTarget într-o versiune viitoare).

    mecanica de manipulare a erorilor pentru evenimentele DOM urmează aceeași schemă a oricărui API Web asincron.

    luați în considerare următorul exemplu:

    aici aruncăm o excepție imediat ce faceți clic pe buton. Cum îl prindem?, Acest model nu funcționează, și nu va împiedica programul de crashing:

    la fel Ca exemplul anterior cu setTimeout, orice apel invers trecut la addEventListener se execută asincron:

    Track A: --> try/catchTrack B: --> addEventListener --> callback --> throw

    Dacă nu vrem să se prăbușească în program, să se ocupe de eroare corect trebuie să ne mișcăm try/catch în interiorul callback for addEventListener.

    dar, din nou, nu există prea multă valoare în a face acest lucru.,

    cu setTimeout, excepție aruncată de un cod asincron cale sunt neprins din exterior, și se va prăbuși programul tău.

    în secțiunile următoare vom vedea cum promisiunile și async/await pot ușura gestionarea erorilor pentru codul asincron.

    ce zici de onerror?

    HTML elemente au o serie de stivuitoare eveniment ca onclick, onmouseenter, onchange pentru a numi doar câteva.

    Există, de asemenea, onerror, dar nu are nimic de-a face cu throw și prieteni.,

    onerror event handler incendii orice moment un element HTML ca un <img> tag-ul sau un <script> lovește un non-existent de resurse.,b4″>

// omitted<body><img src="https://www.valentinog.com/blog/error/nowhere-to-be-found.png" alt="So empty!"></body>// omitted

atunci Când vizitează un document HTML cu o lipsă sau non-existente de resurse browser-ul consola înregistrările de eroare:

GET http://localhost:5000/https://www.valentinog.com/blog/error/nowhere-to-be-found.png

În JavaScript avem șansa de a „prinde” aceasta eroare adecvate de tratare a evenimentului:

const image = document.querySelector("img");image.onerror = function(event) { console.log(event);};

Sau mai bine:

const image = document.querySelector("img");image.addEventListener("error", function(event) { console.log(event);});

Acest model este util pentru încărcare resurse alternative în loc de imagini lipsă sau script-uri.,

Dar amintiți-vă: onerror, nu are nimic de-a face cu throw sau try/catch.

eroare de manipulare cu promisiunea

pentru a ilustra eroare de manipulare cu promisiunea vom „promite” unul dintre exemplele noastre originale. Am tweak următoarea funcție:

în Loc de a se întoarce un șir de simplu, sau o excepție, vom folosi respectiv Promise.reject și Promise.resolve să se ocupe de eroare și de succes:

(din punct de vedere Tehnic nu e nimic asincron în acest cod, dar servește bine pentru a ilustra acest punct de vedere).,

Acum că funcția este „promisified” putem atașa then pentru a consuma urmare, și catch pentru manipularea respins Promisiunea:

toUppercase(99) .then(result => result) .catch(error => console.error(error.message));

Acest cod va jurnal:

Wrong type given, expected a string

În tărâm al făgăduinței, catch este construi pentru manipularea erorilor.,

În plus față de catch și then avem, de asemenea, finally, similar cu finally în try/catch.

Ca sa sincron „relativă”, Promisiunea lui finally ruleaza indiferent de Promisiunea rezultat:

toUppercase(99) .then(result => result) .catch(error => console.error(error.message)) .finally(() => console.log("Run baby, run"));

păstrați-vă Întotdeauna în vedere faptul că orice apel invers trecut la then/catch/finally este manipulat în mod asincron de Microtask Coadă. Sunt micro sarcini cu prioritate față de sarcini macro, cum ar fi evenimente și cronometre.,

Promit, eroare, si arunca

cele mai bune practici atunci când respinge o Promisiune este convenabil pentru a oferi o eroare obiect:

Promise.reject(TypeError("Wrong type given, expected a string"));

De a face astfel încât vă păstrați eroare de manipulare coerentă prin codebase. Alți membri ai echipei se pot aștepta întotdeauna să acceseze error.message și, mai important, puteți inspecta urmele stivei.

în plus față de Promise.reject, putem ieși dintr-un lanț de promisiuni aruncând o excepție.,

luați în Considerare următorul exemplu:

Promise.resolve("A string").then(value => { if (typeof value === "string") { throw TypeError("Expected a number!"); }});

Ne-am rezolva o Promisiune cu un șir de caractere, și apoi lanțul este rupt imediat cu throw.

Pentru a opri excepție de propagare vom folosi catch, ca de obicei:

Acest model este comună în fetch, unde vom verifica obiect de răspuns în căutare de erori:

Aici o excepție poate fi interceptat cu catch., Dacă nu reușim, sau să decidă să nu-l prindă acolo, excepția este liber să bule în stivă.

Acest lucru nu este rău per-se, dar diferite medii reacționează diferit la Respingerile neîngrijite.

nod.js de exemplu, în viitor, va lăsa să se prăbușească în orice program în cazul în care Promisiunea de respingeri sunt ne-manipulate:

DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

mai Bine le prinde!

eroare de manipulare pentru” promisified ” cronometre

cu cronometre sau evenimente nu este posibil pentru a prinde excepții aruncate de la un apel invers., Am văzut un exemplu în secțiunea anterioară:

o soluție oferită de Promise constă în” promisiunea ” codului nostru. Practic, ne înfășurăm timer cu o Promisiune:

function failAfterOneSecond() { return new Promise((_, reject) => { setTimeout(() => { reject(Error("Something went wrong!")); }, 1000); });}

Cu reject am pornit o Promisiune de respingere, care poartă o eroare obiect.,

În acest punct ne putem ocupa de excepție cu catch:

failAfterOneSecond().catch(reason => console.error(reason.message));

Notă: este comună de a folosi value ca întoarcerea valoare de o Promisiune, și reason ca întoarcerea obiect dintr-o respingere.

nod.js are un utilitar numit promisify pentru a ușura „promisiunea” API-urilor de apel invers în stil vechi.

eroare de manipulare în promisiune.,toate

metoda statică Promise.all acceptă o serie de Promisiune, și returnează o matrice de rezultate din rezolvarea Promisiune:

Dacă oricare dintre aceste Promit respinge, Promise.all respinge cu eroarea de la primul respins Promisiunea.

Să se ocupe de aceste situații în Promise.all vom folosi catch, cum am făcut-o în secțiunea anterioară:

Pentru a rula o funcție, indiferent de rezultatul de Promise.all, din nou, putem folosi finally:

Eroare de manipulare în Promisiune.,orice

putem considera Promise.any (Firefox > 79, Chrome > 85), ca opus al Promise.all.

Întrucât Promise.all returnează un eșec, chiar dacă o singură Promisiune în matrice respinge, Promise.any ne dă întotdeauna primul rezolvate Promit (dacă este prezent în matrice), indiferent de orice respingere a avut loc.

în cazul În care în loc de toate Promit trecut la Promise.any respingere, rezultat de eroare este un AggregateError., Luați în considerare următorul exemplu:

aici gestionăm eroarea cu catch., Datele de ieșire ale acestui cod este:

AggregateError: No Promise in Promise.any was resolvedAlways runs!

AggregateError obiect are aceleași proprietăți de bază Error, plus un errors proprietate:

// .catch(error => console.error(error.errors))//

Această proprietate este o matrice de fiecare individ de eroare produs de respingere:

Eroare de manipulare în Promisiune.,cursa

metoda staticăPromise.race acceptă o serie de promisiuni:

rezultatul este prima promisiune care câștigă „cursa”.

Ce zici de respingeri atunci? Dacă respinge Promisiunea nu este primul să apară în matrice de intrare, Promise.race rezolvă:

Dacă respingerea în schimb apare ca primul element din matrice, Promise.race respinge, și trebuie să prindem respingere:

Eroare de manipulare în Promisiune.allSettled

Promise.allSettled este o adăugare ECMAScript 2020 la limbă.,

nu este atât de mult să se ocupe cu această metodă statică, deoarece rezultatul va fi întotdeauna o promisiune rezolvată, chiar dacă una sau mai multe promisiuni de intrare respinge.

luați în considerare următorul exemplu:

trecem la Promise.allSettled o matrice formată din două promisiuni: una rezolvată și alta respinsă.

în acest caz catch nu va fi niciodată lovit. finally în schimb rulează.,

rezultatul acestui cod, conectat în then este:

Eroare de manipulare pentru async/așteaptă

async/await în JavaScript denotă asincron funcții, dar de la un cititor de vedere vor beneficia de toate lizibilitatea sincron funcții.,

Pentru a păstra lucrurile simple ne luăm anterior sincron funcția toUppercase, și ne-am transforma într-o funcție asincron prin punerea async înainte function cuvinte cheie:

Doar prin prefixarea o funcție cu async vom determina funcția să returneze o Promisiune., Asta înseamnă că putem lanț then, catch și finally după apelul funcției:

Când ne-am arunca de la un async funcția excepția devine cauza de respingere pentru fond al sistemului Promisiune.orice eroare poate fi interceptată cu catch din exterior.

cel mai important, pe lângă acest stil putem folosi try/catch/finally, la fel cum am face cu o funcție sincronă.,

În exemplul următor vom numi toUppercase de la o altă funcție, consumer, care în mod convenabil împachetări apelul funcției cu try/catch/finally:

rezultatul este:

Wrong type given, expected a stringAlways runs!

Pe aceeași temă: Cum să Arunce Erori De Async Funcții în JavaScript?

manipularea erorilor pentru generatoarele asincrone

generatoarele asincrone în JavaScript sunt funcții generatoare capabile să obțină promisiuni în loc de valori simple.,acestea combină funcțiile generatorului cu async. Rezultatul este o funcție generator ale cărei obiecte iterator expun o promisiune consumatorului.

Pentru a crea un generator asincron declara un generator de funcții cu steaua *, prefixat cu async:

async function* asyncGenerator() { yield 33; yield 99; throw Error("Something went wrong!"); // Promise.reject}

Fiind bazat pe Promisiunea, aceleași reguli pentru eroare de manipulare se aplică aici., throwîn interiorul unui generator async provoacă o respingere a promisiunii, pe care o interceptăm cu catch.

Pentru a trage Promite o asincron generatoare putem folosi două metode:

  • then stivuitoare.
  • asincronizare iterație.din exemplul de mai sus știm sigur că va exista o excepție după primele două yield., Acest lucru înseamnă că puteți face:

    ieșire de la acest cod este:

    { value: 33, done: false }{ value: 99, done: false }Something went wrong!

    alte abordare folosește asincron iterație cu for await...of. Pentru a utiliza iterația async, trebuie să înfășurăm consumatorul cu o funcție async.,

    Iată un exemplu complet:

    Și async/await ne ocupam de orice potențial de excepție cu try/catch:

    ieșire a acestui cod este:

    3399Something went wrong!

    obiect iterator întors de la un generator asincron funcție are, de asemenea, un throw() metoda, ca sa sincron omologul său.,

    Apelarea throw() pe obiect iterator aici nu va arunca o excepție, ci o Promisiune de respingere:

    Să se ocupe de această situație din exterior ne poate face:

    go.throw(Error("Let's reject!")).catch(reason => console.error(reason.message));

    Dar să nu uităm că obiecte iterator throw() trimite excepție în interiorul generatorului. Acest lucru înseamnă că putem aplica, de asemenea, următorul model:

    eroare de manipulare în nod.js

    eroare de manipulare sincron în nod.JS

    eroare de manipulare sincron în nod.,js nu diferă prea mult de ceea ce am văzut până acum.

    pentru codul sincron, try/catch/finally funcționează bine.cu toate acestea, lucrurile devin interesante dacă aruncăm o privire asupra lumii asincrone.

    manipularea erorilor asincrone în nod.js: modelul de apel invers

    pentru codul asincron, nod.js se bazează puternic pe două idiomuri:

    • modelul de apel invers.
    • emițători de evenimente.

    în modelul de apel invers, nod asincron.API-urile js acceptă o funcție care este gestionată prin bucla de evenimente și executată imediat ce stiva de apeluri este goală.,

    Considerăm următorul cod:

    Dacă vom extrage apel de pe această listă, putem vedea cum ar trebui să se ocupe de erori:

    //function(error, data) { if (error) console.error(error); // do stuff with the data }//

    Dacă orice erori rezultă din citirea dat cale cu fs.readFile, vom primi o eroare obiect.

    în acest moment putem:

    • pur și simplu conectați obiectul de eroare așa cum am făcut-o.
    • aruncați o excepție.
    • treceți eroarea la un alt apel invers.,pentru a arunca o excepție putem face:

      cu toate acestea, ca și în cazul evenimentelor și cronometrelor din DOM, această excepție va bloca programul. Următoarea încercare să-l oprească cu try/catch nu va funcționa:

      Trecerea de eroare la un alt apel invers este opțiunea preferată, dacă nu vrem să se prăbușească în program:

      Aici errorHandler este ceea ce sugerează și numele, o funcție de simplu pentru eroare de manipulare:

      Asincron eroare de manipulare în Nod.js: emițători de evenimente

      o mare parte din ceea ce faci în nod.js se bazează pe evenimente., De cele mai multe ori interacționați cu un obiect emițător și cu unii observatori care ascultă mesaje.

      orice modul condus de evenimente (cum ar fi net, de exemplu) în nod.js extinde o clasă rădăcină numită EventEmitter.

      EventEmitter în nod.js are două metode fundamentale: on și emit.

      luați în considerare acest server HTTP simplu:

      aici ascultăm două evenimente: ascultare și conexiune.în plus față de aceste evenimente, emițătorii de evenimente expun și un eveniment de eroare, tras în caz de erori.,

      Dacă tu a alerga acest cod asculta pe portul 80 în loc de exemplul anterior, veți obține o excepție:

      Ieșire:

      Pentru a prinde-l putem înregistra o tratare a evenimentului de eroare:

      server.on("error", function(error) { console.error(error.message);});

      Acest lucru se va imprima:

      listen EACCES: permission denied 127.0.0.1:80

      În plus, programul nu se va prăbuși.

      pentru a afla mai multe despre acest subiect, luați în considerare și citirea „manipularea erorilor în nod.js”.,în acest ghid am acoperit gestionarea erorilor în JavaScript pentru întregul spectru, de la cod sincron simplu, la primitive asincrone avansate.

      există multe moduri în care o excepție se poate manifesta în programele noastre JavaScript.excepțiile de la codul sincron sunt cele mai simple de prins. În schimb, excepțiile de la căile de cod asincrone pot fi dificil de rezolvat.

      între timp, noi API-uri JavaScript în browser sunt aproape toate îndreptate spre Promise., Acest model omniprezentă face mai ușor să se ocupe de excepții cu then/catch/finally sau try/catch pentru async/await.după ce ați citit acest ghid, ar trebui să puteți recunoaște toate situațiile diferite care pot apărea în programele dvs. și să vă prindeți corect excepțiile.

      Vă mulțumim că ați citit și rămâneți la curent!

      Acest post este de asemenea disponibil în:

      • Japoneză
      • chineză