‫Insegnante: In questo video, creiamo
‫ora una classe di errore migliore e più utile e
‫facciamo anche un po' di refactoring.
‫E partendo da quella classe di
‫errore, creiamo un nuovo file nella nostra cartella Utilità.
‫Quindi, nuovo file, e lo chiamerò
‫AppError perché quello sarà il nome della classe, va bene?
‫Quindi, class AppError, e in realtà vogliamo che tutti
‫i nostri oggetti AppError ereditino dall'errore
‫incorporato, quindi estendiamo effettivamente la classe di errore incorporata.
‫Quindi, abbiamo usato l'estensione Error, ok?
‫Quindi, l'abbiamo fatto prima da qualche parte in
‫questo corso, e di nuovo si tratta solo di lezioni ES6, ok?
‫In questo caso, l'ereditarietà
‫della classe, dove una classe eredita dall'altra, ok?
‫Quindi, come sempre, il nostro costruttore
‫e quello che passeremo in
‫un nuovo oggetto creato dalla classe
‫AppError saranno il messaggio e lo statusCode, quindi solo
‫questi due.
‫Ok, allora ricorda che il metodo del costruttore viene
‫chiamato ogni volta che creiamo un nuovo oggetto da questa classe.
‫Ora, come al solito, quando estendiamo
‫una classe genitore, chiamiamo super per chiamare il
‫costruttore genitore, va bene, e
‫lo facciamo con message perché il messaggio è
‫in realtà l'unico parametro che l'errore integrato accetta.
‫Ok, quindi questo è fondamentalmente che stai chiamando
‫errore, va bene, e poi questa
‫è la solita
‫roba, impostiamo statusCode su statusCode, va bene, e ora
‫vogliamo anche impostare lo stato stesso.
‫Quindi, ricorda che lo stato può essere fail o
‫error, e potremmo passarlo all'oggetto, ma
‫non è nemmeno
‫realmente necessario, perché lo stato dipende dallo statusCode.
‫Quindi, quando statusCode è un 400,
‫lo stato sarà fail,
‫e se è un 500, allora sarà un errore, giusto,
‫e quindi verifica semplicemente se
‫statusCode inizia con un quattro.
‫Quindi, in JavaScript, c'è un metodo startWith che possiamo chiamare sulle
‫stringhe, e quindi penso che
‫sia il modo più semplice per fare questo
‫test, quindi questo è fondamentalmente convertire lo statusCode in una stringa,
‫e per questo sto semplicemente usando un stringa del
‫modello con il codice lì dentro, quindi questo,
‫o in realtà possiamo semplicemente usare statusCode.
‫Quindi, statusCode,
‫e poi inizia con, allora anche
‫qui abbiamo bisogno di una stringa, e quindi se
‫statusCode come stringa inizia con un quattro, beh, allora abbiamo un errore.
‫E quindi qui, usiamo il ternario,
‫ok, quindi fallisce quando inizia
‫con un quattro, altrimenti è un errore, ok?
‫Quindi, molto semplice, e questo ci salva
‫già dal dover passare manualmente in caso di errore o errore.
‫Bene, ora il prossimo passo,
‫tutti gli errori che
‫creeremo usando questa classe saranno tutti errori operativi.
‫Quindi, gli errori
‫che possiamo prevedere si verificheranno in
‫futuro, come ad esempio un
‫utente che crea un tour senza i campi richiesti, giusto?
‫Quindi questo è un errore operativo, okay, e
‫quindi di nuovo, d'ora in poi,
‫useremo sempre questa classe AppError che
‫stiamo creando proprio ora
‫per creare tutti gli errori nella nostra applicazione.
‫E quindi questi errori saranno errori operativi, quindi quello
‫che farò ora è
‫creare effettivamente anche un file . è proprietà operativa qui.
‫Così questo. è operativo
‫e impostarlo su true.
‫Quindi tutti i nostri errori
‫otterranno questa proprietà impostata su true, e
‫lo sto facendo in
‫modo che in seguito possiamo testare questa
‫proprietà e inviare solo messaggi di
‫errore al client per questi errori operativi
‫che abbiamo creato utilizzando questa classe.
‫E questo è utile perché
‫alcuni altri errori imprevisti folli che potrebbero
‫verificarsi nella nostra applicazione, ad esempio un errore
‫di programmazione o qualche bug in uno
‫dei pacchetti che richiediamo nella nostra
‫app, e questi
‫errori ovviamente non avranno questo. è una proprietà
‫operativa su di loro, va bene,
‫e potrebbe sembrare un po'
‫confuso a questo punto, ma
‫non preoccuparti, avrà molto senso
‫quando implementeremo quella parte che ho appena menzionato.
‫Quindi, test per questo. è proprietà operativa qui.
‫Bene, e ora solo un ultimo passaggio
‫è che in realtà abbiamo anche bisogno di acquisire la traccia dello stack.
‫Ora, cosa intendo per traccia dello stack?
‫E quindi, lascia che te lo
‫mostri effettivamente, quindi, ti mostro cos'è la traccia dello
‫stack, e quindi lo registrerò qui nella console.
‫Consolle. registro ed errore. stackTrace,
‫quindi ogni errore ottiene questa traccia dello stack, e
‫in realtà è solo uno stack, ok.
‫Quindi sbaglia. stack ci mostrerà
‫fondamentalmente dove si è verificato l'errore.
‫Quindi fammi eseguire
‫questo qui ora, quindi diamo un'occhiata
‫a questo, e quindi ci
‫dà qui l'errore e poi anche dove è successo, ok?
‫Quindi, in questo caso qui,
‫ovviamente, aggiungi app. js alla riga 32.
‫Quindi, proprio qui.
‫Quindi, è lì che
‫abbiamo creato questo errore, e quindi
‫ora è nella nostra traccia dello stack, e ci
‫mostra anche l'intero stack di chiamate qui, che alla fine ha avuto origine in questo errore, ok?
‫Quindi in un certo
‫senso vogliamo preservarlo e allo stesso tempo non aggiungere questo metodo
‫qui, o questa classe, a quella traccia dello stack, ok?
‫E ancora, suona un po' confuso,
‫lo so, ma in questo
‫caso non è molto importante, tutto ciò che
‫conta è che aggiungiamo solo questa riga di codice
‫qui, che è Error. CapturestackTrace, quindi esattamente
‫quello che ottieni qui, e
‫all'inizio dobbiamo specificare l'oggetto corrente, che è
‫questo, e poi la stessa classe AppError, che sarà
‫questa. costruttore.
‫Ok, in questo modo quando viene creato un nuovo
‫oggetto e viene chiamata una funzione di costruzione, quella chiamata
‫alla funzione non apparirà nella
‫traccia dello stack e non la inquinerà.
‫Va
‫bene, quindi mettiamolo qui, e
‫sì, quindi questa è la nostra classe
‫AppError, quindi ora esportiamola da qui.
‫Quindi, modulo. exports è ovviamente AppError.
‫Fantastico, solo una domanda che potresti avere è "Perché
‫non l'ho impostato. messaggio uguale a messaggio? ' Bene,
‫è solo perché proprio qui ho chiamato la
‫classe genitore, giusto, e la classe genitore
‫è errore, e qualunque cosa passiamo in essa
‫sarà la proprietà del messaggio.
‫Quindi, proprio come ti ho detto prima.
‫E quindi, fondamentalmente, qui facendo questa chiamata genitore abbiamo già impostato
‫la proprietà del messaggio sul nostro
‫messaggio in arrivo.
‫Va bene, salvalo e ora possiamo chiuderlo, non
‫ne abbiamo più
‫bisogno, e qui lo importeremo qui.
‫Const AppError,
‫require,
‫e poi è
‫in utils, quindi Utilities e appError, okay, e
‫quindi ora andiamo avanti e usiamolo.
‫Commenta questo pezzo di codice
‫ed effettivamente elimina quello che avevamo prima,
‫e questo ora
‫creerà l'errore proprio qui all'interno del prossimo.
‫Quindi, nuovo AppError, e poi
‫il messaggio, che è
‫questo, e il codice
‫di stato.
‫Giusto, e il fallimento, ricorda,
‫verrà automaticamente risolto, quindi cancelliamo tutto questo, salviamolo
‫qui e
‫ancora una volta, proviamo questo percorso sbagliato, e in
‫effetti otteniamo ancora il nostro stesso
‫errore, e otteniamo anche lo stesso identico stack trace.
‫Ok, e finalmente voglio
‫anche esportare questo middleware qui, ok?
‫Quindi, in pratica, questo gestore
‫perché nel resto della sezione creeremo
‫un paio di funzioni
‫diverse per gestire diversi tipi di errori, quindi voglio
‫che tutte queste
‫funzioni siano tutte nello stesso file, ok?
‫E possiamo dire che tutte queste
‫funzioni che ho appena menzionato sono gestori, ok,
‫quindi gestori, li chiamiamo anche controller nel
‫contesto dell'architettura MVC, quindi ora creiamo
‫effettivamente un file
‫controller di errore nella nostra cartella controller.
‫Ok, e questo potrebbe sembrare o sembrare un po' strano perché in
‫realtà non abbiamo una risorsa di errore ok, quindi
‫probabilmente alcune persone non saranno d'accordo con me
‫sul fatto che questo sia il
‫posto corretto, ma personalmente mi piace farlo in
‫questo modo perché
‫a alla fine della giornata, queste funzioni,
‫sono un po' per controllare i nostri
‫errori, va bene, e quindi almeno
‫per me ha senso chiamare semplicemente questa funzione qui il controller
‫degli errori, e qui volevo incollare quella funzione middleware ,
‫ma immagino di non averlo copiato, quindi ripetiamolo.
‫Va bene, quindi in realtà esporterò questo
‫qui come modulo. exports perché
‫le altre funzioni
‫handle che creeremo in
‫seguito, non le esporterò da qui.
‫Quindi saranno solo un po' di aiuto.
‫Quindi, modulo. exports è uguale a questa funzione, ok?
‫In realtà, liberiamoci di questa console. accedi qui,
‫salvalo e ora di nuovo nella nostra
‫app, ovviamente ora dobbiamo collegare
‫quella funzione middleware qui.
‫Quindi, andiamo di nuovo avanti e
‫importiamolo e posso chiamarlo
‫come
‫voglio, quindi lascia che
‫lo chiami globalErrorHandler con
‫la H
‫maiuscola, e richiederò controller ed errorController.
‫Rimettilo qui, e ora per il test finale
‫dopo questo refactoring.
‫Vediamo, e in effetti
‫ancora una volta, tutto funziona bene, ok?
‫Quindi, perfetto, questo era l'obiettivo di questo video, ci
‫vediamo nel prossimo.