1
00:00:03,650 --> 00:00:06,180
Nell'esercizio precedente,

2
00:00:06,180 --> 00:00:09,414
abbiamo appreso due nuovi aspetti di JavaScript, il

3
00:00:09,414 --> 00:00:13,155
loro supporto per funzioni e chiusure di prima classe.

4
00:00:13,155 --> 00:00:20,250
Abbiamo anche visto come Node gestisce l'aspetto di programmazione asincrona e come Node

5
00:00:20,250 --> 00:00:24,015
supporta l'esecuzione asincrona del codice con

6
00:00:24,015 --> 00:00:28,365
l'uso di callback e anche la gestione degli errori.

7
00:00:28,365 --> 00:00:31,815
Diamo un'occhiata a un esempio di come facciamo uso di questo

8
00:00:31,815 --> 00:00:36,650
all'interno della nostra applicazione Node in questo esercizio.

9
00:00:36,650 --> 00:00:42,315
Continuando con il punto in cui abbiamo interrotto nell'esercizio precedente,

10
00:00:42,315 --> 00:00:48,025
ora andrò a modificare il modulo nodo rettangolo,

11
00:00:48,025 --> 00:00:51,670
in modo che possa prendere l'aiuto dei callback.

12
00:00:51,670 --> 00:00:55,375
Quindi ho intenzione di rimuovere queste esportazioni qui,

13
00:00:55,375 --> 00:00:59,800
e invece, stanno andando a modificare questa funzione.

14
00:00:59,800 --> 00:01:03,190
Farò uso di queste due funzioni un po 'più tardi,

15
00:01:03,190 --> 00:01:05,925
quindi è per questo che le sto salvando in basso.

16
00:01:05,925 --> 00:01:07,515
Quindi lascia che li tenga da parte.

17
00:01:07,515 --> 00:01:11,530
E poi modificherò questo modulo rettangolo come segue.

18
00:01:11,530 --> 00:01:15,270
Quindi diremo module.export.

19
00:01:15,270 --> 00:01:20,025
Quindi stiamo usando il modo standard in cui viene gestito il modulo.

20
00:01:20,025 --> 00:01:26,185
E questo sta per esportare questa funzione che prende questi tre parametri,

21
00:01:26,185 --> 00:01:30,565
x e y e callback.

22
00:01:30,565 --> 00:01:37,300
Il callback è una funzione che verrà fornita in quando questo modulo viene chiamato.

23
00:01:37,300 --> 00:01:43,825
Quindi questo è l'uso delle funzioni di prima classe di cui abbiamo parlato in precedenza.

24
00:01:43,825 --> 00:01:46,775
Quindi all'interno di questo callback,

25
00:01:46,775 --> 00:01:49,940
così puoi vedere che stai ottenendo due parametri, x e y.

26
00:01:49,940 --> 00:01:51,965
In questo caso, per

27
00:01:51,965 --> 00:01:55,520
il rettangolo, la x e y corrispondono alla lunghezza e all'ampiezza

28
00:01:55,520 --> 00:02:01,550
del rettangolo che viene passato come i due valori.

29
00:02:01,550 --> 00:02:05,090
Quindi qui dentro, stiamo andando a controllare per vedere

30
00:02:05,090 --> 00:02:10,300
se x è minore o uguale a zero o y è minore o uguale a zero.

31
00:02:10,300 --> 00:02:13,255
Abbiamo scritto codice come questo qui.

32
00:02:13,255 --> 00:02:17,630
Quindi ho intenzione di copiare questo codice da qui

33
00:02:17,630 --> 00:02:23,330
e poi portarlo qui e poi modificheremo.

34
00:02:23,330 --> 00:02:26,090
Quindi in questo caso, questo è se x è

35
00:02:26,090 --> 00:02:30,135
minore o uguale a zero o y è minore o uguale a zero.

36
00:02:30,135 --> 00:02:32,810
In questo caso, cosa facciamo?

37
00:02:32,810 --> 00:02:35,435
In questo caso, notiamo che

38
00:02:35,435 --> 00:02:39,750
le dimensioni del rettangolo sono inferiori o uguali a zero.

39
00:02:39,750 --> 00:02:43,775
Quindi dobbiamo gestirlo in modo diverso,

40
00:02:43,775 --> 00:02:46,330
e faremo l'altra parte di esso.

41
00:02:46,330 --> 00:02:52,790
L' altra parte in cui gestiamo la situazione in cui il rettangolo è un rettangolo valido.

42
00:02:52,790 --> 00:02:54,245
Quindi, in questo caso,

43
00:02:54,245 --> 00:03:04,580
quello che faremo è quindi utilizzare un setTimeout.

44
00:03:04,580 --> 00:03:08,090
Quindi qui, sto simulando il fatto che qualsiasi cosa

45
00:03:08,090 --> 00:03:11,860
venga fatta in questo rettangolo richiederà del tempo.

46
00:03:11,860 --> 00:03:14,375
Quindi questa è l'elaborazione asincrona.

47
00:03:14,375 --> 00:03:18,710
Ora, dal momento che non ho molto lavoro da fare in background,

48
00:03:18,710 --> 00:03:22,530
quindi ho intenzione di simularlo semplicemente usando

49
00:03:22,530 --> 00:03:24,830
la funzione setTimeout di JavaScript e quindi

50
00:03:24,830 --> 00:03:28,825
ritardare prima che venga chiamata la funzione di callback.

51
00:03:28,825 --> 00:03:32,210
Quindi il modo in cui organizzo questo è il seguente.

52
00:03:32,210 --> 00:03:34,270
Quindi all'interno di setTimeout,

53
00:03:34,270 --> 00:03:40,445
chiamerò questa funzione lì

54
00:03:40,445 --> 00:03:44,855
e organizzerò un ritardo di

55
00:03:44,855 --> 00:03:50,570
2.000 millisecondi o due secondi dopo di che questa funzione verrà chiamata.

56
00:03:50,570 --> 00:03:52,003
Quindi, se si ricorda,

57
00:03:52,003 --> 00:03:54,890
il setTimeout supportato in JavaScript,

58
00:03:54,890 --> 00:03:58,070
prende come primo parametro una funzione e

59
00:03:58,070 --> 00:04:03,450
il secondo parametro sarebbe il periodo di tempo per il quale questo verrà ritardato.

60
00:04:03,450 --> 00:04:07,120
Quindi fammi rientrare in questo.

61
00:04:07,120 --> 00:04:09,255
Ora, ho bisogno di compilare questa funzione qui.

62
00:04:09,255 --> 00:04:11,915
Quindi ho iniziato con la funzione freccia qui

63
00:04:11,915 --> 00:04:15,575
che non accetta parametri e poi quando viene chiamato,

64
00:04:15,575 --> 00:04:20,745
emetterò una chiamata al callback.

65
00:04:20,745 --> 00:04:22,880
Questo callback è una funzione di callback

66
00:04:22,880 --> 00:04:25,760
che verrà passata come terzo parametro qui.

67
00:04:25,760 --> 00:04:33,440
Questa funzione di callback, come hai notato, accetta due parametri.

68
00:04:33,440 --> 00:04:38,245
Il primo è l'errore e il secondo è il valore restituito.

69
00:04:38,245 --> 00:04:40,625
Quindi, in questo caso, dal momento che abbiamo un errore,

70
00:04:40,625 --> 00:04:44,750
perché x è minore o uguale a zero e y è minore o uguale a zero,

71
00:04:44,750 --> 00:04:50,820
quindi il primo valore che passerò come nuovo errore,

72
00:04:50,820 --> 00:05:00,603
e questo errore è esattamente questa stringa che stavo usando nel console.log quindi,

73
00:05:00,603 --> 00:05:03,915
e questo è ciò che passerò come l'errore qui.

74
00:05:03,915 --> 00:05:06,160
Permettetemi ora di cancellare quel console.log,

75
00:05:06,160 --> 00:05:07,625
non ne ho più bisogno.

76
00:05:07,625 --> 00:05:08,890
Quindi, per il callback,

77
00:05:08,890 --> 00:05:13,210
genererò un nuovo oggetto errore e quindi lo passerò

78
00:05:13,210 --> 00:05:18,850
come valore restituito per la funzione di callback, il primo parametro.

79
00:05:18,850 --> 00:05:23,770
Quindi dirò che le dimensioni rettangolari dovrebbero essere maggiori di zero.

80
00:05:23,770 --> 00:05:28,240
Quindi diremo l,

81
00:05:28,240 --> 00:05:39,000
questo è il valore x e y che abbiamo ottenuto come valori di input lì.

82
00:05:39,000 --> 00:05:40,650
Quindi questo è il callback.

83
00:05:40,650 --> 00:05:43,890
E la seconda parte di questo callback,

84
00:05:43,890 --> 00:05:51,290
passerò come null perché questo restituirà un errore.

85
00:05:51,290 --> 00:05:54,345
Quindi, quando si restituisce un errore come primo parametro,

86
00:05:54,345 --> 00:05:59,250
il secondo parametro verrà ignorato quando quel callback è stato appena ricevuto

87
00:05:59,250 --> 00:06:06,510
dal modulo nodo da dove stiamo chiamando questa particolare funzione lì.

88
00:06:06,510 --> 00:06:09,085
Quindi, con questa disposizione,

89
00:06:09,085 --> 00:06:10,700
quindi meno di zero,

90
00:06:10,700 --> 00:06:18,590
quindi lasciatemi dare un po' di spazio qui in modo che sia correttamente rientrato qui.

91
00:06:18,590 --> 00:06:21,650
Quindi, il modo in cui sto organizzando questo

92
00:06:21,650 --> 00:06:26,135
qui è che se x è inferiore a zero e y è inferiore

93
00:06:26,135 --> 00:06:30,040
a zero, ho intenzione di richiamare la funzione di callback che è stata passata,

94
00:06:30,040 --> 00:06:32,424
ma il primo parametro passerà per

95
00:06:32,424 --> 00:06:36,307
errore perché qui notiamo che c'è un errore

96
00:06:36,307 --> 00:06:38,930
e il secondo parametro sarà nullo.

97
00:06:38,930 --> 00:06:40,940
Se questo non è il caso,

98
00:06:40,940 --> 00:06:44,550
chiamerò lo stesso callback,

99
00:06:44,550 --> 00:06:46,910
ma con il primo parametro.

100
00:06:46,910 --> 00:06:51,800
Quindi fammi copiare quel codice qui dentro.

101
00:06:51,800 --> 00:07:05,490
Ho ancora intenzione di utilizzare setTimeout qui.

102
00:07:05,490 --> 00:07:10,727
Ma quella prima parte non sarà un errore,

103
00:07:10,727 --> 00:07:13,005
invece, la prima parte,

104
00:07:13,005 --> 00:07:15,235
in questo caso, non c'è errore.

105
00:07:15,235 --> 00:07:20,455
Quindi ho intenzione di passare indietro quel valore come null.

106
00:07:20,455 --> 00:07:22,950
Quindi ciò significa che l'errore è impostato su null.

107
00:07:22,950 --> 00:07:26,335
Quindi questo è un rettangolo valido.

108
00:07:26,335 --> 00:07:29,965
Quindi possiamo calcolare i valori per il rettangolo.

109
00:07:29,965 --> 00:07:35,165
Ma invece, passerò semplicemente in

110
00:07:35,165 --> 00:07:40,020
un oggetto JavaScript contenente le due funzioni

111
00:07:40,020 --> 00:07:45,330
come i due valori all'interno di questo oggetto JavaScript.

112
00:07:45,330 --> 00:07:50,355
Quindi, qui ho intenzione di prendere questo due,

113
00:07:50,355 --> 00:07:54,530
il perimetro e l'area,

114
00:07:55,250 --> 00:08:05,639
e poi questi due saranno passati come i due valori qui,

115
00:08:05,639 --> 00:08:07,807
perimetro e area.

116
00:08:07,807 --> 00:08:12,740
E questi due, dal momento che capita di essere un oggetto JavaScript,

117
00:08:12,740 --> 00:08:16,544
quindi perimetro e area saranno

118
00:08:16,544 --> 00:08:22,690
le due proprietà che passerò all'interno di quegli oggetti JavaScript,

119
00:08:22,690 --> 00:08:25,295
e basta.

120
00:08:25,295 --> 00:08:28,570
Quindi qui, nel secondo caso,

121
00:08:28,570 --> 00:08:32,034
l'errore è impostato su null perché non c'è errore,

122
00:08:32,034 --> 00:08:33,190
ma la seconda parte,

123
00:08:33,190 --> 00:08:37,715
nota che sto passando in un oggetto JavaScript contenente due proprietà,

124
00:08:37,715 --> 00:08:41,530
perimetro e area, che sono due funzioni qui.

125
00:08:41,530 --> 00:08:46,060
Quindi le due funzioni sono la funzione perimetrale e la funzione area.

126
00:08:46,060 --> 00:08:49,390
Quindi questo oggetto JavaScript verrà passato come

127
00:08:49,390 --> 00:08:53,705
valore restituito per il callback qui, il secondo valore.

128
00:08:53,705 --> 00:08:56,035
E ancora, ho intenzione di ritardare questo di

129
00:08:56,035 --> 00:09:02,900
un intervallo di due secondi prima che il valore venga passato da questa funzione.

130
00:09:02,900 --> 00:09:07,075
Il motivo per cui sto usando setTimeout è simulare

131
00:09:07,075 --> 00:09:11,780
un ritardo prima che il callback arrivi dall'altra parte.

132
00:09:11,780 --> 00:09:15,280
Quindi questo tipo di rappresenta situazioni in cui, ad esempio,

133
00:09:15,280 --> 00:09:18,565
si emette una chiamata al database

134
00:09:18,565 --> 00:09:23,300
e il database deve essere letto prima che il valore venga restituito a voi.

135
00:09:23,300 --> 00:09:25,855
Quindi ci vorrà un certo lasso di tempo.

136
00:09:25,855 --> 00:09:32,560
Quindi sto praticamente simulando questo in questo momento usando la funzione setTimeout qui.

137
00:09:32,560 --> 00:09:37,000
Più tardi, vedrai che quando integreremo il MongoDB con

138
00:09:37,000 --> 00:09:43,060
il nostro Express negli esercizi successivi,

139
00:09:43,060 --> 00:09:45,580
quel ritardo dovrebbe essere simulato,

140
00:09:45,580 --> 00:09:48,670
sarà automaticamente causato dal fatto che

141
00:09:48,670 --> 00:09:54,190
è necessario eseguire operazioni di database dietro le quinte prima che i dati vengano ottenuti.

142
00:09:54,190 --> 00:10:00,325
Quindi qui, dopo aver completato questo aggiornamento dei moduli rettangolari,

143
00:10:00,325 --> 00:10:03,135
quindi qui vedi che il modulo rettangolo accetta

144
00:10:03,135 --> 00:10:06,830
tre parametri poiché è una chiamata di input qui,

145
00:10:06,830 --> 00:10:08,920
x, y e callback.

146
00:10:08,920 --> 00:10:12,445
E così, il callback è la funzione di callback che viene fornita qui.

147
00:10:12,445 --> 00:10:16,585
E questa funzione di callback verrà chiamata qui dentro,

148
00:10:16,585 --> 00:10:18,685
e quando viene chiamata la funzione di

149
00:10:18,685 --> 00:10:22,495
callback, o si passa indietro un errore o si passa indietro

150
00:10:22,495 --> 00:10:28,045
una funzione che consente di calcolare il perimetro e l'area del rettangolo.

151
00:10:28,045 --> 00:10:33,835
Ora, questo modello di chiamata e passaggio in una funzione di callback

152
00:10:33,835 --> 00:10:40,300
da un modulo Node e quindi il secondo modulo Node che una volta completato,

153
00:10:40,300 --> 00:10:44,800
passerà indietro il risultato utilizzando la funzione di callback è

154
00:10:44,800 --> 00:10:50,135
esattamente il modello che vedrai spesso ripetuto nelle applicazioni Node.

155
00:10:50,135 --> 00:10:52,360
Quindi e' questo il motivo per cui lo sto illustrando.

156
00:10:52,360 --> 00:10:58,735
Naturalmente, questo è un esempio inventato che sto illustrando qui, ma mostra

157
00:10:58,735 --> 00:11:02,525
tutti i modelli standard che userai con le

158
00:11:02,525 --> 00:11:07,065
funzioni di nodo e callback e anche la gestione degli errori.

159
00:11:07,065 --> 00:11:10,955
Ora, abbiamo aggiornato il modulo rettangolo qui.

160
00:11:10,955 --> 00:11:16,870
Andiamo a riparare quel file index.js in modo che possa passare nella funzione di callback e

161
00:11:16,870 --> 00:11:23,770
quindi gestire il valore restituito dal modulo rettangolo.

162
00:11:23,770 --> 00:11:26,940
Tornando a index.js,

163
00:11:26,940 --> 00:11:31,270
ora ci accingiamo ad aggiornare il file index.js come segue.

164
00:11:31,270 --> 00:11:37,955
Ho intenzione di rimuovere questo dal file index.js invece.

165
00:11:37,955 --> 00:11:42,430
Qui, quello che finirà per fare è chiamare

166
00:11:42,430 --> 00:11:49,120
questo modulo rettangolo e

167
00:11:49,120 --> 00:11:53,880
poi passare il l e la b come i due parametri.

168
00:11:53,880 --> 00:12:00,300
E il terzo parametro che passerò è quella funzione di callback.

169
00:12:00,300 --> 00:12:10,080
Quindi la funzione di callback ha due parametri, err e rettangolo.

170
00:12:10,080 --> 00:12:15,860
E questa funzione di callback è implementata come segue qui.

171
00:12:15,860 --> 00:12:19,090
Quindi qui, vedi che sto chiamando

172
00:12:19,090 --> 00:12:23,785
questo modulo del nodo rettangolo e sto

173
00:12:23,785 --> 00:12:29,050
passando la lunghezza e l'ampiezza dei primi due parametri.

174
00:12:29,050 --> 00:12:31,285
E il terzo parametro è, ovviamente,

175
00:12:31,285 --> 00:12:34,355
una funzione di callback che sto implementando qui.

176
00:12:34,355 --> 00:12:38,250
Quindi, questa è una funzione freccia che sto implementando qui.

177
00:12:38,250 --> 00:12:40,510
Quindi, all'interno di questa funzione di callback,

178
00:12:40,510 --> 00:12:43,245
come gestisco il valore restituito?

179
00:12:43,245 --> 00:12:46,860
Quindi qui dirò se (err),

180
00:12:46,860 --> 00:12:51,335
quindi se il valore di errore ti viene restituito,

181
00:12:51,335 --> 00:12:59,500
allora farò semplicemente console.log e dirò

182
00:12:59,500 --> 00:13:09,100
«ERRORE» e quindi il secondo valore è err.message.

183
00:13:09,100 --> 00:13:11,445
Ricordiamo che nel rettangolo,

184
00:13:11,445 --> 00:13:14,820
avevamo creato questo nuovo oggetto errore

185
00:13:14,820 --> 00:13:18,155
e poi passato in questa stringa all'interno di questo oggetto errore.

186
00:13:18,155 --> 00:13:20,100
Questa stringa verrà allegata

187
00:13:20,100 --> 00:13:24,380
all'oggetto error alla proprietà message dell'oggetto error qui.

188
00:13:24,380 --> 00:13:26,830
Quindi, nel file index.js,

189
00:13:26,830 --> 00:13:30,090
quindi sto recuperando la proprietà message dell'oggetto error

190
00:13:30,090 --> 00:13:33,755
e quindi stampandola sulla mia console qui.

191
00:13:33,755 --> 00:13:35,310
Quindi, se si verifica un errore,

192
00:13:35,310 --> 00:13:39,215
ho intenzione di stampare il messaggio di errore usando questo.

193
00:13:39,215 --> 00:13:45,820
E così, questo è il modo in cui gestirei l'errore restituito da una funzione di callback.

194
00:13:45,820 --> 00:13:51,360
Altrimenti, ovviamente in questo caso,

195
00:13:51,360 --> 00:13:57,450
il modulo rettangolo ha restituito la funzione rettangolo,

196
00:13:57,450 --> 00:14:01,620
l'oggetto che contiene il perimetro e le funzioni area,

197
00:14:01,620 --> 00:14:08,108
quindi posso andare avanti e stampare quel valore.

198
00:14:08,108 --> 00:14:14,175
Quindi qui, dirò l'area del rettangolo

199
00:14:14,175 --> 00:14:23,030
di dimensioni l uguale a,

200
00:14:23,140 --> 00:14:28,270
quindi dirò,

201
00:14:29,170 --> 00:14:37,155
e b uguale a.

202
00:14:37,155 --> 00:14:40,530
Il motivo per cui lo sto identificando

203
00:14:40,530 --> 00:14:47,340
esplicitamente diventerà molto chiaro quando eseguiamo questo esempio.

204
00:14:47,340 --> 00:15:01,480
Dirò è rettangolo.area.

205
00:15:01,480 --> 00:15:04,188
Ora, nota che per quest'area,

206
00:15:04,188 --> 00:15:09,555
non sto inviando alcun parametro qui perché va ai valori,

207
00:15:09,555 --> 00:15:14,540
la lunghezza e il respiro sono stati passati già qui in l e b,

208
00:15:14,540 --> 00:15:19,065
e quelli sarebbero già disponibili per questo

209
00:15:19,065 --> 00:15:24,245
e qui a causa della chiusura che JavaScript supporta.

210
00:15:24,245 --> 00:15:27,470
Poiché questi x e y sono entrati come parametri,

211
00:15:27,470 --> 00:15:32,710
quindi quelli saranno accessibili proprio lì in questa funzione di callback.

212
00:15:32,710 --> 00:15:37,315
Quindi questi x_y saranno automaticamente disponibili per noi qui.

213
00:15:37,315 --> 00:15:39,890
Quindi, in effetti,

214
00:15:39,890 --> 00:15:43,970
non ho bisogno di fornire questi parametri x e y qui perché

215
00:15:43,970 --> 00:15:49,090
quelli x e y saranno recuperati da questo x e y proprio lì.

216
00:15:49,090 --> 00:15:53,375
Quindi non ho nemmeno bisogno di passare quei due valori qui dentro.

217
00:15:53,375 --> 00:15:55,385
Ecco perché, proprio lì,

218
00:15:55,385 --> 00:15:57,905
posso chiamare rettangle.area.

219
00:15:57,905 --> 00:16:03,170
E questo calcolo dell'area otterrà automaticamente l e b che sono stati passati

220
00:16:03,170 --> 00:16:09,505
dalla chiamata rettangolo al modulo nodo diretto in precedenza.

221
00:16:09,505 --> 00:16:14,980
Quindi questa è la chiusura di JavaScript che opera qui.

222
00:16:14,980 --> 00:16:17,945
Quindi, questo è il primo.

223
00:16:17,945 --> 00:16:23,305
Sto stampando l'area del rettangolo.

224
00:16:23,305 --> 00:16:32,990
La stessa cosa, fammi anche stampare i perimetri.

225
00:16:32,990 --> 00:16:34,608
Quindi per stampare i perimetri,

226
00:16:34,608 --> 00:16:36,720
quindi dirò console.log.

227
00:16:36,720 --> 00:16:46,560
Il perimetro del rettangolo sarà il perimetro del rettangolo.

228
00:16:46,560 --> 00:16:53,280
Ora, devo dirti che questo tipo di approccio per l'implementazione richiede un po 'di

229
00:16:53,280 --> 00:17:02,335
sforzo per capire e interiorizzare l'abilità della funzione asincrona.

230
00:17:02,335 --> 00:17:06,360
Ci vuole un po 'di tempo per capire completamente come funziona davvero.

231
00:17:06,360 --> 00:17:08,550
Ora per illustrare il fatto che

232
00:17:08,550 --> 00:17:14,642
questa chiamata di funzione si tradurrà in una chiamata al modulo Node,

233
00:17:14,642 --> 00:17:19,280
ma questa parte verrà eseguita solo dopo

234
00:17:19,280 --> 00:17:24,830
un ritardo di due secondi a causa del fatto che stiamo usando il segno di tempo impostato.

235
00:17:24,830 --> 00:17:28,745
Ora, come abbiamo studiato in operazioni asincrone,

236
00:17:28,745 --> 00:17:33,155
perché abbiamo spostato l'elaborazione sul retro,

237
00:17:33,155 --> 00:17:41,420
permettetemi di introdurre anche un altro console.log qui per fare un punto.

238
00:17:41,420 --> 00:17:46,175
Quindi diremo che questa affermazione è

239
00:17:46,175 --> 00:17:53,869
dopo la chiamata a rect.

240
00:17:53,869 --> 00:18:00,210
Il motivo per cui sto illustrando questo punto è che quando si emette questa chiamata,

241
00:18:00,210 --> 00:18:06,130
questo codice non verrà eseguito fino a dopo un ritardo di due secondi.

242
00:18:06,130 --> 00:18:08,070
Quindi, nel frattempo, la

243
00:18:08,070 --> 00:18:10,360
tua funzione, la funzione principale qui,

244
00:18:10,360 --> 00:18:16,340
continuerà e quindi eseguirà la riga successiva di codice che vedi qui.

245
00:18:16,340 --> 00:18:19,745
Quindi questa è la continuazione che vedrete qui.

246
00:18:19,745 --> 00:18:21,805
Quindi, con queste modifiche,

247
00:18:21,805 --> 00:18:27,815
salviamo le modifiche e poi guardiamo come questa applicazione viene eseguita ora.

248
00:18:27,815 --> 00:18:29,410
Quindi, salvando le modifiche.

249
00:18:29,410 --> 00:18:35,220
Andiamo al terminale ed eseguiamo questa applicazione nodo.

250
00:18:35,220 --> 00:18:37,570
Ora, andando al terminale, aggiungi il prompt.

251
00:18:37,570 --> 00:18:43,795
Permettetemi di digitare npm start e noterete immediatamente

252
00:18:43,795 --> 00:18:51,790
che la soluzione e questa affermazione sono state stampate in precedenza.

253
00:18:51,790 --> 00:18:54,505
E dopo questo certo ritardo,

254
00:18:54,505 --> 00:18:57,855
l'area e il perimetro sono stati stampati.

255
00:18:57,855 --> 00:19:02,130
Quindi questo è un ritardo di due secondi che abbiamo introdotto usando il timeout impostato.

256
00:19:02,130 --> 00:19:05,755
Quindi, hai notato che nella versione precedente,

257
00:19:05,755 --> 00:19:10,290
questo è stato stampato e immediatamente l'area e il perimetro sono stati stampati proprio sotto quello.

258
00:19:10,290 --> 00:19:15,120
Ma ora, notate che quei valori sono stampati un po 'più tardi.

259
00:19:15,120 --> 00:19:20,460
Quindi, nel mezzo, la loro funzione chiama con i diversi parametri che sono già

260
00:19:20,460 --> 00:19:26,505
entrati e quindi i callback vengono richiamati dopo due secondi di ritardo per ciascuno di essi.

261
00:19:26,505 --> 00:19:32,500
E a causa del fatto che c'è la chiusura che supporta il JavaScript,

262
00:19:32,500 --> 00:19:35,980
quindi i valori che vengono passati vengono conservati.

263
00:19:35,980 --> 00:19:38,440
E così quando viene chiamata la funzione di callback,

264
00:19:38,440 --> 00:19:40,615
viene stampato il valore appropriato.

265
00:19:40,615 --> 00:19:42,730
Ecco perché vedi che l'area e

266
00:19:42,730 --> 00:19:46,330
il perimetro sono stampati correttamente e questi due qui,

267
00:19:46,330 --> 00:19:48,070
queste due affermazioni qui,

268
00:19:48,070 --> 00:19:51,340
corrispondono a questa particolare chiamata a dirigere

269
00:19:51,340 --> 00:19:55,100
con l è uguale a due e b è uguale a quattro.

270
00:19:55,100 --> 00:19:56,605
E poi questi due,

271
00:19:56,605 --> 00:19:58,150
il prossimo a due, ovviamente,

272
00:19:58,150 --> 00:20:05,000
corrispondono a questo particolare e a quelli rimanenti come vedete qui.

273
00:20:05,000 --> 00:20:10,410
Quindi, quello che volevo illustrare è il fatto che quando si esegue il calcolo asincrono,

274
00:20:10,410 --> 00:20:12,730
il calcolo asincrono richiede il suo tempo

275
00:20:12,730 --> 00:20:16,270
per restituire il valore mentre il calcolo principale

276
00:20:16,270 --> 00:20:22,460
procederà in avanti senza attendere il completamento del callback.

277
00:20:22,460 --> 00:20:25,245
Quindi, quando hai bisogno di fare una certa quantità di lavoro,

278
00:20:25,245 --> 00:20:29,365
hai passato come callback a quell'altro modulo.

279
00:20:29,365 --> 00:20:31,375
E quando quell'altro modulo completa il suo lavoro,

280
00:20:31,375 --> 00:20:35,010
sta per richiamare e quindi quel codice verrà eseguito.

281
00:20:35,010 --> 00:20:40,350
Quindi questo è il punto che ho illustrato usando questo esempio.

282
00:20:40,350 --> 00:20:41,565
Ancora una volta, come ho detto,

283
00:20:41,565 --> 00:20:45,210
questo richiede un po 'di immaginazione e comprensione

284
00:20:45,210 --> 00:20:48,930
per voi per interiorizzare il modo in cui funziona,

285
00:20:48,930 --> 00:20:55,185
ma vedrete che con Node e anche Express e quando usiamo MongoDB,

286
00:20:55,185 --> 00:21:01,785
vedrete questo tipo di modello che si ripete molto spesso nel modo in cui scriviamo il nostro codice.

287
00:21:01,785 --> 00:21:06,210
Quindi, con questa semplice illustrazione di callback e gestione degli errori,

288
00:21:06,210 --> 00:21:08,940
completiamo questo esercizio.

289
00:21:08,940 --> 00:21:13,675
Questo è un buon momento per fare un commento get con quel messaggio,

290
00:21:13,675 --> 00:21:17,700
nodo, callback e gestione degli errori.