‫Istruttore: In questa lezione, implementiamo un modo migliore
‫per rilevare gli errori in tutte le nostre funzioni asincrone.
‫Quindi in questo momento, in tutte le
‫nostre funzioni asincrone, abbiamo questi blocchi try catch, giusto?
‫Quindi, ricorda come abbiamo aggiunto a tutte queste funzioni handle questo
‫tentativo e poi questo blocco catch, ok?
‫E quindi tutti hanno questo perché
‫sono tutte funzioni asincrone ed è
‫così che di solito catturiamo gli errori all'interno
‫di una funzione asincrona.
‫Quindi usando un blocco try catch.
‫Ora questo rende il nostro codice davvero disordinato e sfocato, quindi
‫l'obiettivo di questo metodo createTour qui, ad esempio, è
‫semplicemente eseguire questo codice.
‫In realtà non vogliamo scherzare con
‫la gestione degli
‫errori qui, quindi in questo momento abbiamo questi due blocchi
‫extra, prova e cattura, e con questo
‫arriva questo rientro extra qui e
‫così di nuovo, questo fa davvero sembrare il nostro codice non pulito.
‫Non è davvero concentrato.
‫Inoltre, abbiamo molti codici duplicati qui perché
‫in ciascuno di questi
‫gestori abbiamo un blocco catch abbastanza simile.
‫Quindi in tutto questo, tutto ciò
‫che stiamo facendo è davvero inviare questa risposta.
‫E quella risposta in realtà non verrebbe nemmeno inviata
‫qui, ma invece nel nostro middleware di gestione degli errori globale, ricorda,
‫ma questo è un altro argomento.
‫Per ora, quello che sto
‫cercando di mettere a fuoco qui
‫è che questi blocchi try catch all'interno di ciascuna delle nostre funzioni
‫asincrone non sono l'ideale e quindi ora proviamo a risolverlo.
‫E la soluzione è fondamentalmente portare il blocco try catch
‫fuori da qui e metterlo a un livello
‫superiore in un'altra funzione.
‫Quindi fondamentalmente ciò che
‫faremo è
‫creare una funzione e quindi avvolgere questa funzione asincrona in quella funzione.
‫Tutto ok?
‫E quindi fammi chiamare quello catchAsync.
‫Quindi catchAsync, e lo chiamo in questo modo
‫perché l'obiettivo di questa
‫funzione è semplicemente catturare i nostri errori asincroni.
‫Così semplice, vero?
‫Quindi in questa
‫funzione catchAsync, passeremo una funzione, ok?
‫E ricorda, la funzione che passeremo
‫è fondamentalmente questa.
‫Quindi, ora che stiamo lavorando con questo
‫esempio, la funzione che passeremo a catchAsync è questa
‫funzione perché è qui che vogliamo
‫catturare gli errori asincroni.
‫Quindi facciamolo davvero.
‫Quindi fn, e poi avvolgi l'intera funzione lì dentro.
‫Quindi, quello che dobbiamo fare è
‫chiamare effettivamente questa funzione qui.
‫Quindi chiamalo e questa funzione
‫dovrebbe ricevere richiesta, risposta e in effetti anche successiva.
‫Quindi questo qui dovrebbe effettivamente avere anche next e anche
‫tutti gli altri,
‫perché ricorda, abbiamo bisogno della funzione
‫successiva per passarci l'errore in modo
‫che quell'errore possa essere gestito
‫nel middleware di gestione degli errori globale.
‫Quindi tutte queste funzioni avranno bisogno di
‫richiesta, risposta e il prossimo.
‫Ma lo lasciamo per dopo.
‫Per ora, concentriamoci sul nostro catchAsync qui.
‫Quindi questa funzione qui che abbiamo passato ad async,
‫che ora si chiama fn qui,
‫è una funzione asincrona.
‫E ricorda che le
‫funzioni asincrone restituiscono le promesse, giusto?
‫E quando c'è un errore all'interno di
‫una funzione asincrona, ciò significa sostanzialmente che la promessa viene rifiutata.
‫E così quassù, dove chiamiamo effettivamente quella
‫funzione, possiamo rilevare quell'errore.
‫Quindi lo prendiamo qui, invece
‫di prenderlo nel blocco try catch.
‫Quindi cattura, ed errore, e poi avanti, e passa l'errore.
‫E possiamo
‫semplificarlo, ma per ora rimuoviamo il blocco try catch
‫qui, e quindi concentriamoci semplicemente su questo pezzo.
‫Quindi questo è
‫tutto ciò che vogliamo e non abbiamo più bisogno del
‫blocco try catch, di nuovo, perché quel catch è ora sostanzialmente
‫trasferito qui, su questa linea.
‫Non è più un
‫blocco catch, perché qui è solo
‫più semplice usare la promessa che restituisce la funzione fn.
‫Quindi di nuovo, questa funzione fn è questa funzione,
‫quindi quella che abbiamo passato a catchAsync,
‫e quindi restituirà una promessa.
‫E in effetti, ho notato che
‫questo, ovviamente, dovrebbe essere chiamato catchAsync, va bene?
‫E quindi quella funzione
‫che abbiamo passato a catchAsync, questa è ovviamente fn.
‫Tutto ok?
‫Quindi l'argomento che abbiamo passato lì dentro.
‫Ora ci sono in realtà due grossi problemi con
‫il modo in cui questo viene implementato
‫in questo momento e quindi in questo modo non funzionerebbe affatto.
‫Quindi, prima, questa chiamata di funzione
‫qui non ha modo di conoscere la richiesta, la risposta e la successiva.
‫Non li abbiamo passati in catchAsync qui, quindi in
‫realtà non c'è modo
‫per la funzione di conoscere i valori di questi parametri.
‫E secondo è che
‫proprio qui stiamo effettivamente chiamando la funzione asincrona.
‫E per vederlo un po' meglio,
‫liberiamoci completamente di questo codice.
‫Quindi qui abbiamo catchAsync e lo chiamiamo ovviamente
‫usando le parentesi.
‫E poi all'interno di catchAsync stiamo anche
‫chiamando subito la funzione fn, e non
‫è così che dovrebbe funzionare.
‫Quindi createTour qui dovrebbe essere davvero una funzione ma
‫non il risultato della chiamata di una funzione.
‫Ma è proprio ora che sta succedendo.
‫Quindi in questo momento
‫viene chiamato catchAsync, che quindi chiama questa funzione qui, ok?
‫E così di nuovo, questa funzione non dovrebbe
‫essere chiamata, ma dovrebbe stare qui e
‫aspettare che express la chiami.
‫E express lo chiamerà
‫ovviamente non appena qualcuno raggiunge il
‫percorso che necessita di questa funzione di controllo.
‫E quindi la soluzione è fondamentalmente fare in modo che
‫la funzione catchAsync restituisca un'altra funzione che verrà quindi
‫assegnata a createTour e in modo che tale
‫funzione possa essere
‫chiamata in seguito quando necessario.
‫Quindi facciamolo qui.
‫Quindi restituiamo una funzione anonima e quindi
‫ricordiamo che questa è la
‫funzione che express chiamerà.
‫E quindi qui è dove
‫specifichiamo la richiesta, la risposta e il prossimo.
‫In realtà manca la freccia qui.
‫E va bene.
‫Ed è proprio così.
‫Questa è la nostra funzione catchAsync.
‫Ricorda solo come ho detto
‫che potremmo semplificarlo ed è solo
‫perché, in JavaScript, possiamo semplificarlo in questo
‫modo, quindi tutto ciò che dobbiamo passare qui
‫è la funzione, e verrà quindi chiamata
‫automaticamente con il parametro che riceve questa callback.
‫Quindi è come scrivere dopo.
‫Quindi ricapitoliamo qui.
‫Quindi, per eliminare i blocchi try catch, abbiamo
‫semplicemente avvolto la nostra funzione
‫asincrona all'interno della funzione catchAsync che abbiamo appena creato.
‫Questa funzione restituirà quindi una nuova funzione
‫anonima, che
‫è questa qui, che verrà quindi assegnata a createTour.
‫E quindi fondamentalmente è questa funzione
‫qui che verrà chiamata non appena un
‫nuovo tour dovrebbe essere creato usando il gestore createTour.
‫Ed ecco perché ha la stessa identica
‫firma qui di questa funzione asincrona, con richiesta, risposta e successiva.
‫Ora, ciò che farà questa funzione
‫qui è che chiamerà la
‫funzione che abbiamo passato inizialmente, quindi
‫questa qui, e
‫quindi eseguirà tutto il codice che è lì dentro.
‫Ora poiché qui è una funzione asincrona,
‫restituirà una promessa e
‫quindi, nel caso in cui ci sia un errore in
‫questa promessa o in altre parole, nel caso
‫venga rifiutata, possiamo quindi rilevare l'errore che si
‫è verificato utilizzando il metodo catch che è disponibile su tutte le promesse.
‫E alla fine, è questo metodo catch qui
‫che passerà l'errore alla funzione successiva che farà in
‫modo che il nostro errore
‫finisca nel nostro middleware di gestione degli errori globale.
‫Quindi questo qui, questa riga di codice,
‫è davvero dove avviene tutta la magia, e
‫questo è, infatti, ciò che
‫ci permette di sbarazzarci del blocco catch che avevamo in precedenza.
‫E una
‫nota: è abbastanza complicato da avvolgere la testa e nel
‫caso in cui non sia chiaro al 100%,
‫non preoccuparti, non è poi così importante.
‫In realtà si tratta solo di capire come
‫funziona esattamente il codice asincrono dietro le quinte in JavaScript.
‫Quindi non si tratta tanto di express o Node. js, si tratta
‫più di come funziona il codice asincrono.
‫Ora comunque, se ora creiamo un nuovo
‫tour e si
‫verifica qualche errore, ad esempio, da un
‫input non valido, allora quell'errore dovrebbe ovviamente essere catturato
‫qui in questa funzione catch,
‫e verrà quindi propagato al nostro middleware di gestione
‫degli errori e in modo che uno invierà quindi la risposta
‫di errore che ci si aspetta di ricevere.
‫E quindi ora proviamolo davvero.
‫Quindi crea un nuovo tour.
‫Qui abbiamo il
‫corpo e ora eliminiamo uno di questi campi obbligatori.
‫Tutto bene.
‫E così dovrebbe innescare un errore, e quindi vediamo.
‫E in effetti, la nostra convalida del tour non è
‫riuscita, che è esattamente il
‫messaggio di errore che dovevamo ricevere.
‫Ora qui, vedi questo errore del server interno 500, che è semplicemente dovuto
‫al fatto che in questo momento l'errore
‫che è stato propagato al middleware
‫di gestione degli errori
‫non aveva alcun codice di stato specificato e
‫quindi ricorda che il nostro valore predefinito è 500 e
‫quindi questo è quello che è stato poi rimandato indietro.
‫E, naturalmente, dobbiamo risolverlo e
‫lo faremo in una lezione successiva di questo corso.
‫Per ora, ciò che conta qui
‫è che in primo luogo, la nostra funzione catchAsync funziona esattamente
‫come previsto e, in secondo luogo, che l'errore è stato effettivamente
‫propagato, quindi è stato rilevato dal nostro middleware di gestione
‫degli errori globale che ha quindi inviato questa risposta al client.
‫Ora andiamo avanti ed esportiamo questa funzione
‫di cattura nel proprio file.
‫Quindi lo prendo da qui
‫e creerò solo un altro file nella
‫nostra cartella delle utilità.
‫Quindi catchAsync. js.
‫E qui, modulo. le esportazioni dovrebbero essere proprio questo.
‫E quindi dovrebbe funzionare bene.
‫Nel nostro tour controller,
‫ovviamente, ora dobbiamo importare questa funzione.
‫E come al solito, dobbiamo andare su una
‫cartella e poi nella nostra cartella delle
‫utilità e poi catchAsync.
‫Bene, e ora tutto
‫ciò che dobbiamo fare è sbarazzarci di
‫tutti questi blocchi catch e avvolgere tutti i gestori in catchAsync.
‫Quindi facciamolo.
‫Prima fai l'avvolgimento e poi sbarazzati di questi blocchi.
‫Dagli un salvataggio per riformattare e ci siamo.
‫E ora è semplicemente un processo di ripetizione
‫fino a quando tutti i tour, o, scusa, fino a
‫quando tutti i gestori non sono finiti.
‫Ok, salvataggio veloce.
‫Questo è già fatto.
‫Il prossimo è l'aggiornamento.
‫E solo un altro mancante.
‫O in realtà, non è vero.
‫Laggiù abbiamo ancora più funzioni asincrone.
‫Quindi ci libereremo del trucco e della prova qui.
‫E credo che questo sia l'ultimo.
‫E sì, in effetti lo è.
‫Bene, ora un'altra cosa che
‫dobbiamo fare è aggiungere anche qui accanto a tutti loro.
‫Ma ovviamente non in maiuscolo.
‫Bene.
‫E mi permetta di selezionarli tutti qui in
‫modo che dovrò scriverlo solo una volta.
‫E così questo lo ha aggiunto a tutti loro.
‫E quindi ora immagino che abbiamo finito con questa parte.
‫Proviamolo di nuovo molto velocemente, non con questo,
‫ma qui con, non anche con
‫questo, quindi abbiamo finito.
‫E proverò a fare
‫un tour ma con un ID non valido, quindi vediamo cosa succede qui.
‫E infatti, riceviamo il nostro messaggio di
‫errore e di nuovo con il codice di stato
‫500, che non è corretto,
‫ricorda, ma ce
‫ne occuperemo in un secondo momento.
‫Quindi in questo momento, lascia che ti mostri
‫che qui è da dove viene il 500 perché in questo momento
‫non c'è alcun codice di stato
‫all'interno dell'errore che otteniamo perché
‫questi errori, in realtà provengono da Mongoose e quindi non
‫abbiamo modo di
‫aggiungere uno stato codice a questi errori.
‫O in realtà, ovviamente, potremmo farlo, ma sarebbe
‫ancora più confuso e quindi troveremo
‫un altro modo più avanti in
‫questa sezione.
‫Per ora, sono davvero contento del risultato che abbiamo qui
‫e quindi è tutto per questa lezione.