1
00:00:01,150 --> 00:00:03,310
‫Man: In questo video, ora implementeremo il

2
00:00:03,310 --> 00:00:06,080
‫middleware di gestione degli errori globale di cui abbiamo

3
00:00:06,080 --> 00:00:07,483
‫appena parlato prima.

4
00:00:09,020 --> 00:00:11,280
‫Quindi ricorda che l'obiettivo

5
00:00:11,280 --> 00:00:13,650
‫è scrivere una funzione middleware, che

6
00:00:13,650 --> 00:00:17,690
‫sarà in grado di gestire errori operativi come questo.

7
00:00:17,690 --> 00:00:22,010
‫Ok, quindi quando un utente colpisce un URL che non esiste,

8
00:00:22,010 --> 00:00:24,890
‫mentre possiamo considerarlo un errore operativo, e

9
00:00:24,890 --> 00:00:27,590
‫in questo caso lo gestiamo inviando

10
00:00:27,590 --> 00:00:29,630
‫questa risposta qui, giusto?

11
00:00:29,630 --> 00:00:33,320
‫Ma ancora una volta, l'obiettivo è farlo in un posto centrale.

12
00:00:33,320 --> 00:00:37,200
‫Ad esempio, abbiamo cose simili qui.

13
00:00:37,200 --> 00:00:39,870
‫Quindi dappertutto qui abbiamo questi frammenti qui,

14
00:00:39,870 --> 00:00:41,950
‫che gestiscono gli errori.

15
00:00:41,950 --> 00:00:45,270
‫Quindi dobbiamo colpire il blocco etch qui, e se

16
00:00:45,270 --> 00:00:47,460
‫c'è un errore, beh, allora

17
00:00:47,460 --> 00:00:50,083
‫lo gestiamo inviando quell'errore al client.

18
00:00:51,290 --> 00:00:53,520
‫E così di nuovo, alla fine,

19
00:00:53,520 --> 00:00:56,170
‫vogliamo sbarazzarci di tutto questo e gestire l'errore

20
00:00:56,170 --> 00:00:57,900
‫in un middleware centrale.

21
00:00:57,900 --> 00:01:00,556
‫E quindi iniziamo ora costruendo

22
00:01:00,556 --> 00:01:02,800
‫effettivamente quella funzione middleware.

23
00:01:02,800 --> 00:01:05,470
‫E in Express, in realtà è molto semplice.

24
00:01:05,470 --> 00:01:07,580
‫Ricorda come ti ho detto che Express

25
00:01:07,580 --> 00:01:09,540
‫viene già fornito con gestori di

26
00:01:09,540 --> 00:01:10,880
‫middleware pronti all'uso.

27
00:01:10,880 --> 00:01:15,720
‫Quindi, come sempre, iniziamo utilizzando l'app. use, okay, e poi

28
00:01:15,720 --> 00:01:19,210
‫qui definiamo la nostra funzione middleware.

29
00:01:19,210 --> 00:01:21,880
‫Quindi, per definire un middleware di

30
00:01:21,880 --> 00:01:24,870
‫gestione degli errori, tutto ciò che dobbiamo fare è

31
00:01:24,870 --> 00:01:27,980
‫fornire alla funzione middleware quattro argomenti e Express lo

32
00:01:27,980 --> 00:01:30,740
‫riconoscerà automaticamente come middleware di gestione degli errori.

33
00:01:30,740 --> 00:01:33,653
‫E quindi, chiamalo solo quando c'è un errore.

34
00:01:34,556 --> 00:01:38,220
‫E così, proprio come in molti altri casi,

35
00:01:38,220 --> 00:01:41,740
‫questa funzione middleware è una prima funzione errore,

36
00:01:41,740 --> 00:01:43,330
‫il che significa

37
00:01:43,330 --> 00:01:44,483
‫che il

38
00:01:45,930 --> 00:01:50,563
‫primo argomento è l'errore, e quindi abbiamo richiesta, risposta e poi.

39
00:01:51,975 --> 00:01:55,280
‫Quindi, specificando quattro parametri, Express riconosce automaticamente che

40
00:01:55,280 --> 00:01:57,750
‫l'intera funzione qui è un middleware

41
00:01:57,750 --> 00:02:00,150
‫di gestione degli errori.

42
00:02:00,150 --> 00:02:04,150
‫Quindi ora implementiamo il codice per questa funzione qui e successivamente ti

43
00:02:04,150 --> 00:02:06,400
‫mostrerò come possiamo effettivamente creare un

44
00:02:06,400 --> 00:02:09,000
‫errore in modo che questa funzione middleware venga

45
00:02:09,000 --> 00:02:09,930
‫effettivamente catturata.

46
00:02:09,930 --> 00:02:13,450
‫Quindi due passaggi, prima creiamo il middleware, quindi nel

47
00:02:13,450 --> 00:02:15,130
‫secondo passaggio creeremo effettivamente

48
00:02:15,130 --> 00:02:18,700
‫un errore in modo che questa funzione venga catturata.

49
00:02:18,700 --> 00:02:20,943
‫E per ora, manteniamo le cose molto semplici qui.

50
00:02:20,943 --> 00:02:23,590
‫Quindi tutto ciò che vogliamo veramente fare

51
00:02:23,590 --> 00:02:27,100
‫per gestire questo errore è inviare una risposta al client.

52
00:02:27,100 --> 00:02:29,893
‫Quindi ris. stato, ma ora

53
00:02:31,170 --> 00:02:35,100
‫non sappiamo davvero quale codice di stato sia, giusto?

54
00:02:35,100 --> 00:02:38,420
‫Quindi, ad esempio, in questo caso qui è un 404, ma

55
00:02:38,420 --> 00:02:41,650
‫abbiamo alcuni errori qui, che hanno altri codici di stato.

56
00:02:41,650 --> 00:02:46,020
‫Ad esempio, abbiamo un 400 per una cattiva richiesta o davvero

57
00:02:46,020 --> 00:02:48,823
‫tutti i tipi di altri codici.

58
00:02:50,903 --> 00:02:53,142
‫E quindi in realtà vogliamo

59
00:02:53,142 --> 00:02:56,113
‫leggere quel codice di stato dall'oggetto errore, ok?

60
00:02:57,480 --> 00:02:59,650
‫Quindi, quando creeremo quell'errore un po'

61
00:02:59,650 --> 00:03:01,143
‫più avanti nel secondo

62
00:03:01,143 --> 00:03:04,504
‫passaggio, come ti ho detto, definiremo questo codice di stato sull'errore.

63
00:03:04,504 --> 00:03:08,943
‫Quindi diciamo codice di stato, e ora voglio definire un

64
00:03:10,533 --> 00:03:11,962
‫valore predefinito qui.

65
00:03:11,962 --> 00:03:14,620
‫Perché ci saranno errori che non provengono da

66
00:03:14,620 --> 00:03:17,090
‫noi perché ci saranno errori senza un

67
00:03:17,090 --> 00:03:19,590
‫codice di stato, quindi errori che non sono

68
00:03:19,590 --> 00:03:22,750
‫stati creati da noi, ma per esempio in alcuni altri

69
00:03:22,750 --> 00:03:24,240
‫posti nell'applicazione delle note.

70
00:03:24,240 --> 00:03:26,640
‫E so che per ora suona un po'

71
00:03:26,640 --> 00:03:28,770
‫confuso, ma vedrai in questa sezione.

72
00:03:28,770 --> 00:03:31,790
‫Per ora definiamo davvero questo codice di stato

73
00:03:31,790 --> 00:03:32,623
‫predefinito.

74
00:03:33,550 --> 00:03:36,959
‫Quindi diciamo che l'errore. statuscode è

75
00:03:36,959 --> 00:03:40,446
‫uguale a err. statuscode fondamentalmente se è definito

76
00:03:40,446 --> 00:03:45,230
‫o il codice 500, che significa di nuovo, errore interno del server,

77
00:03:45,230 --> 00:03:48,140
‫e quindi questo è di solito lo

78
00:03:48,140 --> 00:03:49,763
‫standard che usiamo.

79
00:03:50,660 --> 00:03:54,820
‫E allo stesso modo, definiamo anche lo stato,

80
00:03:54,820 --> 00:03:59,820
‫quindi diciamo errore. lo stato è uguale a errore. status se è definito

81
00:04:01,350 --> 00:04:03,713
‫e in caso contrario è

82
00:04:04,670 --> 00:04:05,760
‫errore.

83
00:04:05,760 --> 00:04:10,120
‫Quindi l'errore, ricorda, è quando abbiamo un codice di stato 500 e se è

84
00:04:10,120 --> 00:04:13,033
‫un codice di stato 400, allora è un errore.

85
00:04:13,926 --> 00:04:16,723
‫Quindi, ad esempio, qui in questo 404 , lo stato è fail.

86
00:04:18,597 --> 00:04:20,960
‫E quindi ora qui

87
00:04:20,960 --> 00:04:25,960
‫possiamo quindi usarlo, quindi errore. statuscode, e quindi inviare del json, quindi molto

88
00:04:27,100 --> 00:04:29,363
‫simile a quello che abbiamo fatto prima.

89
00:04:30,320 --> 00:04:34,830
‫Quindi iniziamo con lo stato e lo leggiamo dall'errore. stato e

90
00:04:37,010 --> 00:04:40,473
‫il messaggio verrà anche dall'errore.

91
00:04:41,380 --> 00:04:44,970
‫Quindi sbaglia. messaggio e ti mostrerò in un

92
00:04:44,970 --> 00:04:48,223
‫secondo come si sbaglia. la proprietà del messaggio qui viene creata.

93
00:04:49,750 --> 00:04:52,700
‫Va bene, ma per ora questo è il nostro middleware molto semplice

94
00:04:52,700 --> 00:04:54,000
‫per la gestione degli errori.

95
00:04:55,400 --> 00:04:58,190
‫Quindi molto semplice, ma per ora funziona.

96
00:04:58,190 --> 00:05:00,200
‫E così ora il secondo passaggio, in

97
00:05:00,200 --> 00:05:01,830
‫cui creiamo effettivamente un errore.

98
00:05:01,830 --> 00:05:03,680
‫E quindi facciamolo qui.

99
00:05:03,680 --> 00:05:06,270
‫Quindi proprio qui in quella funzione, che gestisce

100
00:05:06,270 --> 00:05:08,820
‫tutti i percorsi non gestiti, quindi lasciami

101
00:05:08,820 --> 00:05:11,833
‫commentare questo qui e invece vogliamo creare un errore.

102
00:05:12,973 --> 00:05:16,850
‫Quindi diciamo const err ed

103
00:05:18,080 --> 00:05:21,700
‫è un nuovo errore.

104
00:05:21,700 --> 00:05:24,840
‫Quindi fondamentalmente usiamo il costruttore di errori integrato

105
00:05:24,840 --> 00:05:26,600
‫per creare un errore.

106
00:05:26,600 --> 00:05:29,320
‫E ora possiamo passare una stringa e quella stringa

107
00:05:29,320 --> 00:05:31,900
‫sarà quindi la proprietà del messaggio di errore.

108
00:05:31,900 --> 00:05:35,163
‫Quindi di cosa abbiamo appena parlato quaggiù.

109
00:05:37,350 --> 00:05:40,113
‫Quindi quel messaggio dovrebbe essere questo messaggio.

110
00:05:42,920 --> 00:05:43,753
‫Tutto ok?

111
00:05:45,600 --> 00:05:49,600
‫E poi dovrebbe dire errare. stato che

112
00:05:51,680 --> 00:05:52,693
‫è

113
00:05:55,830 --> 00:06:00,450
‫fail e quindi err. statusCode è uguale a 404.

114
00:06:00,450 --> 00:06:03,610
‫Quindi è quello che ho menzionato prima che possiamo definire

115
00:06:03,610 --> 00:06:06,770
‫il codice di stato e lo stato sull'oggetto errore.

116
00:06:06,770 --> 00:06:09,010
‫E quindi è esattamente quello che stiamo facendo qui.

117
00:06:09,010 --> 00:06:10,950
‫Stiamo creando un errore e quindi definiamo

118
00:06:10,950 --> 00:06:14,220
‫lo stato e le proprietà del codice di stato su di esso in

119
00:06:14,220 --> 00:06:15,930
‫modo che il nostro middleware di

120
00:06:15,930 --> 00:06:18,150
‫gestione degli errori possa utilizzarli nel passaggio successivo.

121
00:06:18,150 --> 00:06:20,840
‫Ma ora, come leggiamo effettivamente il passaggio successivo?

122
00:06:20,840 --> 00:06:23,390
‫Quindi il prossimo middleware.

123
00:06:23,390 --> 00:06:26,650
‫Bene, come sempre, usiamo next.

124
00:06:26,650 --> 00:06:29,430
‫Ma questa volta usiamo next in un modo speciale.

125
00:06:29,430 --> 00:06:32,100
‫Perché ora dobbiamo effettivamente passare quell'errore

126
00:06:32,100 --> 00:06:35,190
‫al prossimo, quindi se la funzione successiva riceve

127
00:06:35,190 --> 00:06:37,460
‫un argomento, non importa quale sia,

128
00:06:37,460 --> 00:06:40,680
‫Express saprà automaticamente che c'è stato un errore, quindi

129
00:06:40,680 --> 00:06:43,620
‫presumerà che qualunque cosa passiamo al prossimo sarà

130
00:06:43,620 --> 00:06:44,950
‫un errore.

131
00:06:44,950 --> 00:06:48,300
‫E questo vale per ogni funzione successiva in ogni singolo

132
00:06:48,300 --> 00:06:50,803
‫middleware in qualsiasi punto della nostra applicazione.

133
00:06:51,950 --> 00:06:54,800
‫Quindi, di nuovo, ogni volta che passiamo qualcosa al prossimo,

134
00:06:54,800 --> 00:06:57,250
‫presumerà che si tratti di un errore, quindi

135
00:06:57,250 --> 00:06:59,670
‫salterà tutti gli altri middleware nello stack del

136
00:06:59,670 --> 00:07:02,250
‫middleware e invierà l'errore che abbiamo passato al nostro

137
00:07:02,250 --> 00:07:04,680
‫middleware di gestione degli errori globale, che sarà

138
00:07:04,680 --> 00:07:06,680
‫quindi , ovviamente, essere eseguito.

139
00:07:08,030 --> 00:07:10,090
‫E quindi ora passiamo all'errore

140
00:07:10,090 --> 00:07:12,350
‫che salterà di nuovo, tutti gli

141
00:07:12,350 --> 00:07:15,393
‫altri middleware nello stack e andiamo direttamente a questo.

142
00:07:16,850 --> 00:07:18,430
‫Ora, in questo caso, in

143
00:07:18,430 --> 00:07:21,210
‫realtà non c'è nessun altro middleware nel mezzo, ok?

144
00:07:21,210 --> 00:07:23,060
‫Quindi è davvero solo il prossimo

145
00:07:23,060 --> 00:07:25,950
‫qui, ma se dovessimo usare next e passare un errore

146
00:07:25,950 --> 00:07:28,603
‫da qualche altra parte, ovviamente funzionerà allo stesso modo.

147
00:07:29,720 --> 00:07:31,940
‫E quindi ora proviamo tutto questo semplicemente

148
00:07:31,940 --> 00:07:35,077
‫provando ad accedere a un percorso che non è stato definito.

149
00:07:35,077 --> 00:07:38,460
‫E quindi questo attiverà tutto questo codice qui, passerà al

150
00:07:38,460 --> 00:07:41,190
‫middleware di gestione degli errori e quindi invierà

151
00:07:41,190 --> 00:07:43,700
‫la risposta in base a tutta questa

152
00:07:43,700 --> 00:07:44,773
‫logica qui.

153
00:07:47,420 --> 00:07:52,130
‫Quindi, qui abbiamo ancora il nostro percorso sbagliato o inesistente

154
00:07:52,130 --> 00:07:55,220
‫e iniziamo chiamando effettivamente questo, che

155
00:07:55,220 --> 00:07:57,023
‫dovrebbe ancora funzionare, ok,

156
00:07:59,850 --> 00:08:01,650
‫quindi solo per confermare

157
00:08:01,650 --> 00:08:05,050
‫che tutto funziona bene e funziona, e

158
00:08:05,050 --> 00:08:06,810
‫ora questo.

159
00:08:06,810 --> 00:08:11,250
‫E in effetti non riusciamo a trovare i tour slash dell'API su questo server, quindi

160
00:08:11,250 --> 00:08:13,810
‫il nostro middleware di gestione degli errori globale sta

161
00:08:13,810 --> 00:08:15,560
‫effettivamente facendo il suo lavoro.

162
00:08:15,560 --> 00:08:19,560
‫Perfetto, questo è il primo passo per implementare davvero un

163
00:08:19,560 --> 00:08:22,370
‫meccanismo di gestione degli errori molto migliore

164
00:08:22,370 --> 00:08:24,200
‫nella nostra applicazione.

165
00:08:24,200 --> 00:08:26,830
‫Quindi ora potremmo andare avanti e provare a implementare

166
00:08:26,830 --> 00:08:29,460
‫questo tipo di cose qui, ovunque in tutti i

167
00:08:29,460 --> 00:08:30,310
‫nostri gestori.

168
00:08:30,310 --> 00:08:34,160
‫Ad esempio, qui in tutte queste funzioni che abbiamo

169
00:08:34,160 --> 00:08:35,060
‫qui.

170
00:08:35,060 --> 00:08:37,410
‫Quindi sostituendo tutto ciò che abbiamo qui con

171
00:08:37,410 --> 00:08:38,850
‫questo tipo di errore.

172
00:08:38,850 --> 00:08:41,460
‫Ma quello che voglio fare per ora è creare effettivamente

173
00:08:41,460 --> 00:08:42,920
‫la nostra classe di errore.

174
00:08:42,920 --> 00:08:46,330
‫In modo che non dobbiamo scrivere tutto questo codice qui

175
00:08:46,330 --> 00:08:49,280
‫e abbiamo invece una classe più simile a

176
00:08:49,280 --> 00:08:50,113
‫noi stessi.

177
00:08:50,113 --> 00:08:53,350
‫Quindi questa è una pratica comune, quindi facciamolo nel

178
00:08:53,350 --> 00:08:54,283
‫prossimo video.