Che cos’è un errore nella programmazione?

Le cose non vanno sempre bene nei nostri programmi.

In particolare, ci sono situazioni in cui potremmo voler interrompere il programma o informare l’utente se succede qualcosa di brutto.

Ad esempio:

  • il programma ha cercato di aprire un file inesistente.
  • la connessione di rete è interrotta.
  • l’utente ha inserito un input non valido.,

In tutti questi casi noi come programmatori, creiamo errori, o lasciamo che il motore di programmazione ne crei alcuni per noi.

Dopo aver creato l’errore possiamo informare l’utente con un messaggio, oppure possiamo interrompere del tutto l’esecuzione.

Che cos’è un errore in JavaScript?

Un errore in JavaScript è un oggetto, che viene successivamente lanciato per arrestare il programma.

Per creare un nuovo errore in JavaScript chiamiamo la funzione di costruzione appropriata., Per esempio, per creare un nuovo messaggio di errore generico che possiamo fare:

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

Quando si crea un oggetto di errore, è possibile omettere il new parola chiave:

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

una Volta creato, l’errore in oggetto presenta tre caratteristiche:

  • message: una stringa con il messaggio di errore.
  • name: il tipo di errore.
  • stack: una traccia di stack di esecuzione delle funzioni.,

Per esempio, se si crea un nuovo TypeError oggetto con il messaggio appropriato, il message porterà l’attuale stringa di errore, mentre name sarà "TypeError":

Firefox implementa anche un gruppo di non-standard di proprietà come columnNumber filename e 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.,

Nel tuo codice userai principalmente Error e TypeError, due dei tipi più comuni, per creare il tuo oggetto error.

La maggior parte delle volte, la maggior parte degli errori verrà direttamente dal motore JavaScript, come InternalErroro SyntaxError., 

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

O quando si utilizzano le parole chiave riservate in posti sbagliati, come await al di fuori di un async funzione:

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

un Altro esempio di TypeError si verifica quando si seleziona inesistenti gli elementi HTML della pagina:

Uncaught TypeError: button is null

In aggiunta a questi tradizionali oggetti di errore, un AggregateError oggetto sta per terra presto in JavaScript., AggregateError è conveniente per il wrapping di più errori insieme, come vedremo più avanti.

Oltre a questi errori incorporati, nel browser possiamo trovare anche:

  • DOMException.
  • DOMError, deprecato e non più utilizzato oggi.

DOMException è una famiglia di errori relativi alle API Web., Essi sono gettati quando facciamo cose stupide nel browser, come:

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

Il risultato:

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

Per un elenco completo, vedere questa pagina su MDN.

Che cos’è un’eccezione?

La maggior parte degli sviluppatori pensa che l’errore e le eccezioni siano la stessa cosa. In realtà, un oggetto error diventa un’eccezione solo quando viene lanciato.,

Per lanciare un’eccezione in JavaScript si usa throw, seguito da l’errore in oggetto:

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

La forma breve è più comune nella maggior parte delle basi di codice si trova:

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

o

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

È improbabile per generare eccezioni al di fuori di una funzione o di un blocco condizionale. Invece, considera il seguente esempio:

Qui controlliamo se l’argomento della funzione è una stringa., Se non lo è, lanciamo un’eccezione.

Tecnicamente, puoi lanciare qualsiasi cosa in JavaScript, non solo oggetti error: 

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

Tuttavia, è meglio evitare queste cose: lanciare sempre oggetti error corretti, non primitive.

In questo modo si mantiene la gestione degli errori coerente attraverso la base di codice. Altri membri del team possono sempre aspettarsi di accedere aerror.message oerror.stack sull’oggetto error.

Cosa succede quando lanciamo un’eccezione?,

Le eccezioni sono come un ascensore che sale: una volta lanciato uno, bolle nello stack del programma, a meno che non venga catturato da qualche parte.

Si consideri il seguente codice:

Se si esegue questo codice in un browser o nel nodo.js, il programma si ferma e segnala l’errore:

Inoltre, è possibile vedere la riga esatta in cui si è verificato l’errore.

Questo rapporto è una traccia dello stack ed è utile per rintracciare i problemi nel codice.

La traccia dello stack va dal basso verso l’alto., Così qui:

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

Possiamo dire:

  • qualcosa in programma alla riga 9 denominato toUppercase
  • toUppercase fatto saltare in aria in linea 3

oltre a vedere questa traccia dello stack nel browser della console, è possibile accedere su stack proprietà dell’oggetto di errore.

Se l’eccezione non viene rilevata, cioè non viene fatto nulla dal programmatore per catturarla, il programma si bloccherà.,

Quando e dove si rileva un’eccezione nel codice dipende dal caso d’uso specifico.

Ad esempio, potresti voler propagare un’eccezione nello stack per mandare in crash del tutto il programma. Questo potrebbe accadere per errori fatali, quando è più sicuro interrompere il programma piuttosto che lavorare con dati non validi.

Dopo aver introdotto le basi, rivolgiamo ora la nostra attenzione alla gestione degli errori e delle eccezioni sia nel codice JavaScript sincrono che asincrono.

Gestione sincrona degli errori

Il codice sincrono è la maggior parte delle volte semplice e quindi la sua gestione degli errori.,

Gestione degli errori per le funzioni regolari

Il codice sincrono viene eseguito nello stesso ordine in cui viene scritto. Riprendiamo l’esempio precedente:

Qui il motore chiama ed eseguetoUppercase. Tutto avviene in modo sincrono. Per catturare un’eccezione proveniente da tale funzione sincrona è possibile usare try/catch/finally:

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

di Solito, try occupa il felice percorso, o con la chiamata di funzione che, potenzialmente, potrebbero gettare.,

catch invece, cattura l’eccezione effettiva. Riceve l’oggetto error, che possiamo ispezionare (e inviare da remoto ad alcuni logger in produzione).

L’istruzione finally invece viene eseguita indipendentemente dal risultato della funzione: che sia fallita o riuscita, verrà eseguito qualsiasi codice all’interno di finally.

Ricorda:try/catch/finally è un costrutto sincrono: ora ha modo di catturare le eccezioni provenienti dal codice asincrono.,

Gestione degli errori per le funzioni del generatore

Una funzione del generatore in JavaScript è un tipo speciale di funzione.

Può essere messo in pausa e ripreso a volontà, oltre a fornire un canale di comunicazione bidirezionale tra il suo ambito interno e il consumatore.,

Per creare un generatore di funzione abbiamo messo una stella * dopo il function parola chiave:

function* generate() {//}

una Volta all’interno della funzione si può usare yield per i valori di ritorno:

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

Il valore di ritorno da un generatore di funzione è un oggetto iteratore. Per estrarre valori da un generatore possiamo usare due approcci:

  • chiamandonext() sull’oggetto iteratore.,
  • iterazione con for...of.

Se prendiamo il nostro esempio, per ottenere valori dal generatore possiamo fare: 

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

Quigo diventa il nostro oggetto iteratore quando chiamiamo la funzione generator.

D’ora in poi possiamo chiamare go.next() per avanzare l’esecuzione:

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

I generatori funzionano anche al contrario: possono accettare valori ed eccezioni dal chiamante.,

Oltre a next(), gli oggetti iteratori restituiti dai generatori hanno un metodo throw().

Con questo metodo siamo in grado di fermare il programma iniettando un’eccezione nel generatore:

Per la cattura di tale errore si sarebbe avvolgere il codice all’interno del generatore con try/catch (e finally se necessario):

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

Generatore di funzioni, è possibile anche generare eccezioni all’esterno., Il meccanismo per la cattura di queste eccezioni è lo stesso per la cattura di eccezioni sincrone: try/catch/finally.

Ecco un esempio di una funzione generatrice consumata dall’esterno confor...of:

Qui iteriamo il percorso felice all’interno di un bloccotry. Se si verificano eccezioni, la interrompiamo con catch.

Gestione asincrona degli errori

JavaScript è sincrono per natura, essendo un linguaggio a thread singolo.,

Gli ambienti host come i motori dei browser aumentano JavaScript con una serie di API Web per interagire con sistemi esterni e per gestire le operazioni di I / O bound.

Esempi di asincronicità nel browser sono timeout, eventi, Promesse.

La gestione degli errori nel mondo asincrono è distinta dalla sua controparte sincrona.

Vediamo alcuni esempi.

Gestione degli errori per i timer

All’inizio delle tue esplorazioni con JavaScript, dopo aver appreso di try/catch/finally, potresti essere tentato di metterlo in giro per qualsiasi blocco di codice.,

Considera il seguente frammento: 

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

Questa funzione viene generata dopo circa 1 secondo. Qual è il modo giusto per gestire questa eccezione?

Il seguente esempio non funziona:

Come abbiamo detto,try/catch è sincrono. D’altra parte abbiamo setTimeout, un’API del browser per i timer.

Quando il callback è passato a setTimeoutviene eseguito, il nostro try/catch è ormai lontano. Il programma si bloccherà perché non siamo riusciti a catturare l’eccezione.,

viaggiano su due tracce diverse:

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

Se non vogliamo mandare in crash il programma, per gestire l’errore correttamente dobbiamo spostare try/catch all’interno di callback per setTimeout.

Ma questo approccio non ha molto senso la maggior parte delle volte. Come vedremo più avanti, la gestione asincrona degli errori con Promises fornisce una migliore ergonomia.,

Gestione degli errori per gli eventi

I nodi HTML nel modello a oggetti Document sono collegati aEventTarget, l’antenato comune per qualsiasi emettitore di eventi nel browser.

Ciò significa che possiamo ascoltare gli eventi su qualsiasi elemento HTML nella pagina.

(Nodo.js supporterà EventTarget in una versione futura).

La meccanica di gestione degli errori per gli eventi DOM segue lo stesso schema di qualsiasi API Web asincrona.

Considera il seguente esempio:

Qui generiamo un’eccezione non appena si fa clic sul pulsante. Come lo prendiamo?, Questo modello non funziona, e non impedire che il programma di crash:

Come con l’esempio precedente, con setTimeout, qualsiasi richiamata passato addEventListener viene eseguita in modo asincrono:

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

Se non vogliamo mandare in crash il programma, per gestire l’errore correttamente dobbiamo spostare try/catch all’interno di callback per addEventListener.

Ma ancora una volta, non c’è poco valore nel fare questo.,

Come con setTimeout, l’eccezione generata da un percorso di codice asincrono non è catturabile dall’esterno e bloccherà il programma.

Nelle prossime sezioni vedremo come Promises e async/await possono facilitare la gestione degli errori per il codice asincrono.

Che ne dici di onerror?

Gli elementi HTML hanno un numero di gestori di eventi comeonclick,onmouseenter,onchange per citarne alcuni.

C’è ancheonerror, ma non ha nulla a che fare conthrow e amici.,

Il gestore di eventi onerror si attiva ogni volta che un elemento HTML come un tag <img> o un <script> colpisce una risorsa inesistente.,b4″>// omitted<body><img src="https://www.valentinog.com/blog/error/nowhere-to-be-found.png" alt="So empty!"></body>// omitted

Quando si visita un documento HTML con una mancanti o inesistente risorsa che il browser della console registra il messaggio di errore:

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

Nel nostro JavaScript che abbiamo la possibilità di “catturare” questo errore con il relativo gestore di eventi:

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

O meglio:

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

Questo modello è utile per il caricamento alternativo risorse mancanti immagini o script.,

Ma ricorda:onerror, non ha nulla a che fare conthrow otry/catch.

Gestione degli errori con Promise

Per illustrare la gestione degli errori con Promise, “promisify” uno dei nostri esempi originali. Possiamo modificare la funzione riportata di seguito:

Invece di restituire una semplice stringa, o di un’eccezione, usiamo rispettivamente Promise.reject e Promise.resolve per gestire l’errore e il successo:

(Tecnicamente non c’è niente asincrona in questo codice, ma ben si presta a illustrare il punto).,

Ora che la funzione è “promisified” si può collegare then per consumare il risultato, e catch per la gestione rifiutato Promessa:

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

Questo codice log:

Wrong type given, expected a string

Nel regno della Promessa, catch è il costrutto per la gestione degli errori.,

In aggiunta a catch e then abbiamo anche finally, simile a finally nel try/catch.

Come la sincrono “rispetto”, la Promessa del finally viene eseguito indipendentemente dalla Promessa risultato:

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

tenere Sempre a mente che qualsiasi richiamata passato then/catch/finally viene gestita in modo asincrono da Microtask Coda. Sono micro attività con precedenza su attività macro come eventi e timer.,

Promise, error, and throw

Come best practice quando si rifiuta una Promessa è conveniente fornire un oggetto error: 

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

In questo modo si mantiene la gestione degli errori coerente attraverso la base di codice. Altri membri del team possono sempre aspettarsi di accedere aerror.message, e più importante è possibile ispezionare le tracce dello stack.

Oltre a Promise.reject, possiamo uscire da una catena di promesse lanciando un’eccezione.,

Considera il seguente esempio: 

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

Risolviamo una Promessa con una stringa, e quindi la catena viene immediatamente interrotta conthrow.

Per fermare la propagazione delle eccezioni usiamo catch, come al solito:

Questo pattern è comune in fetch, dove controlliamo l’oggetto response in cerca di errori:

Qui l’eccezione può essere intercettata con catch., Se falliamo, o decidiamo di non prenderlo lì, l’eccezione è libera di gonfiarsi nella pila.

Questo non è male di per sé, ma ambienti diversi reagiscono in modo diverso ai rifiuti non rilevati.

Nodo.js, ad esempio, in futuro lascerà andare in crash qualsiasi programma in cui i rifiuti promessi non vengono gestiti:

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.

Meglio catturarli!

Gestione degli errori per i timer “promisified”

Con timer o eventi non è possibile rilevare eccezioni generate da un callback., Abbiamo visto un esempio nella sezione precedente:

Una soluzione offerta da Promise consiste nella “promisification” del nostro codice. Fondamentalmente, avvolgiamo il nostro timer con una Promessa:

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

Con reject abbiamo attivato un rifiuto della Promessa, che porta un oggetto error.,

A questo punto siamo in grado di gestire l’eccezione con catch:

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

Nota: è comune l’uso di value come valore di ritorno da una Promessa, e reason come la restituzione di un oggetto da un rifiuto.

Nodo.js ha un’utilità chiamata promisify per facilitare la” promessa ” delle API di callback vecchio stile.

Gestione degli errori in Promise.,all

Il metodo staticoPromise.all accetta un array di Promise e restituisce un array di risultati da all resolving Promise:

Se una di queste Promise rifiuta,Promise.all rifiuta con l’errore della prima Promessa rifiutata.

Per gestire queste situazioni in Promise.all si usa catch‘, come abbiamo fatto nella sezione precedente:

Per eseguire una funzione a prescindere dal risultato del Promise.all, ancora, si può usare finally:

la gestione degli errori in Promessa.,qualsiasi

Possiamo considerarePromise.any (Firefox> 79, Chrome> 85) come l’opposto diPromise.all.

Mentre Promise.all restituisce un errore anche se una singola Promessa nell’array rifiuta, Promise.any ci dà sempre la prima Promessa risolta (se presente nell’array) indipendentemente da qualsiasi rifiuto si è verificato.

Nel caso in cui invece tutta la Promessa sia passata a Promise.anyrifiuta, l’errore risultante è un AggregateError., Si consideri il seguente esempio:

Qui gestiamo l’errore con catch., L’output di questo codice è:

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

AggregateError oggetto ha le stesse proprietà di un Error più un errors proprietà:

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

Questa proprietà è una matrice di ogni singolo errore prodotta da rifiutare:

la gestione degli errori in Promessa.,race

Il metodo staticoPromise.race accetta una matrice di Promise:

Il risultato è la prima Promessa che vince la “race”.

Che ne dici dei rifiuti allora? Se la Promessa di rifiuto non è la prima ad apparire nell’array di input, Promise.race risolve:

Se il rifiuto appare invece come primo elemento dell’array, Promise.race rifiuta, e dobbiamo catturare il rifiuto:

Gestione degli errori in Promise.allSettled

Promise.allSettled è un’aggiunta ECMAScript 2020 alla lingua.,

Non c’è molto da gestire con questo metodo statico poiché il risultato sarà sempre una Promessa risolta, anche se una o più promesse di input vengono rifiutate.

Considera il seguente esempio:

Passiamo aPromise.allSettled un array composto da due Promesse: una risolta e un’altra respinta.

In questo caso catch non verrà mai colpito. finally invece viene eseguito.,

Il risultato di questo codice, registrato nel then è:

Errore di gestione per async/await

async/await in JavaScript, che indica le funzioni asincrone, ma da un lettore di vista beneficiare di tutti i leggibilità del sincrono funzioni.,

Per mantenere le cose semplici, noi porteremo il nostro precedente funzione sincrona toUppercase e che la trasformazione di una funzione asincrona mettendo async prima di function parola chiave:

Solo anteponendo una funzione con async siamo in causa la funzione deve restituire una Promessa., Ciò significa che possiamo concatenare then, catch e finally dopo la chiamata di funzione:

Quando lanciamo da una funzione async l’eccezione diventa causa di rifiuto per la Promessa sottostante.

Qualsiasi errore può essere intercettato concatch dall’esterno.

Più importante, oltre a questo stile possiamo usaretry/catch/finally, proprio come faremmo con una funzione sincrona.,

Nell’esempio che segue viene chiamata toUppercase da un’altra funzione, consumer, che comodamente include la funzione di chiamata con try/catch/finally:

L’output è:

Wrong type given, expected a stringAlways runs!

Sullo stesso argomento: Come Buttare Errori Da Async Funzioni in JavaScript?

Gestione degli errori per i generatori asincroni

I generatori asincroni in JavaScript sono funzioni generatrici in grado di produrre Promesse anziché valori semplici.,

Combinano le funzioni del generatore conasync. Il risultato è una funzione generatrice i cui oggetti iteratori espongono una Promessa al consumatore.

Per creare un generatore asincrono dichiariamo un generatore di funzione con la stella *, il prefisso async:

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

Essendo basato sulla Promessa, le stesse regole per la gestione degli errori applica qui., throw all’interno di un generatore asincrono causa un rifiuto della Promessa, che intercettiamo con catch.

Per estrarre le promesse da un generatore asincrono possiamo usare due approcci:

  • then gestori.
  • iterazione asincrona.

Dall’esempio precedente sappiamo per certo che ci sarà un’eccezione dopo i primi due yield., Ciò significa che possiamo fare:

L’output da questo codice è: 

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

L’altro approccio utilizza l’iterazione asincrona confor await...of. Per utilizzare l’iterazione asincrona è necessario avvolgere il consumatore con una funzioneasync.,

Ecco un esempio completo:

E con async/await e gestire potenziali eccezione con try/catch:

L’uscita di questo codice è:

3399Something went wrong!

L’iteratore oggetto restituito da un generatore asincrono funzione ha anche un throw() metodo, proprio come la sua controparte sincrona.,

Chiama throw() un oggetto iteratore qui non gettare un’eccezione, ma una Promessa di rifiuto:

Per gestire questa situazione dall’esterno si può fare:

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

Ma non dimentichiamo che iteratore oggetti throw() invia l’eccezione all’interno del generatore. Ciò significa che possiamo anche applicare il seguente modello:

Gestione degli errori nel nodo.js

Gestione sincrona degli errori nel nodo.js

Gestione sincrona degli errori nel nodo.,js non differisce troppo da quello che abbiamo visto finora.

Per il codice sincrono, try/catch/finally funziona bene.

Tuttavia, le cose si fanno interessanti se diamo un’occhiata al mondo asincrono.

Gestione asincrona degli errori nel Nodo.js: il modello di callback

Per il codice asincrono, Nodo.js si basa fortemente su due idiomi:

  • il modello di callback.
  • emettitori di eventi.

Nel modello di callback, Nodo asincrono.le API js accettano una funzione che viene gestita attraverso il ciclo di eventi ed eseguita non appena lo stack di chiamate è vuoto.,

Considera il seguente codice:

Se estraiamo il callback da questo elenco, possiamo vedere come dovrebbe gestire gli errori:

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

Se qualche errore deriva dalla lettura del percorso dato con fs.readFile, otteniamo un oggetto error.

A questo punto possiamo:

  • semplicemente registrare l’oggetto error come abbiamo fatto.
  • genera un’eccezione.
  • passa l’errore a un altro callback.,

Per lanciare un’eccezione possiamo fare:

Tuttavia, come con eventi e timer nel DOM, questa eccezione andrà in crash il programma. Il seguente tentativo di fermare con try/catch non funziona:

Passando l’errore di un altro callback è l’opzione preferita, se non vogliamo mandare in crash il programma:

errorHandler è quello che suggerisce il nome, una semplice funzione per la gestione dell’errore:

Asincroni gestione degli errori nel Nodo.js: emettitori di eventi

Gran parte di ciò che fai nel nodo.js si basa su eventi., La maggior parte delle volte si interagisce con un oggetto emettitore e alcuni osservatori in ascolto per i messaggi.

Qualsiasi modulo basato su eventi (come net per esempio) nel nodo.js estende una classe radice denominata EventEmitter.

EventEmitter nel Nodo.js ha due metodi fondamentali: oneemit.

Considera questo semplice server HTTP:

Qui ascoltiamo due eventi: ascolto e connessione.

Oltre a questi eventi, gli emettitori di eventi espongono anche un evento di errore, attivato in caso di errori.,

Se si esegue questo codice in ascolto sulla porta 80, invece dell’esempio precedente, si otterrà un’eccezione:

Uscita:

afferrare se siamo in grado di registrare un gestore eventi per l’errore:

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

in Questo modo, di stampa:

listen EACCES: permission denied 127.0.0.1:80

In aggiunta, il programma non crash.

Per saperne di più sull’argomento, considera anche la lettura di “Gestione degli errori nel nodo.js”.,

Avvolgimento

In questa guida abbiamo trattato la gestione degli errori in JavaScript per l’intero spettro, dal semplice codice sincrono, alle primitive asincrone avanzate.

Ci sono molti modi in cui un’eccezione può manifestarsi nei nostri programmi JavaScript.

Le eccezioni dal codice sincrono sono le più semplici da catturare. Le eccezioni dai percorsi di codice asincroni possono invece essere difficili da gestire.

Nel frattempo, le nuove API JavaScript nel browser sono quasi tutte dirette verso Promise., Questo modello pervasivo semplifica la gestione delle eccezioni conthen/catch/finally, o contry/catch perasync/await.

Dopo aver letto questa guida dovresti essere in grado di riconoscere tutte le diverse situazioni che possono sorgere nei tuoi programmi e cogliere correttamente le tue eccezioni.

Grazie per la lettura e rimanete sintonizzati!

Questo post è disponibile anche in:

  • Giapponese
  • Cinese