﻿1
00:00:01,210 --> 00:00:04,370
‫Istruttore: In questa lezione, implementiamo un modo migliore

2
00:00:04,370 --> 00:00:07,853
‫per rilevare gli errori in tutte le nostre funzioni asincrone.

3
00:00:09,310 --> 00:00:12,180
‫Quindi in questo momento, in tutte le

4
00:00:12,180 --> 00:00:15,750
‫nostre funzioni asincrone, abbiamo questi blocchi try catch, giusto?

5
00:00:15,750 --> 00:00:20,430
‫Quindi, ricorda come abbiamo aggiunto a tutte queste funzioni handle questo

6
00:00:20,430 --> 00:00:23,930
‫tentativo e poi questo blocco catch, ok?

7
00:00:23,930 --> 00:00:26,430
‫E quindi tutti hanno questo perché

8
00:00:26,430 --> 00:00:28,900
‫sono tutte funzioni asincrone ed è

9
00:00:28,900 --> 00:00:31,930
‫così che di solito catturiamo gli errori all'interno

10
00:00:31,930 --> 00:00:33,863
‫di una funzione asincrona.

11
00:00:34,800 --> 00:00:37,100
‫Quindi usando un blocco try catch.

12
00:00:37,100 --> 00:00:41,170
‫Ora questo rende il nostro codice davvero disordinato e sfocato, quindi

13
00:00:41,170 --> 00:00:44,740
‫l'obiettivo di questo metodo createTour qui, ad esempio, è

14
00:00:44,740 --> 00:00:46,560
‫semplicemente eseguire questo codice.

15
00:00:46,560 --> 00:00:48,500
‫In realtà non vogliamo scherzare con

16
00:00:48,500 --> 00:00:49,934
‫la gestione degli

17
00:00:49,934 --> 00:00:53,450
‫errori qui, quindi in questo momento abbiamo questi due blocchi

18
00:00:53,450 --> 00:00:55,690
‫extra, prova e cattura, e con questo

19
00:00:55,690 --> 00:00:57,900
‫arriva questo rientro extra qui e

20
00:00:57,900 --> 00:01:01,730
‫così di nuovo, questo fa davvero sembrare il nostro codice non pulito.

21
00:01:01,730 --> 00:01:03,550
‫Non è davvero concentrato.

22
00:01:03,550 --> 00:01:05,940
‫Inoltre, abbiamo molti codici duplicati qui perché

23
00:01:05,940 --> 00:01:07,830
‫in ciascuno di questi

24
00:01:07,830 --> 00:01:10,310
‫gestori abbiamo un blocco catch abbastanza simile.

25
00:01:10,310 --> 00:01:12,250
‫Quindi in tutto questo, tutto ciò

26
00:01:12,250 --> 00:01:14,690
‫che stiamo facendo è davvero inviare questa risposta.

27
00:01:14,690 --> 00:01:17,490
‫E quella risposta in realtà non verrebbe nemmeno inviata

28
00:01:17,490 --> 00:01:20,900
‫qui, ma invece nel nostro middleware di gestione degli errori globale, ricorda,

29
00:01:20,900 --> 00:01:23,010
‫ma questo è un altro argomento.

30
00:01:23,010 --> 00:01:24,910
‫Per ora, quello che sto

31
00:01:24,910 --> 00:01:27,170
‫cercando di mettere a fuoco qui

32
00:01:27,170 --> 00:01:30,840
‫è che questi blocchi try catch all'interno di ciascuna delle nostre funzioni

33
00:01:30,840 --> 00:01:34,010
‫asincrone non sono l'ideale e quindi ora proviamo a risolverlo.

34
00:01:34,010 --> 00:01:37,100
‫E la soluzione è fondamentalmente portare il blocco try catch

35
00:01:37,100 --> 00:01:39,890
‫fuori da qui e metterlo a un livello

36
00:01:39,890 --> 00:01:41,450
‫superiore in un'altra funzione.

37
00:01:41,450 --> 00:01:43,000
‫Quindi fondamentalmente ciò che

38
00:01:43,000 --> 00:01:44,470
‫faremo è

39
00:01:44,470 --> 00:01:49,326
‫creare una funzione e quindi avvolgere questa funzione asincrona in quella funzione.

40
00:01:49,326 --> 00:01:50,630
‫Tutto ok?

41
00:01:50,630 --> 00:01:53,333
‫E quindi fammi chiamare quello catchAsync.

42
00:01:56,960 --> 00:02:00,290
‫Quindi catchAsync, e lo chiamo in questo modo

43
00:02:00,290 --> 00:02:02,380
‫perché l'obiettivo di questa

44
00:02:02,380 --> 00:02:05,410
‫funzione è semplicemente catturare i nostri errori asincroni.

45
00:02:05,410 --> 00:02:06,613
‫Così semplice, vero?

46
00:02:07,500 --> 00:02:09,840
‫Quindi in questa

47
00:02:09,840 --> 00:02:13,660
‫funzione catchAsync, passeremo una funzione, ok?

48
00:02:13,660 --> 00:02:16,820
‫E ricorda, la funzione che passeremo

49
00:02:16,820 --> 00:02:19,030
‫è fondamentalmente questa.

50
00:02:19,030 --> 00:02:21,678
‫Quindi, ora che stiamo lavorando con questo

51
00:02:21,678 --> 00:02:25,420
‫esempio, la funzione che passeremo a catchAsync è questa

52
00:02:25,420 --> 00:02:27,840
‫funzione perché è qui che vogliamo

53
00:02:27,840 --> 00:02:30,033
‫catturare gli errori asincroni.

54
00:02:31,030 --> 00:02:32,563
‫Quindi facciamolo davvero.

55
00:02:34,090 --> 00:02:39,090
‫Quindi fn, e poi avvolgi l'intera funzione lì dentro.

56
00:02:40,950 --> 00:02:43,340
‫Quindi, quello che dobbiamo fare è

57
00:02:43,340 --> 00:02:45,440
‫chiamare effettivamente questa funzione qui.

58
00:02:46,670 --> 00:02:49,640
‫Quindi chiamalo e questa funzione

59
00:02:49,640 --> 00:02:53,810
‫dovrebbe ricevere richiesta, risposta e in effetti anche successiva.

60
00:02:53,810 --> 00:02:57,440
‫Quindi questo qui dovrebbe effettivamente avere anche next e anche

61
00:02:57,440 --> 00:02:58,860
‫tutti gli altri,

62
00:02:58,860 --> 00:03:01,260
‫perché ricorda, abbiamo bisogno della funzione

63
00:03:01,260 --> 00:03:03,540
‫successiva per passarci l'errore in modo

64
00:03:03,540 --> 00:03:05,660
‫che quell'errore possa essere gestito

65
00:03:05,660 --> 00:03:08,470
‫nel middleware di gestione degli errori globale.

66
00:03:08,470 --> 00:03:10,360
‫Quindi tutte queste funzioni avranno bisogno di

67
00:03:10,360 --> 00:03:12,063
‫richiesta, risposta e il prossimo.

68
00:03:12,950 --> 00:03:14,540
‫Ma lo lasciamo per dopo.

69
00:03:14,540 --> 00:03:17,090
‫Per ora, concentriamoci sul nostro catchAsync qui.

70
00:03:19,180 --> 00:03:22,120
‫Quindi questa funzione qui che abbiamo passato ad async,

71
00:03:22,120 --> 00:03:24,290
‫che ora si chiama fn qui,

72
00:03:24,290 --> 00:03:26,040
‫è una funzione asincrona.

73
00:03:26,040 --> 00:03:28,080
‫E ricorda che le

74
00:03:28,080 --> 00:03:30,490
‫funzioni asincrone restituiscono le promesse, giusto?

75
00:03:30,490 --> 00:03:33,500
‫E quando c'è un errore all'interno di

76
00:03:33,500 --> 00:03:37,310
‫una funzione asincrona, ciò significa sostanzialmente che la promessa viene rifiutata.

77
00:03:37,310 --> 00:03:40,160
‫E così quassù, dove chiamiamo effettivamente quella

78
00:03:40,160 --> 00:03:41,893
‫funzione, possiamo rilevare quell'errore.

79
00:03:43,790 --> 00:03:46,040
‫Quindi lo prendiamo qui, invece

80
00:03:46,040 --> 00:03:48,590
‫di prenderlo nel blocco try catch.

81
00:03:48,590 --> 00:03:53,590
‫Quindi cattura, ed errore, e poi avanti, e passa l'errore.

82
00:03:57,040 --> 00:03:58,160
‫E possiamo

83
00:03:58,160 --> 00:04:01,810
‫semplificarlo, ma per ora rimuoviamo il blocco try catch

84
00:04:01,810 --> 00:04:05,103
‫qui, e quindi concentriamoci semplicemente su questo pezzo.

85
00:04:07,580 --> 00:04:08,920
‫Quindi questo è

86
00:04:08,920 --> 00:04:12,110
‫tutto ciò che vogliamo e non abbiamo più bisogno del

87
00:04:12,110 --> 00:04:15,660
‫blocco try catch, di nuovo, perché quel catch è ora sostanzialmente

88
00:04:15,660 --> 00:04:17,113
‫trasferito qui, su questa linea.

89
00:04:18,500 --> 00:04:20,350
‫Non è più un

90
00:04:20,350 --> 00:04:22,560
‫blocco catch, perché qui è solo

91
00:04:22,560 --> 00:04:26,060
‫più semplice usare la promessa che restituisce la funzione fn.

92
00:04:26,060 --> 00:04:29,640
‫Quindi di nuovo, questa funzione fn è questa funzione,

93
00:04:29,640 --> 00:04:32,270
‫quindi quella che abbiamo passato a catchAsync,

94
00:04:32,270 --> 00:04:34,650
‫e quindi restituirà una promessa.

95
00:04:34,650 --> 00:04:37,100
‫E in effetti, ho notato che

96
00:04:37,100 --> 00:04:40,110
‫questo, ovviamente, dovrebbe essere chiamato catchAsync, va bene?

97
00:04:40,110 --> 00:04:41,800
‫E quindi quella funzione

98
00:04:41,800 --> 00:04:45,447
‫che abbiamo passato a catchAsync, questa è ovviamente fn.

99
00:04:45,447 --> 00:04:46,280
‫Tutto ok?

100
00:04:46,280 --> 00:04:48,980
‫Quindi l'argomento che abbiamo passato lì dentro.

101
00:04:48,980 --> 00:04:51,590
‫Ora ci sono in realtà due grossi problemi con

102
00:04:51,590 --> 00:04:54,180
‫il modo in cui questo viene implementato

103
00:04:54,180 --> 00:04:57,240
‫in questo momento e quindi in questo modo non funzionerebbe affatto.

104
00:04:57,240 --> 00:04:59,340
‫Quindi, prima, questa chiamata di funzione

105
00:04:59,340 --> 00:05:03,213
‫qui non ha modo di conoscere la richiesta, la risposta e la successiva.

106
00:05:04,300 --> 00:05:07,460
‫Non li abbiamo passati in catchAsync qui, quindi in

107
00:05:07,460 --> 00:05:09,300
‫realtà non c'è modo

108
00:05:09,300 --> 00:05:12,693
‫per la funzione di conoscere i valori di questi parametri.

109
00:05:13,658 --> 00:05:15,610
‫E secondo è che

110
00:05:15,610 --> 00:05:18,473
‫proprio qui stiamo effettivamente chiamando la funzione asincrona.

111
00:05:20,290 --> 00:05:22,290
‫E per vederlo un po' meglio,

112
00:05:23,200 --> 00:05:24,873
‫liberiamoci completamente di questo codice.

113
00:05:26,370 --> 00:05:29,520
‫Quindi qui abbiamo catchAsync e lo chiamiamo ovviamente

114
00:05:29,520 --> 00:05:31,153
‫usando le parentesi.

115
00:05:32,350 --> 00:05:34,900
‫E poi all'interno di catchAsync stiamo anche

116
00:05:34,900 --> 00:05:37,760
‫chiamando subito la funzione fn, e non

117
00:05:37,760 --> 00:05:40,130
‫è così che dovrebbe funzionare.

118
00:05:40,130 --> 00:05:43,060
‫Quindi createTour qui dovrebbe essere davvero una funzione ma

119
00:05:43,060 --> 00:05:45,840
‫non il risultato della chiamata di una funzione.

120
00:05:45,840 --> 00:05:47,810
‫Ma è proprio ora che sta succedendo.

121
00:05:47,810 --> 00:05:49,940
‫Quindi in questo momento

122
00:05:49,940 --> 00:05:54,310
‫viene chiamato catchAsync, che quindi chiama questa funzione qui, ok?

123
00:05:54,310 --> 00:05:56,890
‫E così di nuovo, questa funzione non dovrebbe

124
00:05:56,890 --> 00:05:59,360
‫essere chiamata, ma dovrebbe stare qui e

125
00:05:59,360 --> 00:06:01,460
‫aspettare che express la chiami.

126
00:06:01,460 --> 00:06:03,310
‫E express lo chiamerà

127
00:06:03,310 --> 00:06:05,400
‫ovviamente non appena qualcuno raggiunge il

128
00:06:05,400 --> 00:06:08,390
‫percorso che necessita di questa funzione di controllo.

129
00:06:08,390 --> 00:06:11,980
‫E quindi la soluzione è fondamentalmente fare in modo che

130
00:06:11,980 --> 00:06:15,030
‫la funzione catchAsync restituisca un'altra funzione che verrà quindi

131
00:06:15,030 --> 00:06:18,060
‫assegnata a createTour e in modo che tale

132
00:06:18,060 --> 00:06:19,640
‫funzione possa essere

133
00:06:19,640 --> 00:06:21,483
‫chiamata in seguito quando necessario.

134
00:06:23,294 --> 00:06:24,394
‫Quindi facciamolo qui.

135
00:06:25,590 --> 00:06:28,480
‫Quindi restituiamo una funzione anonima e quindi

136
00:06:28,480 --> 00:06:30,890
‫ricordiamo che questa è la

137
00:06:30,890 --> 00:06:32,900
‫funzione che express chiamerà.

138
00:06:32,900 --> 00:06:35,380
‫E quindi qui è dove

139
00:06:35,380 --> 00:06:38,423
‫specifichiamo la richiesta, la risposta e il prossimo.

140
00:06:41,120 --> 00:06:43,763
‫In realtà manca la freccia qui.

141
00:06:47,230 --> 00:06:48,480
‫E va bene.

142
00:06:48,480 --> 00:06:49,890
‫Ed è proprio così.

143
00:06:49,890 --> 00:06:52,420
‫Questa è la nostra funzione catchAsync.

144
00:06:52,420 --> 00:06:54,610
‫Ricorda solo come ho detto

145
00:06:54,610 --> 00:06:56,840
‫che potremmo semplificarlo ed è solo

146
00:06:56,840 --> 00:06:59,110
‫perché, in JavaScript, possiamo semplificarlo in questo

147
00:06:59,110 --> 00:07:01,777
‫modo, quindi tutto ciò che dobbiamo passare qui

148
00:07:01,777 --> 00:07:04,020
‫è la funzione, e verrà quindi chiamata

149
00:07:04,020 --> 00:07:06,810
‫automaticamente con il parametro che riceve questa callback.

150
00:07:06,810 --> 00:07:09,263
‫Quindi è come scrivere dopo.

151
00:07:11,500 --> 00:07:13,290
‫Quindi ricapitoliamo qui.

152
00:07:13,290 --> 00:07:16,490
‫Quindi, per eliminare i blocchi try catch, abbiamo

153
00:07:16,490 --> 00:07:19,230
‫semplicemente avvolto la nostra funzione

154
00:07:19,230 --> 00:07:23,010
‫asincrona all'interno della funzione catchAsync che abbiamo appena creato.

155
00:07:23,010 --> 00:07:26,160
‫Questa funzione restituirà quindi una nuova funzione

156
00:07:26,160 --> 00:07:27,690
‫anonima, che

157
00:07:27,690 --> 00:07:31,660
‫è questa qui, che verrà quindi assegnata a createTour.

158
00:07:31,660 --> 00:07:34,200
‫E quindi fondamentalmente è questa funzione

159
00:07:34,200 --> 00:07:36,940
‫qui che verrà chiamata non appena un

160
00:07:36,940 --> 00:07:40,010
‫nuovo tour dovrebbe essere creato usando il gestore createTour.

161
00:07:40,010 --> 00:07:42,960
‫Ed ecco perché ha la stessa identica

162
00:07:42,960 --> 00:07:47,520
‫firma qui di questa funzione asincrona, con richiesta, risposta e successiva.

163
00:07:47,520 --> 00:07:49,740
‫Ora, ciò che farà questa funzione

164
00:07:49,740 --> 00:07:51,320
‫qui è che chiamerà la

165
00:07:51,320 --> 00:07:53,440
‫funzione che abbiamo passato inizialmente, quindi

166
00:07:53,440 --> 00:07:54,990
‫questa qui, e

167
00:07:54,990 --> 00:07:58,270
‫quindi eseguirà tutto il codice che è lì dentro.

168
00:07:58,270 --> 00:08:00,670
‫Ora poiché qui è una funzione asincrona,

169
00:08:00,670 --> 00:08:02,380
‫restituirà una promessa e

170
00:08:02,380 --> 00:08:05,610
‫quindi, nel caso in cui ci sia un errore in

171
00:08:05,610 --> 00:08:08,400
‫questa promessa o in altre parole, nel caso

172
00:08:08,400 --> 00:08:11,090
‫venga rifiutata, possiamo quindi rilevare l'errore che si

173
00:08:11,090 --> 00:08:15,193
‫è verificato utilizzando il metodo catch che è disponibile su tutte le promesse.

174
00:08:16,560 --> 00:08:19,510
‫E alla fine, è questo metodo catch qui

175
00:08:19,510 --> 00:08:22,670
‫che passerà l'errore alla funzione successiva che farà in

176
00:08:22,670 --> 00:08:24,780
‫modo che il nostro errore

177
00:08:24,780 --> 00:08:27,943
‫finisca nel nostro middleware di gestione degli errori globale.

178
00:08:28,890 --> 00:08:31,020
‫Quindi questo qui, questa riga di codice,

179
00:08:31,020 --> 00:08:33,510
‫è davvero dove avviene tutta la magia, e

180
00:08:33,510 --> 00:08:35,440
‫questo è, infatti, ciò che

181
00:08:35,440 --> 00:08:38,893
‫ci permette di sbarazzarci del blocco catch che avevamo in precedenza.

182
00:08:39,770 --> 00:08:40,603
‫E una

183
00:08:40,603 --> 00:08:43,710
‫nota: è abbastanza complicato da avvolgere la testa e nel

184
00:08:43,710 --> 00:08:46,460
‫caso in cui non sia chiaro al 100%,

185
00:08:46,460 --> 00:08:48,943
‫non preoccuparti, non è poi così importante.

186
00:08:49,792 --> 00:08:53,010
‫In realtà si tratta solo di capire come

187
00:08:53,010 --> 00:08:56,460
‫funziona esattamente il codice asincrono dietro le quinte in JavaScript.

188
00:08:56,460 --> 00:09:00,100
‫Quindi non si tratta tanto di express o Node. js, si tratta

189
00:09:00,100 --> 00:09:04,060
‫più di come funziona il codice asincrono.

190
00:09:04,060 --> 00:09:06,560
‫Ora comunque, se ora creiamo un nuovo

191
00:09:06,560 --> 00:09:08,040
‫tour e si

192
00:09:08,040 --> 00:09:10,440
‫verifica qualche errore, ad esempio, da un

193
00:09:10,440 --> 00:09:13,450
‫input non valido, allora quell'errore dovrebbe ovviamente essere catturato

194
00:09:13,450 --> 00:09:15,120
‫qui in questa funzione catch,

195
00:09:15,120 --> 00:09:18,270
‫e verrà quindi propagato al nostro middleware di gestione

196
00:09:18,270 --> 00:09:21,870
‫degli errori e in modo che uno invierà quindi la risposta

197
00:09:21,870 --> 00:09:24,570
‫di errore che ci si aspetta di ricevere.

198
00:09:24,570 --> 00:09:26,973
‫E quindi ora proviamolo davvero.

199
00:09:28,080 --> 00:09:30,500
‫Quindi crea un nuovo tour.

200
00:09:30,500 --> 00:09:32,030
‫Qui abbiamo il

201
00:09:32,030 --> 00:09:35,223
‫corpo e ora eliminiamo uno di questi campi obbligatori.

202
00:09:36,440 --> 00:09:37,273
‫Tutto bene.

203
00:09:37,273 --> 00:09:40,223
‫E così dovrebbe innescare un errore, e quindi vediamo.

204
00:09:41,220 --> 00:09:44,920
‫E in effetti, la nostra convalida del tour non è

205
00:09:44,920 --> 00:09:46,910
‫riuscita, che è esattamente il

206
00:09:46,910 --> 00:09:49,090
‫messaggio di errore che dovevamo ricevere.

207
00:09:49,090 --> 00:09:53,220
‫Ora qui, vedi questo errore del server interno 500, che è semplicemente dovuto

208
00:09:53,220 --> 00:09:55,710
‫al fatto che in questo momento l'errore

209
00:09:55,710 --> 00:09:57,500
‫che è stato propagato al middleware

210
00:09:57,500 --> 00:09:59,280
‫di gestione degli errori

211
00:09:59,280 --> 00:10:02,110
‫non aveva alcun codice di stato specificato e

212
00:10:02,110 --> 00:10:05,190
‫quindi ricorda che il nostro valore predefinito è 500 e

213
00:10:05,190 --> 00:10:08,310
‫quindi questo è quello che è stato poi rimandato indietro.

214
00:10:08,310 --> 00:10:10,060
‫E, naturalmente, dobbiamo risolverlo e

215
00:10:10,060 --> 00:10:13,173
‫lo faremo in una lezione successiva di questo corso.

216
00:10:14,730 --> 00:10:17,030
‫Per ora, ciò che conta qui

217
00:10:17,030 --> 00:10:20,420
‫è che in primo luogo, la nostra funzione catchAsync funziona esattamente

218
00:10:20,420 --> 00:10:23,700
‫come previsto e, in secondo luogo, che l'errore è stato effettivamente

219
00:10:23,700 --> 00:10:26,900
‫propagato, quindi è stato rilevato dal nostro middleware di gestione

220
00:10:26,900 --> 00:10:30,223
‫degli errori globale che ha quindi inviato questa risposta al client.

221
00:10:32,520 --> 00:10:35,360
‫Ora andiamo avanti ed esportiamo questa funzione

222
00:10:35,360 --> 00:10:38,010
‫di cattura nel proprio file.

223
00:10:38,010 --> 00:10:39,950
‫Quindi lo prendo da qui

224
00:10:39,950 --> 00:10:42,200
‫e creerò solo un altro file nella

225
00:10:42,200 --> 00:10:43,843
‫nostra cartella delle utilità.

226
00:10:47,060 --> 00:10:51,123
‫Quindi catchAsync. js.

227
00:10:55,470 --> 00:11:00,470
‫E qui, modulo. le esportazioni dovrebbero essere proprio questo.

228
00:11:04,650 --> 00:11:09,450
‫E quindi dovrebbe funzionare bene.

229
00:11:09,450 --> 00:11:11,340
‫Nel nostro tour controller,

230
00:11:11,340 --> 00:11:13,373
‫ovviamente, ora dobbiamo importare questa funzione.

231
00:11:18,970 --> 00:11:21,840
‫E come al solito, dobbiamo andare su una

232
00:11:22,840 --> 00:11:25,690
‫cartella e poi nella nostra cartella delle

233
00:11:25,690 --> 00:11:27,733
‫utilità e poi catchAsync.

234
00:11:30,810 --> 00:11:32,840
‫Bene, e ora tutto

235
00:11:32,840 --> 00:11:36,080
‫ciò che dobbiamo fare è sbarazzarci di

236
00:11:36,080 --> 00:11:40,593
‫tutti questi blocchi catch e avvolgere tutti i gestori in catchAsync.

237
00:11:42,210 --> 00:11:43,793
‫Quindi facciamolo.

238
00:11:47,610 --> 00:11:52,610
‫Prima fai l'avvolgimento e poi sbarazzati di questi blocchi.

239
00:11:57,030 --> 00:12:00,220
‫Dagli un salvataggio per riformattare e ci siamo.

240
00:12:00,220 --> 00:12:03,310
‫E ora è semplicemente un processo di ripetizione

241
00:12:03,310 --> 00:12:06,821
‫fino a quando tutti i tour, o, scusa, fino a

242
00:12:06,821 --> 00:12:09,633
‫quando tutti i gestori non sono finiti.

243
00:12:13,070 --> 00:12:14,760
‫Ok, salvataggio veloce.

244
00:12:14,760 --> 00:12:16,740
‫Questo è già fatto.

245
00:12:16,740 --> 00:12:18,763
‫Il prossimo è l'aggiornamento.

246
00:12:26,920 --> 00:12:28,483
‫E solo un altro mancante.

247
00:12:36,380 --> 00:12:37,870
‫O in realtà, non è vero.

248
00:12:37,870 --> 00:12:40,403
‫Laggiù abbiamo ancora più funzioni asincrone.

249
00:12:52,530 --> 00:12:57,203
‫Quindi ci libereremo del trucco e della prova qui.

250
00:12:59,150 --> 00:13:01,100
‫E credo che questo sia l'ultimo.

251
00:13:04,020 --> 00:13:05,483
‫E sì, in effetti lo è.

252
00:13:12,390 --> 00:13:15,000
‫Bene, ora un'altra cosa che

253
00:13:15,000 --> 00:13:19,040
‫dobbiamo fare è aggiungere anche qui accanto a tutti loro.

254
00:13:19,040 --> 00:13:20,793
‫Ma ovviamente non in maiuscolo.

255
00:13:21,690 --> 00:13:22,960
‫Bene.

256
00:13:22,960 --> 00:13:25,480
‫E mi permetta di selezionarli tutti qui in

257
00:13:28,170 --> 00:13:30,683
‫modo che dovrò scriverlo solo una volta.

258
00:13:33,140 --> 00:13:35,943
‫E così questo lo ha aggiunto a tutti loro.

259
00:13:38,390 --> 00:13:42,063
‫E quindi ora immagino che abbiamo finito con questa parte.

260
00:13:43,270 --> 00:13:46,310
‫Proviamolo di nuovo molto velocemente, non con questo,

261
00:13:46,310 --> 00:13:48,733
‫ma qui con, non anche con

262
00:13:49,950 --> 00:13:52,000
‫questo, quindi abbiamo finito.

263
00:13:55,330 --> 00:13:57,140
‫E proverò a fare

264
00:13:57,140 --> 00:14:01,870
‫un tour ma con un ID non valido, quindi vediamo cosa succede qui.

265
00:14:01,870 --> 00:14:04,250
‫E infatti, riceviamo il nostro messaggio di

266
00:14:04,250 --> 00:14:06,950
‫errore e di nuovo con il codice di stato

267
00:14:06,950 --> 00:14:08,640
‫500, che non è corretto,

268
00:14:08,640 --> 00:14:10,050
‫ricorda, ma ce

269
00:14:10,050 --> 00:14:11,930
‫ne occuperemo in un secondo momento.

270
00:14:11,930 --> 00:14:15,130
‫Quindi in questo momento, lascia che ti mostri

271
00:14:15,130 --> 00:14:19,920
‫che qui è da dove viene il 500 perché in questo momento

272
00:14:19,920 --> 00:14:22,200
‫non c'è alcun codice di stato

273
00:14:22,200 --> 00:14:24,310
‫all'interno dell'errore che otteniamo perché

274
00:14:24,310 --> 00:14:27,940
‫questi errori, in realtà provengono da Mongoose e quindi non

275
00:14:27,940 --> 00:14:29,730
‫abbiamo modo di

276
00:14:29,730 --> 00:14:32,390
‫aggiungere uno stato codice a questi errori.

277
00:14:32,390 --> 00:14:35,370
‫O in realtà, ovviamente, potremmo farlo, ma sarebbe

278
00:14:35,370 --> 00:14:37,950
‫ancora più confuso e quindi troveremo

279
00:14:37,950 --> 00:14:40,330
‫un altro modo più avanti in

280
00:14:40,330 --> 00:14:41,443
‫questa sezione.

281
00:14:42,510 --> 00:14:45,840
‫Per ora, sono davvero contento del risultato che abbiamo qui

282
00:14:45,840 --> 00:14:48,773
‫e quindi è tutto per questa lezione.

