try { {{{{{{{{{{{{} catch(e) { alert("The engine can't understand this code, it's invalid");}

Il motore JavaScript prima legge il codice e poi lo esegue., Gli errori che si verificano nella fase di lettura sono chiamati errori” parse-time ” e sono irrecuperabili (dall’interno di quel codice). Questo perché il motore non riesce a capire il codice.

Quindi,try..catch può gestire solo gli errori che si verificano nel codice valido. Tali errori sono chiamati ” errori di runtime “o, a volte,”eccezioni”.

Per tutti gli errori incorporati, l’oggetto error ha due proprietà principali:

name Nome errore. Ad esempio, per una variabile indefinita che è "ReferenceError". message Messaggio testuale sui dettagli dell’errore.

Ci sono altre proprietà non standard disponibili nella maggior parte degli ambienti., Uno dei più utilizzati e supportati è:

stack Current call stack: una stringa con informazioni sulla sequenza di chiamate nidificate che hanno portato all’errore. Utilizzato per scopi di debug.

Per esempio:

Binding opzionale “catch”

Se non abbiamo bisogno di dettagli errore, catch può omettere:

try { // ...} catch { // <-- without (err) // ...}

Uso di “try…catch”

esploriamo la vita reale caso di utilizzo di try..catch.

Come già sappiamo, JavaScript supporta il JSON.metodo parse (str) per leggere i valori codificati JSON.

Di solito viene utilizzato per decodificare i dati ricevuti in rete, dal server o da un’altra fonte.,

Lo riceviamo e chiamiamoJSON.parse in questo modo:

Puoi trovare informazioni più dettagliate su JSON nei metodi JSON, capitolo toJSON.

Se json è malformato, JSON.parse genera un errore, quindi lo script “muore”.

Dovremmo essere soddisfatti di questo? Certo che no!

In questo modo, se qualcosa non va con i dati, il visitatore non lo saprà mai (a meno che non apra la console degli sviluppatori). E alla gente non piace davvero quando qualcosa “muore” senza alcun messaggio di errore.,

Usiamotry..catchper gestire l’errore:

Qui usiamo il bloccocatch solo per mostrare il messaggio, ma possiamo fare molto di più: inviare una nuova richiesta di rete, suggerire un’alternativa al visitatore, inviare informazioni sull’errore a un impianto di registrazione, … . Tutto molto meglio che morire.

Lanciare i nostri errori

Cosa succede sejson è sintatticamente corretto, ma non ha una proprietàname richiesta?,

let json = '{ "age": 30 }'; // incomplete datatry { let user = JSON.parse(json); // <-- no errors alert( user.name ); // no name!} catch (e) { alert( "doesn't execute" );}

JSON.parse viene eseguito normalmente, ma l’assenza di name è in realtà un errore per noi.

Per unificare la gestione degli errori, useremo l’operatore throw.

Operatore”Throw”

L’operatorethrow genera un errore.

La sintassi è:

throw <error object>

Tecnicamente, possiamo usare qualsiasi cosa come oggetto di errore., Potrebbe essere anche una primitiva, come un numero o una stringa, ma è meglio usare oggetti, preferibilmente con proprietà name e message (per rimanere in qualche modo compatibili con gli errori incorporati).

JavaScript ha molti costruttori incorporati per errori standard: Error, SyntaxError, ReferenceError, TypeError e altri. Possiamo usarli anche per creare oggetti di errore.,

La loro sintassi è:

Per errori incorporati (non per oggetti, solo per errori), la proprietà name è esattamente il nome del costruttore. Emessage è preso dall’argomento.,

Per esempio:

let error = new Error("Things happen o_O");alert(error.name); // Erroralert(error.message); // Things happen o_O

vediamo che tipo di errore JSON.parse genera:

try { JSON.parse("{ bad json o_O }");} catch(e) { alert(e.name); // SyntaxError alert(e.message); // Unexpected token b in JSON at position 2}

Come si può vedere, che il SyntaxError.

E nel nostro caso, l’assenza di name è l’errore, poiché gli utenti devono avere un name.,

Quindi buttiamolo:

Nella riga(*), l’operatorethrow genera unSyntaxError con il datomessage, allo stesso modo di JavaScript genererebbe esso stesso. L’esecuzione di try si interrompe immediatamente e il flusso di controllo salta in catch.

Ora catch è diventato un unico posto per tutta la gestione degli errori: sia per JSON.parse e altri casi.,

Rethrowing

Nell’esempio sopra usiamotry..catch per gestire dati errati. Ma è possibile che si verifichi un altro errore imprevisto all’interno del blocco try {...}? Come un errore di programmazione (la variabile non è definita) o qualcos’altro, non solo questa cosa “dati errati”.

Per esempio:

Certo, tutto è possibile! I programmatori fanno errori. Anche nelle utility open-source utilizzate da milioni di persone per decenni – improvvisamente si può scoprire un bug che porta a terribili hack.,

Nel nostro caso, try..catch viene inserito per rilevare errori di “dati errati”. Ma per sua natura,catch ottiene tutti gli errori datry. Qui ottiene un errore inaspettato, ma mostra ancora lo stesso messaggio"JSON Error". Questo è sbagliato e rende anche il codice più difficile da eseguire il debug.

Per evitare tali problemi, possiamo utilizzare la tecnica “rethrowing”. La regola è semplice:

Catch dovrebbe elaborare solo errori che conosce e “ripensare” tutti gli altri.,

La tecnica “rethrowing” può essere spiegata in modo più dettagliato come:

1. Catch ottiene tutti gli errori.
2. Nel bloccocatch(err) {...} analizziamo l’oggetto di erroreerr.
3. Se non sappiamo come gestirlo, facciamo throw err.

Di solito, possiamo controllare il tipo di errore usando l’operatore instanceof:

Possiamo anche ottenere il nome della classe di errore dalla proprietà err.name. Tutti gli errori nativi ce l’hanno. Un’altra opzione è leggere err.constructor.name.,

Nel codice riportato di seguito, usiamo generazione ripetuta in modo che catch gestisce solo SyntaxError:

L’errore di lancio on line (*) dall’interno catch blocco “cade” di try..catch e può essere catturato da un esterno try..catch costruire (se esiste), o che uccide lo script.

Quindi il bloccocatch gestisce in realtà solo errori che sa come gestire e “salta” tutti gli altri.,

L’esempio seguente mostra come tali errori possono essere rilevati da un altro livello di try..catch:

Qui readData sa solo come gestire SyntaxError, mentre l’esterno try..catch sa come gestire tutto.

prova catch cattura finally finalmente

Aspetta, non è tutto.

Il costrutto try..catch può avere un’altra clausola di codice: finally.,

Se esiste, viene eseguito in tutti i casi:

• dopotry, se non ci sono stati errori,
• dopocatch, se ci sono stati errori.

La sintassi estesa di simile a questo:

try { ... try to execute the code ...} catch(e) { ... handle errors ...} finally { ... execute always ...}

Provare a eseguire questo codice:

try { alert( 'try' ); if (confirm('Make an error?')) BAD_CODE();} catch (e) { alert( 'catch' );} finally { alert( 'finally' );}

Il codice ha due modalità di esecuzione:

1. Se la risposta è “Sì” per “Fare un errore?”, quindi try -> catch -> finally.,
2. Se dici “No”, allora try -> finally.

La clausola finally viene spesso utilizzata quando iniziamo a fare qualcosa e vogliamo finalizzarla in ogni caso di esito.

Ad esempio, vogliamo misurare il tempo che una funzione di numeri di Fibonaccifib(n) richiede. Naturalmente, possiamo iniziare a misurare prima che venga eseguito e finire in seguito. Ma cosa succede se c’è un errore durante la chiamata alla funzione? In particolare, l’implementazione di fib(n) nel codice seguente restituisce un errore per numeri negativi o non interi.,

La clausolafinally è un ottimo posto per completare le misurazioni, indipendentemente da cosa.

finally garantisce che il tempo sarà misurato correttamente in entrambe le situazioni – in caso di esito positivo dell’esecuzione del fib e in caso di errore:

È possibile controllare l’esecuzione del codice, con l’immissione di 35 in prompt esegue normalmente finally dopo try., E poi inserisci -1 – ci sarà un errore immediato e l’esecuzione prenderà0ms. Entrambe le misurazioni sono eseguite correttamente.

In altre parole, la funzione potrebbe finire conreturnothrow, non importa. La clausolafinally viene eseguita in entrambi i casi.,

window.onerror = function(message, url, line, col, error) { // ...};