Innanzitutto è necessario capire cos'è un errore e le sue tipologie.
Tipi di errore
Mentre si lavora con qualsiasi linguaggio di programmazione, generalmente possono verificarsi due tipi di errori:
Errore operativo
L'errore operativo si verifica quando l'applicazione affronta un'eccezione non gestita o qualche problema nel codice. Questo tipo di errore è solitamente difficile da individuare in quanto esistono numerose cause per la sua origine, ad es. perdita di memoria, cicli infiniti, progettazione imprecisa del sistema, ecc.
Un modo efficace per gestire gli errori operativi è utilizzare una strategia ottimale di gestione degli errori per individuare l'errore nella sua origine e informare lo sviluppatore in modo che possa essere risolto in tempo.
Errore funzionale
Gli errori funzionali sono quelli che interrompono il normale funzionamento del codice dell'applicazione. Poiché questi errori si comportano in modo diverso, potrebbero richiedere più brainstorming per individuarne l’origine poiché potrebbero comportarsi in modo diverso durante il ciclo di vita dell’applicazione.
Un caso semplice può essere un programma in cui l'utente ha implementato la logica sbagliata che potrebbe provocare un ciclo infinito e alla fine mandare in crash il programma.
Gli sviluppatori devono scavare in profondità nella base di codice per identificare possibili errori funzionali utilizzando tecniche come debugging e stack traces ecc.
Ora che conosciamo il tipo di errore che può verificarsi nel nostro script di codice, è necessario comprendere il motivo per cui è necessario gestire l'errore.
Urge gestire gli errori in Node.js
Prima di spiegare il concetto di come gestire gli errori in Node.js utilizzando try-catch; è necessario comprendere il motivo per cui è necessario gestire gli errori. La gestione degli errori nel codice dell'applicazione è fondamentale per creare un'app con un'esperienza utente affidabile e migliorata per gli utenti.
Migliorare l'esperienza dell'utente
È buona norma evitare l'uso di messaggi generici e mostrare messaggi di errore intuitivi per una migliore esperienza utente.
Costruire una base di codice più forte
Quando gli errori vengono gestiti in modo ottimale, le fondamenta del codice sembrano più realistiche. Cattura e gestisce in modo efficiente gli errori desiderati riducendo così il rischio di arresto anomalo dell'applicazione.
Rilevamento bug
La gestione degli errori semplifica l'individuazione dei bug durante la fase di sviluppo e la loro rimozione il prima possibile. Ciò consente agli utenti di ottimizzare le proprie applicazioni nella fase di sviluppo in modo più accurato, consentendo al codice di fluire senza alcuna interruzione.
Crash dell'applicazione
La mancata gestione degli errori potrebbe comportare un'improvvisa interruzione del flusso del codice e, in ultima analisi, l'arresto anomalo dell'applicazione. L’uso di un “ prova a prendere ' Il blocco ci consente di gestire gli errori senza problemi.
Ora iniziamo esaminando la struttura/sintassi del blocco try-catch che implementeremo nel nostro codice.
Struttura del blocco try-catch
La struttura del blocco try-catch è piuttosto semplice ed è lo strumento di base per gestire efficacemente gli errori.
La struttura del blocco try-catch è:
Tentativo {} presa ( errore ) {
consolle. errore ( ) ;
} Finalmente {
}
Il funzionamento del codice sopra è:
- IL ' Tentativo 'Il blocco contiene tutto il codice funzionante e potrebbero verificarsi errori in questo blocco. Se si verifica un errore in questo blocco, viene attivato il messaggio ' presa 'blocco.
- IL ' presa 'Il blocco è dove vengono gestiti tutti gli errori necessari. Gli utenti possono modificarne le proprietà ed eseguire le azioni desiderate.
- IL ' Finalmente ' è un blocco facoltativo e viene eseguito ogni volta indipendentemente dal fatto che si verifichi o meno un errore. Esegue l'operazione di pulizia.
La comprensione del blocco try-catch potrebbe essere praticamente compresa nel caso in cui stiamo tentando di accedere a un file che potrebbe esistere o meno. Se non esiste potrebbe generare un errore, per evitare l'errore l'utente può gestirlo utilizzando il concetto try-catch.
Errori di gestione dei file utilizzando il blocco 'try-catch' in Node.js
Innanzitutto, esaminiamo un problema senza utilizzare un ' prova a prendere 'blocco. Nell'esempio di codice seguente, un file viene aperto senza un'adeguata gestione degli errori:
cost fs = richiedere ( 'fs' ) ;cost informazioni = fs. leggereFileSync ( '/Utenti/Lenovo/file.txt' ) ;
consolle. tronco d'albero ( 'Un pezzo di codice importante che dovrebbe essere eseguito alla fine' ) ;
La spiegazione del codice sopra è:
- “ const fs = require('fs') ' importa il modulo 'fs' (file system) di Node.js che consente all'utente di lavorare con il file system, comprese tutte le operazioni sui file come la lettura o la scrittura di file.
- “ const data = fs.readFileSync('/Users/Lenovo/file.txt') ' legge il contenuto del file nel percorso specificato. IL ' leggereFileSync ' è un'operazione sincrona, il che significa che interrompe l'ulteriore esecuzione del codice fino a quando il file non viene letto nel percorso specificato e le informazioni vengono archiviate in ' informazioni 'variabile.
- “ console.log('Un pezzo di codice importante che dovrebbe essere eseguito alla fine') ” stampa un messaggio nel terminale ma questa riga non viene eseguita finché il file non viene letto nel passaggio precedente.
Produzione
L'errore risultante dal codice precedente apparirà come:
Si può vedere che l'esecuzione di questo codice senza un'adeguata gestione degli errori genera errori. Ora rifattorizza il codice sopra usando il blocco “try-catch”:
cost fs = richiedere ( 'fs' ) ;Tentativo {
cost informazioni = fs. leggereFileSync ( '/Utenti/Lenovo/file.txt' ) ;
consolle. tronco d'albero ( informazioni ) ;
} presa ( errore ) {
consolle. errore ( ` Errore leggendo il fascicolo : $ { errore. Messaggio } ` ) ;
}
Il funzionamento del codice sopra è:
- Il processo di lettura del file è posto nella sezione “ Tentativo ' blocco perché esiste la possibilità che l'errore possa verificarsi qui.
- “ console.log(informazioni) ' registra il contenuto del file e lo stampa nella console.
- IL ' presa ' Il blocco rileva ogni possibile errore che potrebbe verificarsi nel ' Tentativo ' si blocca durante l'esecuzione del codice e registra il messaggio di errore sul terminale.
- “ console.error(`Errore durante la lettura del file: ${error.message}`) ' registra il messaggio di errore specificato ottenuto come risultato dell'errore rilevato.
Produzione
L'output del codice sottoposto a refactoring in modo efficiente mostrerà un messaggio di errore ottimale come mostrato di seguito nello screenshot allegato:
L'utilizzo di try-catch ci consente di gestire il possibile errore che potrebbe verificarsi, ma per una migliore comprensione vengono elencate alcune pratiche efficienti che possono essere utili.
Migliori pratiche per la gestione degli errori
L'utente può seguire le seguenti pratiche per gestire gli errori nei codici dell'applicazione:
Usando try-catch saggiamente
È necessario utilizzare “ prova a prendere ' solo dove è necessario utilizzarlo, soprattutto nelle parti importanti del codice in cui esiste il rischio di potenziali errori. L'uso eccessivo nel codice potrebbe rendere il codice complesso.
Utilizzo del codice asincrono
Quando il codice deve essere gestito con codice asincrono, prova a utilizzare ' prova a prendere ' con promesse e async/await per gestire in modo ottimale l'errore.
Registra e segnala errori
Registra e segnala sempre correttamente l'errore specifico nel blocco catch, poiché messaggi di errore chiari aiutano a identificare la causa principale degli errori.
Ridurre la complessità
Gestire le situazioni in cui gli errori non sono critici. La rimozione di quella parte specifica (se non è necessaria) può ridurre la complessità del codice.
Evitare errori silenziosi
Scrivere il codice in modo da mostrare il messaggio di errore dove necessario altrimenti se il messaggio di errore non viene indicato diventerà un problema gestire l'errore senza una corretta identificazione.
Questo è tutto incentrato sul funzionamento del blocco try-catch e su come può essere utilizzato in modo efficiente per gestire gli errori in Node.js.
Conclusione
Diventare esperto nella gestione degli errori in Node.js è il passo fondamentale per sviluppare applicazioni forti e coerenti. L’utilizzo ottimale del “ prova a prendere ' insieme a varie pratiche come le tecniche asincrone e la corretta registrazione degli errori possono aiutare a creare applicazioni Node.js stabili e facili da usare. Questo articolo ha spiegato la struttura, l'applicazione pratica e le pratiche di gestione che possono essere impiegate in base ai requisiti dell'utente.