‫Man: In questo video, ora implementeremo il
‫middleware di gestione degli errori globale di cui abbiamo
‫appena parlato prima.
‫Quindi ricorda che l'obiettivo
‫è scrivere una funzione middleware, che
‫sarà in grado di gestire errori operativi come questo.
‫Ok, quindi quando un utente colpisce un URL che non esiste,
‫mentre possiamo considerarlo un errore operativo, e
‫in questo caso lo gestiamo inviando
‫questa risposta qui, giusto?
‫Ma ancora una volta, l'obiettivo è farlo in un posto centrale.
‫Ad esempio, abbiamo cose simili qui.
‫Quindi dappertutto qui abbiamo questi frammenti qui,
‫che gestiscono gli errori.
‫Quindi dobbiamo colpire il blocco etch qui, e se
‫c'è un errore, beh, allora
‫lo gestiamo inviando quell'errore al client.
‫E così di nuovo, alla fine,
‫vogliamo sbarazzarci di tutto questo e gestire l'errore
‫in un middleware centrale.
‫E quindi iniziamo ora costruendo
‫effettivamente quella funzione middleware.
‫E in Express, in realtà è molto semplice.
‫Ricorda come ti ho detto che Express
‫viene già fornito con gestori di
‫middleware pronti all'uso.
‫Quindi, come sempre, iniziamo utilizzando l'app. use, okay, e poi
‫qui definiamo la nostra funzione middleware.
‫Quindi, per definire un middleware di
‫gestione degli errori, tutto ciò che dobbiamo fare è
‫fornire alla funzione middleware quattro argomenti e Express lo
‫riconoscerà automaticamente come middleware di gestione degli errori.
‫E quindi, chiamalo solo quando c'è un errore.
‫E così, proprio come in molti altri casi,
‫questa funzione middleware è una prima funzione errore,
‫il che significa
‫che il
‫primo argomento è l'errore, e quindi abbiamo richiesta, risposta e poi.
‫Quindi, specificando quattro parametri, Express riconosce automaticamente che
‫l'intera funzione qui è un middleware
‫di gestione degli errori.
‫Quindi ora implementiamo il codice per questa funzione qui e successivamente ti
‫mostrerò come possiamo effettivamente creare un
‫errore in modo che questa funzione middleware venga
‫effettivamente catturata.
‫Quindi due passaggi, prima creiamo il middleware, quindi nel
‫secondo passaggio creeremo effettivamente
‫un errore in modo che questa funzione venga catturata.
‫E per ora, manteniamo le cose molto semplici qui.
‫Quindi tutto ciò che vogliamo veramente fare
‫per gestire questo errore è inviare una risposta al client.
‫Quindi ris. stato, ma ora
‫non sappiamo davvero quale codice di stato sia, giusto?
‫Quindi, ad esempio, in questo caso qui è un 404, ma
‫abbiamo alcuni errori qui, che hanno altri codici di stato.
‫Ad esempio, abbiamo un 400 per una cattiva richiesta o davvero
‫tutti i tipi di altri codici.
‫E quindi in realtà vogliamo
‫leggere quel codice di stato dall'oggetto errore, ok?
‫Quindi, quando creeremo quell'errore un po'
‫più avanti nel secondo
‫passaggio, come ti ho detto, definiremo questo codice di stato sull'errore.
‫Quindi diciamo codice di stato, e ora voglio definire un
‫valore predefinito qui.
‫Perché ci saranno errori che non provengono da
‫noi perché ci saranno errori senza un
‫codice di stato, quindi errori che non sono
‫stati creati da noi, ma per esempio in alcuni altri
‫posti nell'applicazione delle note.
‫E so che per ora suona un po'
‫confuso, ma vedrai in questa sezione.
‫Per ora definiamo davvero questo codice di stato
‫predefinito.
‫Quindi diciamo che l'errore. statuscode è
‫uguale a err. statuscode fondamentalmente se è definito
‫o il codice 500, che significa di nuovo, errore interno del server,
‫e quindi questo è di solito lo
‫standard che usiamo.
‫E allo stesso modo, definiamo anche lo stato,
‫quindi diciamo errore. lo stato è uguale a errore. status se è definito
‫e in caso contrario è
‫errore.
‫Quindi l'errore, ricorda, è quando abbiamo un codice di stato 500 e se è
‫un codice di stato 400, allora è un errore.
‫Quindi, ad esempio, qui in questo 404 , lo stato è fail.
‫E quindi ora qui
‫possiamo quindi usarlo, quindi errore. statuscode, e quindi inviare del json, quindi molto
‫simile a quello che abbiamo fatto prima.
‫Quindi iniziamo con lo stato e lo leggiamo dall'errore. stato e
‫il messaggio verrà anche dall'errore.
‫Quindi sbaglia. messaggio e ti mostrerò in un
‫secondo come si sbaglia. la proprietà del messaggio qui viene creata.
‫Va bene, ma per ora questo è il nostro middleware molto semplice
‫per la gestione degli errori.
‫Quindi molto semplice, ma per ora funziona.
‫E così ora il secondo passaggio, in
‫cui creiamo effettivamente un errore.
‫E quindi facciamolo qui.
‫Quindi proprio qui in quella funzione, che gestisce
‫tutti i percorsi non gestiti, quindi lasciami
‫commentare questo qui e invece vogliamo creare un errore.
‫Quindi diciamo const err ed
‫è un nuovo errore.
‫Quindi fondamentalmente usiamo il costruttore di errori integrato
‫per creare un errore.
‫E ora possiamo passare una stringa e quella stringa
‫sarà quindi la proprietà del messaggio di errore.
‫Quindi di cosa abbiamo appena parlato quaggiù.
‫Quindi quel messaggio dovrebbe essere questo messaggio.
‫Tutto ok?
‫E poi dovrebbe dire errare. stato che
‫è
‫fail e quindi err. statusCode è uguale a 404.
‫Quindi è quello che ho menzionato prima che possiamo definire
‫il codice di stato e lo stato sull'oggetto errore.
‫E quindi è esattamente quello che stiamo facendo qui.
‫Stiamo creando un errore e quindi definiamo
‫lo stato e le proprietà del codice di stato su di esso in
‫modo che il nostro middleware di
‫gestione degli errori possa utilizzarli nel passaggio successivo.
‫Ma ora, come leggiamo effettivamente il passaggio successivo?
‫Quindi il prossimo middleware.
‫Bene, come sempre, usiamo next.
‫Ma questa volta usiamo next in un modo speciale.
‫Perché ora dobbiamo effettivamente passare quell'errore
‫al prossimo, quindi se la funzione successiva riceve
‫un argomento, non importa quale sia,
‫Express saprà automaticamente che c'è stato un errore, quindi
‫presumerà che qualunque cosa passiamo al prossimo sarà
‫un errore.
‫E questo vale per ogni funzione successiva in ogni singolo
‫middleware in qualsiasi punto della nostra applicazione.
‫Quindi, di nuovo, ogni volta che passiamo qualcosa al prossimo,
‫presumerà che si tratti di un errore, quindi
‫salterà tutti gli altri middleware nello stack del
‫middleware e invierà l'errore che abbiamo passato al nostro
‫middleware di gestione degli errori globale, che sarà
‫quindi , ovviamente, essere eseguito.
‫E quindi ora passiamo all'errore
‫che salterà di nuovo, tutti gli
‫altri middleware nello stack e andiamo direttamente a questo.
‫Ora, in questo caso, in
‫realtà non c'è nessun altro middleware nel mezzo, ok?
‫Quindi è davvero solo il prossimo
‫qui, ma se dovessimo usare next e passare un errore
‫da qualche altra parte, ovviamente funzionerà allo stesso modo.
‫E quindi ora proviamo tutto questo semplicemente
‫provando ad accedere a un percorso che non è stato definito.
‫E quindi questo attiverà tutto questo codice qui, passerà al
‫middleware di gestione degli errori e quindi invierà
‫la risposta in base a tutta questa
‫logica qui.
‫Quindi, qui abbiamo ancora il nostro percorso sbagliato o inesistente
‫e iniziamo chiamando effettivamente questo, che
‫dovrebbe ancora funzionare, ok,
‫quindi solo per confermare
‫che tutto funziona bene e funziona, e
‫ora questo.
‫E in effetti non riusciamo a trovare i tour slash dell'API su questo server, quindi
‫il nostro middleware di gestione degli errori globale sta
‫effettivamente facendo il suo lavoro.
‫Perfetto, questo è il primo passo per implementare davvero un
‫meccanismo di gestione degli errori molto migliore
‫nella nostra applicazione.
‫Quindi ora potremmo andare avanti e provare a implementare
‫questo tipo di cose qui, ovunque in tutti i
‫nostri gestori.
‫Ad esempio, qui in tutte queste funzioni che abbiamo
‫qui.
‫Quindi sostituendo tutto ciò che abbiamo qui con
‫questo tipo di errore.
‫Ma quello che voglio fare per ora è creare effettivamente
‫la nostra classe di errore.
‫In modo che non dobbiamo scrivere tutto questo codice qui
‫e abbiamo invece una classe più simile a
‫noi stessi.
‫Quindi questa è una pratica comune, quindi facciamolo nel
‫prossimo video.