1
00:00:01,190 --> 00:00:02,840
‫Jonas: Ora scriviamo del

2
00:00:02,840 --> 00:00:05,520
‫codice per avere una migliore comprensione di

3
00:00:05,520 --> 00:00:07,893
‫cosa succede nel ciclo degli eventi.

4
00:00:09,200 --> 00:00:11,370
‫Quindi, proprio come prima, per iniziare

5
00:00:11,370 --> 00:00:13,670
‫con la parte di codifica di questa

6
00:00:13,670 --> 00:00:15,970
‫sezione, vai avanti e prendi i file

7
00:00:15,970 --> 00:00:18,550
‫di partenza per questa sezione, copiali da qualche

8
00:00:18,550 --> 00:00:22,050
‫parte e quindi apri il progetto nel tuo editor di codice.

9
00:00:22,050 --> 00:00:24,310
‫Quindi ce l'ho qui sul desktop e

10
00:00:24,310 --> 00:00:27,550
‫nel mio VSCode, e tutto ciò che abbiamo qui per iniziare

11
00:00:27,550 --> 00:00:31,420
‫è questo file di test. txt, quindi creerò un nuovo file qui

12
00:00:31,420 --> 00:00:35,033
‫e lo chiamerò ciclo di eventi. js.

13
00:00:38,040 --> 00:00:41,530
‫Bene, ora è davvero estremamente difficile simulare correttamente l'event

14
00:00:41,530 --> 00:00:44,000
‫loop, perché non possiamo davvero mettere

15
00:00:44,000 --> 00:00:46,400
‫molte callback in tutte le

16
00:00:46,400 --> 00:00:48,080
‫code di callback

17
00:00:48,080 --> 00:00:51,260
‫di cui abbiamo parlato prima tutte contemporaneamente, giusto.

18
00:00:51,260 --> 00:00:53,710
‫Questa situazione si verifica quando, ad

19
00:00:53,710 --> 00:00:56,360
‫esempio, arrivano molte richieste nella tua app,

20
00:00:56,360 --> 00:01:00,240
‫ma qui a livello locale è molto difficile da replicare.

21
00:01:00,240 --> 00:01:03,150
‫Comunque, faremo comunque degli esperimenti molto interessanti

22
00:01:03,150 --> 00:01:05,390
‫usando alcune delle cose che

23
00:01:05,390 --> 00:01:07,540
‫abbiamo imparato nell'ultimo video.

24
00:01:07,540 --> 00:01:09,830
‫E quello che faremo è scrivere

25
00:01:09,830 --> 00:01:12,190
‫un mucchio di righe di codice, e

26
00:01:12,190 --> 00:01:15,130
‫poi provare a capire in quale ordine dovrebbero essere

27
00:01:15,130 --> 00:01:17,950
‫eseguite nel ciclo degli eventi, e analizzare se i

28
00:01:17,950 --> 00:01:20,360
‫risultati che otteniamo hanno davvero un senso.

29
00:01:20,360 --> 00:01:22,710
‫Quindi iniziamo scrivendo un setTimeout, quindi

30
00:01:24,290 --> 00:01:26,513
‫fondamentalmente per impostare un timer,

31
00:01:27,980 --> 00:01:29,890
‫e sto usando una funzione

32
00:01:29,890 --> 00:01:31,270
‫freccia qui,

33
00:01:31,270 --> 00:01:33,773
‫e l'unica cosa che farò è accedere

34
00:01:34,930 --> 00:01:39,930
‫a console qualche stringa, quindi console. log, timer uno terminato e

35
00:01:41,800 --> 00:01:45,390
‫voglio che questo scada subito dopo zero secondi.

36
00:01:45,390 --> 00:01:47,740
‫Ok, salvalo e poi vedrai che in

37
00:01:47,740 --> 00:01:50,030
‫realtà ha corretto questa stringa qui, quindi

38
00:01:50,030 --> 00:01:53,120
‫ha cambiato le virgolette e ha aggiunto il punto e

39
00:01:53,120 --> 00:01:54,810
‫virgola, e questo è

40
00:01:54,810 --> 00:01:56,940
‫dovuto all'estensione Prettier che abbiamo installato prima.

41
00:01:56,940 --> 00:01:58,510
‫Ora non lo configurerò qui,

42
00:01:58,510 --> 00:01:59,850
‫perché per questo

43
00:01:59,850 --> 00:02:02,050
‫piccolo esempio, non è proprio necessario, ok.

44
00:02:02,050 --> 00:02:05,150
‫Quindi questo è l'impostazione di un

45
00:02:05,150 --> 00:02:09,320
‫timer, quindi usiamo anche setImmediate, quindi ricordalo dall'ultimo video.

46
00:02:09,320 --> 00:02:11,620
‫Ok, ora non spiegherò molto qui, per

47
00:02:11,620 --> 00:02:13,350
‫ora scriviamo questo codice

48
00:02:13,350 --> 00:02:15,510
‫e poi analizziamo cosa succede, ok.

49
00:02:15,510 --> 00:02:20,320
‫Quindi setImmediate e, proprio come l'altro timer, riceve una

50
00:02:20,320 --> 00:02:22,500
‫funzione di callback.

51
00:02:22,500 --> 00:02:25,130
‫E tutto quello che faremo è

52
00:02:27,720 --> 00:02:31,440
‫scriverne uno finito immediato, e questo non ha tempo,

53
00:02:31,440 --> 00:02:33,520
‫perché non è

54
00:02:33,520 --> 00:02:36,930
‫necessario perché come dice il nome, è immediato.

55
00:02:36,930 --> 00:02:38,540
‫Quindi un'altra cosa che vogliamo

56
00:02:38,540 --> 00:02:41,620
‫fare è leggere questo file qui e quindi

57
00:02:41,620 --> 00:02:44,930
‫passare una funzione di callback, ok, quindi la prima

58
00:02:44,930 --> 00:02:48,963
‫cosa è che dobbiamo richiedere il modulo corretto, quindi FS e ora

59
00:02:52,600 --> 00:02:54,987
‫fs. readFile, e vogliamo file di testo. txt,

60
00:03:05,586 --> 00:03:08,003
‫e poi succede qualcosa.

61
00:03:09,270 --> 00:03:12,153
‫E proprio come prima, diciamo

62
00:03:13,740 --> 00:03:17,263
‫qui, in questo caso I/O finito, va bene.

63
00:03:18,830 --> 00:03:21,170
‫Quindi I/O perché questo callback qui

64
00:03:21,170 --> 00:03:24,830
‫è in realtà correlato a un'attività di I/O, che in

65
00:03:24,830 --> 00:03:28,440
‫realtà ottiene la propria fase nel ciclo degli eventi, giusto.

66
00:03:28,440 --> 00:03:31,930
‫E infine, aggiungiamo solo una console. accedi qui, dicendo

67
00:03:31,930 --> 00:03:35,473
‫bene, ciao dal codice di primo livello.

68
00:03:37,517 --> 00:03:40,440
‫Ok, e quindi codice di primo livello, perché in realtà

69
00:03:40,440 --> 00:03:43,130
‫è l'unico che non è all'interno di alcun callback.

70
00:03:43,130 --> 00:03:46,000
‫Quindi in questo piccolo esempio che abbiamo per ora,

71
00:03:46,000 --> 00:03:48,400
‫proviamo a capire cosa dovrebbe accadere prima.

72
00:03:48,400 --> 00:03:50,510
‫Bene, ricorda che il primo passo

73
00:03:50,510 --> 00:03:53,310
‫quando carichiamo un modulo è che il suo

74
00:03:53,310 --> 00:03:56,000
‫codice di primo livello viene eseguito, quindi dovremmo

75
00:03:56,000 --> 00:03:59,360
‫vedere subito questa console. log qui, giusto, solo

76
00:03:59,360 --> 00:04:02,110
‫in seguito dovremmo vedere gli altri log provenienti

77
00:04:02,110 --> 00:04:04,280
‫da questi altri callback, perché questi

78
00:04:04,280 --> 00:04:06,820
‫callback verranno effettivamente eseguiti nel ciclo degli eventi.

79
00:04:06,820 --> 00:04:09,190
‫Quindi proviamo a vedere se è

80
00:04:09,190 --> 00:04:12,000
‫effettivamente così, e poi analizziamolo anche un po' meglio.

81
00:04:12,000 --> 00:04:15,150
‫Quindi aprendo la console qui, e di nuovo,

82
00:04:15,150 --> 00:04:17,250
‫lo sto facendo usando

83
00:04:17,250 --> 00:04:22,023
‫il terminale, o effettivamente nella vista, quindi questo terminale qui, va bene.

84
00:04:23,100 --> 00:04:27,020
‫Quindi nota, ciclo di eventi. js, o in realtà prima

85
00:04:27,020 --> 00:04:30,960
‫di farlo, devo correggere questo errore di battitura qui, quindi è un

86
00:04:30,960 --> 00:04:33,580
‫file di test, non un file di testo.

87
00:04:33,580 --> 00:04:36,093
‫Ok, ma ora siamo pronti per eseguire

88
00:04:36,960 --> 00:04:40,320
‫questo comando e i risultati sono arrivati, quindi il primo

89
00:04:40,320 --> 00:04:43,810
‫registro che abbiamo qui è ciao dal codice di livello

90
00:04:43,810 --> 00:04:46,100
‫superiore, ed era previsto, giusto,

91
00:04:46,100 --> 00:04:49,390
‫perché questo è un codice che viene eseguito subito.

92
00:04:49,390 --> 00:04:52,940
‫Dopodiché, abbiamo questi tre output, ma in realtà non sono in

93
00:04:52,940 --> 00:04:55,460
‫un ordine particolare, e questo perché questo

94
00:04:55,460 --> 00:04:57,640
‫codice qui, quindi questo codice, non

95
00:04:57,640 --> 00:05:00,970
‫è in realtà in un ciclo di I/O, quindi non

96
00:05:00,970 --> 00:05:03,780
‫è in esecuzione all'interno del ciclo di eventi,

97
00:05:03,780 --> 00:05:07,170
‫perché non è in esecuzione all'interno di alcuna funzione di callback.

98
00:05:07,170 --> 00:05:10,370
‫Ok, quindi nel tuo computer, potresti effettivamente vedere questo registro

99
00:05:11,470 --> 00:05:13,160
‫qui prima di questo,

100
00:05:13,160 --> 00:05:15,360
‫e poi questo qui è solo

101
00:05:15,360 --> 00:05:18,550
‫l'ultimo perché questo tipo di file di grandi dimensioni qui

102
00:05:18,550 --> 00:05:20,840
‫richiede del tempo per essere letto, e

103
00:05:20,840 --> 00:05:23,060
‫quindi probabilmente sarà sempre l'ultimo uno.

104
00:05:23,060 --> 00:05:27,140
‫Quindi di nuovo, a questo punto, l'ordine di questi tre qui non ha nulla

105
00:05:27,140 --> 00:05:29,640
‫a che fare con il ciclo degli eventi, perché

106
00:05:29,640 --> 00:05:31,320
‫in realtà non sono ancora

107
00:05:31,320 --> 00:05:33,420
‫in esecuzione all'interno del ciclo degli eventi.

108
00:05:33,420 --> 00:05:36,490
‫Per questo, dovremo spostarli, o almeno

109
00:05:36,490 --> 00:05:40,490
‫spostarli qui, all'interno di una funzione di callback.

110
00:05:40,490 --> 00:05:43,713
‫E quindi, per questo useremo questo qui in realtà.

111
00:05:45,270 --> 00:05:50,190
‫Quindi fammi mettere qui, e dire timer due e timer due

112
00:05:50,190 --> 00:05:55,190
‫qui, o immediatamente due, e aggiungerò anche un altro timer qui, quindi

113
00:05:55,270 --> 00:05:57,740
‫timer tre, e questo durerà

114
00:05:57,740 --> 00:06:01,140
‫tre secondi, quindi sono 3000 millisecondi .

115
00:06:01,140 --> 00:06:03,840
‫Quindi ora proviamo il risultato di questo.

116
00:06:03,840 --> 00:06:06,230
‫Ma prima di farlo, pensiamo al

117
00:06:06,230 --> 00:06:09,660
‫motivo per cui subito dopo che tutto il codice precedente era

118
00:06:09,660 --> 00:06:13,730
‫stato eseguito, il programma è uscito e è tornato al prompt qui.

119
00:06:13,730 --> 00:06:16,500
‫Quindi ricorda come Node. js decide se deve

120
00:06:16,500 --> 00:06:19,000
‫continuare a eseguire il ciclo degli eventi, beh,

121
00:06:19,000 --> 00:06:21,620
‫lo fa chiedendo se c'è ancora del tempo in

122
00:06:21,620 --> 00:06:24,580
‫esecuzione in background e, in tal caso, non finirà, e

123
00:06:24,580 --> 00:06:26,800
‫se c'è ancora un timer in sospeso,

124
00:06:26,800 --> 00:06:29,140
‫beh, allora non lo è uscirò dal programma.

125
00:06:29,140 --> 00:06:30,920
‫Ma se non c'è, come

126
00:06:30,920 --> 00:06:33,920
‫nel primo esempio qui, allora esce immediatamente dal

127
00:06:33,920 --> 00:06:36,660
‫programma, ok, ma ora abbiamo effettivamente un

128
00:06:36,660 --> 00:06:38,980
‫timer qui, quindi questo verrà eseguito

129
00:06:38,980 --> 00:06:41,620
‫per tre secondi, quindi proviamo a capire

130
00:06:41,620 --> 00:06:43,220
‫cosa succede qui.

131
00:06:45,260 --> 00:06:47,450
‫Ok, quindi vedi che non

132
00:06:47,450 --> 00:06:50,640
‫sta uscendo, e solo ora, dopo che il timer

133
00:06:50,640 --> 00:06:53,170
‫tre è terminato, è uscito dall'applicazione.

134
00:06:53,170 --> 00:06:56,100
‫Ok, quindi vediamolo di nuovo, quindi tutti questi

135
00:06:56,100 --> 00:06:59,480
‫timer di registro sono in esecuzione, il timer è

136
00:06:59,480 --> 00:07:02,070
‫terminato e quindi è uscito dall'applicazione.

137
00:07:02,070 --> 00:07:04,490
‫Ora riguardo a questi risultati qui,

138
00:07:04,490 --> 00:07:06,820
‫rendiamolo un po' più facile

139
00:07:06,820 --> 00:07:10,113
‫da vedere e aggiungiamo solo un piccolo separatore qui.

140
00:07:11,360 --> 00:07:14,683
‫Ok, pulisci questo, ok.

141
00:07:16,510 --> 00:07:19,600
‫Quindi questi quattro qui sono gli output che non

142
00:07:19,600 --> 00:07:22,110
‫erano realmente in esecuzione nel ciclo degli

143
00:07:22,110 --> 00:07:24,380
‫eventi, ma questi tre qui stavano

144
00:07:24,380 --> 00:07:28,150
‫effettivamente uscendo dal ciclo degli eventi, quindi ora analizziamo questi risultati.

145
00:07:28,150 --> 00:07:29,980
‫Ora, se ricorderai

146
00:07:29,980 --> 00:07:32,690
‫il diagramma della lezione precedente, probabilmente avrai

147
00:07:32,690 --> 00:07:36,960
‫pensato che il timer, quindi il timer due qui, dovrebbe effettivamente

148
00:07:36,960 --> 00:07:39,640
‫finire prima del setImmediate, perché nel diagramma,

149
00:07:39,640 --> 00:07:42,640
‫in realtà è apparso per primo proprio nella

150
00:07:42,640 --> 00:07:45,100
‫parte superiore del ciclo di eventi.

151
00:07:45,100 --> 00:07:48,090
‫Quindi dobbiamo impostare il timeout qui

152
00:07:48,090 --> 00:07:52,500
‫con zero, che dovrebbe essere lo stesso di setImmediate, giusto.

153
00:07:52,500 --> 00:07:54,610
‫Allora perché setImmediate

154
00:07:54,610 --> 00:07:57,630
‫appare effettivamente prima di setTimeout?

155
00:07:57,630 --> 00:08:00,020
‫Bene, c'è qualcosa che non ho

156
00:08:00,020 --> 00:08:02,470
‫spiegato nell'ultimo video, perché non volevo rendere

157
00:08:02,470 --> 00:08:05,750
‫la cosa ancora più confusa, ed è che il ciclo

158
00:08:05,750 --> 00:08:09,320
‫degli eventi attende effettivamente che accadano cose nella fase di sondaggio.

159
00:08:09,320 --> 00:08:12,270
‫Quindi in quella fase in cui vengono gestiti i callback di I/O.

160
00:08:12,270 --> 00:08:15,400
‫Quindi, quando questa coda di callback è vuota, come

161
00:08:15,400 --> 00:08:17,940
‫nel nostro esempio fittizio qui, quindi non

162
00:08:17,940 --> 00:08:20,270
‫abbiamo callback I/O, tutto ciò che

163
00:08:20,270 --> 00:08:23,500
‫abbiamo sono questi timer, beh, allora il ciclo degli

164
00:08:23,500 --> 00:08:27,490
‫eventi aspetterà in questa fase fino a quando non è scaduto Timer.

165
00:08:27,490 --> 00:08:31,430
‫Ma, se abbiamo pianificato una richiamata utilizzando setImmediate, quella

166
00:08:31,430 --> 00:08:34,320
‫richiamata verrà effettivamente eseguita subito dopo la

167
00:08:34,320 --> 00:08:36,920
‫fase di polling e anche

168
00:08:36,920 --> 00:08:40,240
‫prima dei timer scaduti, se ce n'è uno.

169
00:08:40,240 --> 00:08:43,270
‫E in questo caso, il timer scade subito, quindi

170
00:08:43,270 --> 00:08:46,080
‫dopo zero secondi, ma ancora una volta, il

171
00:08:46,080 --> 00:08:49,710
‫ciclo degli eventi attende effettivamente, quindi si interrompe nella fase di polling.

172
00:08:49,710 --> 00:08:52,100
‫E quindi il callback setImmediate viene

173
00:08:52,100 --> 00:08:55,580
‫effettivamente eseguito per primo, quindi questa è l'intera ragione

174
00:08:55,580 --> 00:08:59,730
‫per cui abbiamo questo immediato qui dopo che abbiamo i timer.

175
00:08:59,730 --> 00:09:02,770
‫Ok, e so che sembra molto confuso, e sono

176
00:09:02,770 --> 00:09:04,810
‫completamente d'accordo, ma in realtà

177
00:09:04,810 --> 00:09:08,090
‫è così che Node. js funziona.

178
00:09:08,090 --> 00:09:11,380
‫E ora rendiamo questo ancora un po' più confuso e

179
00:09:11,380 --> 00:09:14,250
‫aggiungiamo il processo. nextTick di

180
00:09:14,250 --> 00:09:16,950
‫cui abbiamo parlato anche nell'ultima lezione.

181
00:09:16,950 --> 00:09:21,950
‫Quindi diciamo processo. nextTick, e poi, proprio come prima, gli

182
00:09:22,170 --> 00:09:24,323
‫passiamo semplicemente una funzione di callback.

183
00:09:25,540 --> 00:09:27,640
‫E ancora, voglio solo accedere alla

184
00:09:27,640 --> 00:09:31,663
‫console e dirò processo. successivoTick.

185
00:09:32,550 --> 00:09:36,150
‫Quindi cosa pensi che accadrà in questo caso?

186
00:09:36,150 --> 00:09:40,170
‫Vai avanti e fai un'ipotesi, e una volta che sei

187
00:09:40,170 --> 00:09:42,883
‫pronto puoi eseguire questo, quindi facciamolo.

188
00:09:44,120 --> 00:09:48,280
‫Prima salvalo qui, eseguilo e quindi eccoci qui.

189
00:09:48,280 --> 00:09:51,760
‫Quindi i risultati sono di nuovo presenti, e ora la

190
00:09:51,760 --> 00:09:55,640
‫prima richiamata che è stata eseguita era in realtà questa funzione qui.

191
00:09:55,640 --> 00:09:58,220
‫Ecco perché abbiamo il processo. nextSpunta a

192
00:09:58,220 --> 00:09:59,710
‫destra nel primo.

193
00:09:59,710 --> 00:10:03,500
‫Allora perché questa funzione di callback del processo. nextSelezionare il

194
00:10:03,500 --> 00:10:06,570
‫primo di tutti da eseguire?

195
00:10:06,570 --> 00:10:09,070
‫Bene, ricorda che nextTick fa

196
00:10:09,070 --> 00:10:12,410
‫parte della coda dei microtask, che vengono eseguiti

197
00:10:12,410 --> 00:10:16,530
‫dopo ogni fase, quindi non solo dopo un intero tick.

198
00:10:16,530 --> 00:10:19,120
‫E quindi quello che è successo qui è

199
00:10:19,120 --> 00:10:23,660
‫che questa funzione di callback è stata effettivamente eseguita prima della fase in cui è stata

200
00:10:23,660 --> 00:10:26,970
‫eseguita questa funzione di callback qui, e la fase precedente, ok.

201
00:10:26,970 --> 00:10:30,850
‫NextTick è in realtà un nome fuorviante, perché un tick

202
00:10:30,850 --> 00:10:33,990
‫è in realtà un intero ciclo, ma

203
00:10:33,990 --> 00:10:37,860
‫nextTick si verifica effettivamente prima della fase del ciclo successivo,

204
00:10:37,860 --> 00:10:41,990
‫e non l'intero tick, quindi è quello che stavo dicendo prima.

205
00:10:41,990 --> 00:10:45,830
‫Quindi, dall'altra parte, setImmediate ti farebbe pensare che

206
00:10:45,830 --> 00:10:49,690
‫il suo callback verrebbe eseguito immediatamente, ma in realtà

207
00:10:49,690 --> 00:10:52,780
‫non lo fa, giusto, quindi setImmediate

208
00:10:52,780 --> 00:10:55,570
‫viene effettivamente eseguito una volta

209
00:10:55,570 --> 00:10:58,800
‫per tick, mentre nextTick viene eseguito immediatamente.

210
00:10:58,800 --> 00:11:01,820
‫E quindi i loro due nomi dovrebbero effettivamente essere scambiati.

211
00:11:01,820 --> 00:11:03,700
‫Dovrebbero essere il contrario, e questo può

212
00:11:03,700 --> 00:11:05,390
‫causare molta confusione, quindi è

213
00:11:05,390 --> 00:11:08,440
‫meglio attenersi sempre a uno di essi, e di solito è

214
00:11:08,440 --> 00:11:12,470
‫impostato su Immediato e non su Process. successivoTick.

215
00:11:12,470 --> 00:11:15,070
‫Comunque, come ho detto in un ultimo video,

216
00:11:15,070 --> 00:11:18,530
‫questi meccanismi sono in realtà più per casi d'uso piuttosto

217
00:11:18,530 --> 00:11:20,320
‫avanzati, motivo per cui

218
00:11:20,320 --> 00:11:22,760
‫probabilmente non li useremo nel nostro progetto.

219
00:11:22,760 --> 00:11:24,970
‫Ma se vuoi saperne di più su

220
00:11:24,970 --> 00:11:28,060
‫di loro, puoi sempre leggere la documentazione ufficiale di Node.

221
00:11:28,060 --> 00:11:30,660
‫Ok, con questo abbiamo simulato alcuni aspetti del

222
00:11:30,660 --> 00:11:33,250
‫ciclo degli eventi, ma per finire, voglio

223
00:11:33,250 --> 00:11:35,500
‫solo introdurre rapidamente qualcosa sul pool

224
00:11:35,500 --> 00:11:38,290
‫di thread, e per questo faremo un'operazione più

225
00:11:38,290 --> 00:11:40,950
‫complessa che verrà effettivamente scaricata su il pool

226
00:11:40,950 --> 00:11:43,490
‫di thread e dai un'occhiata a quanto

227
00:11:43,490 --> 00:11:47,040
‫tempo impiegano queste operazioni per l'esecuzione e come possiamo modificare la

228
00:11:47,040 --> 00:11:48,510
‫dimensione del pool

229
00:11:48,510 --> 00:11:50,870
‫di thread di cui abbiamo parlato prima.

230
00:11:50,870 --> 00:11:52,840
‫Quindi useremo un po' di

231
00:11:52,840 --> 00:11:55,203
‫crittografia qui per crittografare sostanzialmente una password.

232
00:11:58,620 --> 00:12:00,820
‫Quindi questo è un nuovo pacchetto che

233
00:12:00,820 --> 00:12:04,130
‫non avevamo mai usato prima, e si chiama Crypto, ma ho

234
00:12:04,130 --> 00:12:07,063
‫detto prima che in realtà, tutte le funzioni di

235
00:12:07,960 --> 00:12:11,260
‫questo pacchetto verranno scaricate automaticamente dal ciclo degli eventi nel pool

236
00:12:11,260 --> 00:12:13,280
‫di thread, e quindi è quello

237
00:12:13,280 --> 00:12:14,780
‫che noi proverò adesso.

238
00:12:18,380 --> 00:12:22,070
‫E usiamo questo ora, quindi cripto. pb, quindi useremo una funzione

239
00:12:22,070 --> 00:12:25,303
‫di crittografia chiamata pbkdf2, quindi un nome strano,

240
00:12:27,610 --> 00:12:31,050
‫e ora passiamo la stringa segreta, che diciamo solo

241
00:12:31,050 --> 00:12:34,640
‫password, quindi abbiamo bisogno di una stringa per risolvere

242
00:12:34,640 --> 00:12:37,520
‫le password e le implementazioni qui non

243
00:12:37,520 --> 00:12:40,820
‫importa, quindi per ora non entrerò nei dettagli di

244
00:12:40,820 --> 00:12:42,970
‫come funziona, lo faremo più

245
00:12:42,970 --> 00:12:46,150
‫tardi, ok, quindi qui abbiamo solo bisogno della

246
00:12:46,150 --> 00:12:48,320
‫lunghezza della chiave, quindi questo numero

247
00:12:48,320 --> 00:12:50,070
‫qui è solo

248
00:12:50,070 --> 00:12:53,870
‫per numero di iterazioni, quindi questa è la lunghezza della

249
00:12:53,870 --> 00:12:56,020
‫chiave e infine l'algoritmo, che

250
00:12:56,020 --> 00:12:58,430
‫verrà utilizzato per crittografare la password.

251
00:12:58,430 --> 00:13:00,380
‫Quindi questi numeri aumenteranno semplicemente

252
00:13:00,380 --> 00:13:02,483
‫il tempo necessario per la crittografia.

253
00:13:04,970 --> 00:13:08,610
‫Ok, e poi finalmente, ci vuole anche una funzione di callback, e tutto quello che farò

254
00:13:08,610 --> 00:13:11,483
‫qui è fare un'altra console. log

255
00:13:12,730 --> 00:13:16,453
‫e pronuncia semplicemente la password crittografata.

256
00:13:17,950 --> 00:13:20,740
‫Ora, ai fini di questa

257
00:13:20,740 --> 00:13:24,220
‫dimostrazione, in realtà voglio mostrarti quanto tempo

258
00:13:24,220 --> 00:13:27,400
‫impiega ciascuna di queste operazioni, quindi

259
00:13:27,400 --> 00:13:32,010
‫ciò che faremo è sostanzialmente definire una variabile all'inizio,

260
00:13:32,010 --> 00:13:37,010
‫impostarla su data. ora, quindi questa è la data corrente

261
00:13:37,120 --> 00:13:41,310
‫in millisecondi, e quindi qui, tutto ciò che dobbiamo fare è registrare non

262
00:13:41,310 --> 00:13:46,310
‫solo la stringa, ma anche la data. ora, che sarà la data a

263
00:13:46,310 --> 00:13:49,700
‫questo punto in millisecondi, meno l'inizio, e

264
00:13:49,700 --> 00:13:53,010
‫così che ci darà la quantità di

265
00:13:53,010 --> 00:13:55,380
‫millisecondi che sono passati per

266
00:13:55,380 --> 00:13:57,380
‫fare questo calcolo.

267
00:13:57,380 --> 00:13:59,693
‫Ok, allora proviamolo,

268
00:14:00,890 --> 00:14:05,360
‫salviamolo ed eseguiamolo di nuovo, quindi qui vedete che

269
00:14:05,360 --> 00:14:08,530
‫ci sono voluti 1855 millisecondi, quindi

270
00:14:08,530 --> 00:14:12,250
‫quasi due secondi per crittografare questa password.

271
00:14:12,250 --> 00:14:15,110
‫Ok, ma ora duplichiamo questo codice, o

272
00:14:15,110 --> 00:14:17,360
‫in realtà voglio che quattro

273
00:14:17,360 --> 00:14:19,660
‫istanze di questo ti mostrino qualcosa.

274
00:14:19,660 --> 00:14:23,400
‫Quindi, se eseguiamo questo ora, dovrebbe probabilmente richiedere all'incirca la stessa

275
00:14:23,400 --> 00:14:25,710
‫quantità di tempo, e sì, lo fa,

276
00:14:25,710 --> 00:14:27,980
‫quindi era 1. 8

277
00:14:27,980 --> 00:14:31,620
‫secondi, ora sono 2. 2 secondi, che è abbastanza simile.

278
00:14:31,620 --> 00:14:34,530
‫Ok, e ricorda che ti ho detto in una

279
00:14:34,530 --> 00:14:36,630
‫delle lezioni precedenti, che per

280
00:14:36,630 --> 00:14:39,360
‫impostazione predefinita la dimensione del pool di thread

281
00:14:39,360 --> 00:14:41,720
‫è quattro, quindi ci sono quattro thread

282
00:14:41,720 --> 00:14:44,010
‫che fanno il lavoro contemporaneamente, ed ecco

283
00:14:44,010 --> 00:14:46,160
‫perché queste quattro crittografie di password

284
00:14:46,160 --> 00:14:48,000
‫richiedono circa allo stesso

285
00:14:48,000 --> 00:14:50,740
‫tempo e accadono praticamente tutti allo stesso tempo.

286
00:14:50,740 --> 00:14:53,990
‫Ma possiamo effettivamente modificare la dimensione del pool di thread.

287
00:14:53,990 --> 00:14:57,100
‫Quindi, lascia che ti mostri come lo facciamo, e

288
00:14:57,100 --> 00:14:59,867
‫lo facciamo dicendo processo. env, e

289
00:15:01,290 --> 00:15:03,230
‫questa è una variabile ambientale,

290
00:15:03,230 --> 00:15:05,680
‫e di nuovo ne parleremo più avanti,

291
00:15:06,684 --> 00:15:08,613
‫e UV, che sta per

292
00:15:11,232 --> 00:15:15,500
‫LibUV, dimensione del pool di thread, quindi se lo impostiamo su uno,

293
00:15:15,500 --> 00:15:18,783
‫avremo solo un thread nel nostro pool di thread.

294
00:15:21,110 --> 00:15:26,110
‫Quindi proviamo di nuovo, e vediamo cosa succede ora.

295
00:15:28,650 --> 00:15:32,840
‫Quindi vedi che tutti impiegano molto più tempo per il calcolo.

296
00:15:32,840 --> 00:15:35,490
‫Fondamentalmente, vengono calcolati uno dopo l'altro.

297
00:15:35,490 --> 00:15:38,470
‫Quindi questo il primo, poi questo qui impiega il doppio

298
00:15:38,470 --> 00:15:40,610
‫del tempo, e di nuovo questo è

299
00:15:40,610 --> 00:15:42,980
‫perché questo può iniziare solo non appena il

300
00:15:42,980 --> 00:15:45,160
‫primo è completato, e lo stesso con

301
00:15:45,160 --> 00:15:46,893
‫il terzo e il quarto.

302
00:15:47,920 --> 00:15:49,620
‫Ora diciamo di cambiarlo

303
00:15:52,170 --> 00:15:54,300
‫in due, quindi dovremmo vedere i

304
00:15:54,300 --> 00:15:56,990
‫primi due con lo stesso tempo, e esattamente,

305
00:15:56,990 --> 00:15:59,710
‫anche i secondi due con un tempo simile.

306
00:15:59,710 --> 00:16:01,363
‫Quindi ha senso, giusto.

307
00:16:02,650 --> 00:16:04,500
‫Solo per completezza qui,

308
00:16:05,610 --> 00:16:08,950
‫ora lo stesso con tre, quindi questi tre hanno

309
00:16:08,950 --> 00:16:11,340
‫un tempo simile, e poi l'ultimo.

310
00:16:11,340 --> 00:16:15,440
‫Bene, ecco come funziona fondamentalmente il pool di thread, quindi ho deciso

311
00:16:15,440 --> 00:16:18,660
‫di concentrarmi non solo sul ciclo degli eventi, ma

312
00:16:18,660 --> 00:16:22,630
‫anche di darti una panoramica, molto veloce, del pool di thread e

313
00:16:22,630 --> 00:16:25,010
‫di come possiamo modificare la dimensione del

314
00:16:25,010 --> 00:16:27,620
‫pool di thread , ok, tieni presente che

315
00:16:27,620 --> 00:16:29,560
‫questo codice qui è

316
00:16:29,560 --> 00:16:33,230
‫in realtà ancora asincrono, perché abbiamo passato una funzione di callback.

317
00:16:33,230 --> 00:16:36,490
‫Ok, e potremmo effettivamente usare la versione sincrona, ma

318
00:16:36,490 --> 00:16:38,920
‫ciò bloccherebbe il ciclo degli eventi.

319
00:16:38,920 --> 00:16:40,650
‫Vuoi vederlo?

320
00:16:40,650 --> 00:16:43,183
‫Quindi lascia che te lo mostri molto velocemente anche

321
00:16:44,120 --> 00:16:46,130
‫a te, in modo che uno non

322
00:16:46,130 --> 00:16:48,240
‫fosse davvero pianificato, ma facciamolo comunque, perché è

323
00:16:48,240 --> 00:16:50,090
‫molto interessante vedere che penso.

324
00:16:51,580 --> 00:16:53,830
‫Ok, quindi funzionerà così.

325
00:16:53,830 --> 00:16:57,570
‫Usiamo ancora la versione di sincronizzazione della stessa funzione, che

326
00:16:57,570 --> 00:16:59,950
‫una nota, è molte volte disponibile.

327
00:16:59,950 --> 00:17:02,760
‫Ricorda che abbiamo lo stesso per il file letto,

328
00:17:02,760 --> 00:17:05,190
‫quindi abbiamo letto file, che accetta una

329
00:17:05,190 --> 00:17:08,290
‫richiamata, e abbiamo letto sincronia file, che è la versione

330
00:17:08,290 --> 00:17:11,440
‫sincrona che non accetta alcuna richiamata, quindi proprio come questo.

331
00:17:11,440 --> 00:17:13,520
‫Quindi questo crittograferà la password,

332
00:17:13,520 --> 00:17:16,890
‫bloccherà l'esecuzione del codice e quindi passerà alla riga

333
00:17:16,890 --> 00:17:19,700
‫successiva, che quindi registrerà questo qui nella console.

334
00:17:19,700 --> 00:17:21,823
‫Quindi ora duplichiamo questo qui.

335
00:17:23,570 --> 00:17:26,553
‫Era troppo, sbarazzati di questo qui, quindi

336
00:17:27,500 --> 00:17:31,310
‫ora queste quattro crittografie della password non verranno più eseguite

337
00:17:31,310 --> 00:17:33,350
‫nel ciclo degli eventi.

338
00:17:33,350 --> 00:17:37,070
‫E quindi non verranno più scaricati nel pool di thread.

339
00:17:37,070 --> 00:17:39,980
‫Ok, quindi ora, anche se abbiamo la dimensione del

340
00:17:39,980 --> 00:17:42,583
‫pool di thread di quattro, vediamo cosa succede.

341
00:17:46,010 --> 00:17:50,080
‫Quindi vedete, accadono completamente in modo sincrono.

342
00:17:50,080 --> 00:17:53,290
‫Quindi uno dopo l'altro, e ciò che è anche

343
00:17:53,290 --> 00:17:55,350
‫peggio, è che tutti questi

344
00:17:55,350 --> 00:17:57,960
‫timer qui, anche NextTick e quello immediato,

345
00:17:57,960 --> 00:18:01,850
‫sono apparsi solo dopo che è avvenuta la crittografia delle password.

346
00:18:01,850 --> 00:18:04,990
‫Quindi questo stava davvero bloccando l'intera esecuzione, anche se

347
00:18:04,990 --> 00:18:07,460
‫questo timer qui, per esempio questo qui,

348
00:18:07,460 --> 00:18:09,580
‫è terminato dopo zero secondi e

349
00:18:09,580 --> 00:18:11,440
‫questo dopo tre secondi,

350
00:18:11,440 --> 00:18:13,830
‫ma tutti devono aspettare sette secondi prima

351
00:18:13,830 --> 00:18:16,010
‫che tutte queste crittografie della password

352
00:18:16,010 --> 00:18:19,670
‫qui siano finalmente pronti, sempre perché non erano in esecuzione all'interno

353
00:18:19,670 --> 00:18:22,120
‫del ciclo degli eventi, ma lo erano.

354
00:18:22,120 --> 00:18:24,960
‫E quindi stavano fondamentalmente lavorando in background e potevano

355
00:18:24,960 --> 00:18:26,890
‫essere rilevati dal loop degli

356
00:18:26,890 --> 00:18:29,470
‫eventi solo quando erano pronti, subito dopo

357
00:18:29,470 --> 00:18:32,110
‫queste quattro crittografie della password, quindi questo è

358
00:18:32,110 --> 00:18:34,760
‫stato un altro ottimo esempio di vedere il

359
00:18:34,760 --> 00:18:38,240
‫blocco del codice e il loop degli eventi tutti in azione.

360
00:18:38,240 --> 00:18:41,600
‫Ok, è stato abbastanza per una lezione, spero che

361
00:18:41,600 --> 00:18:43,270
‫l'abbiate trovata interessante,

362
00:18:43,270 --> 00:18:45,220
‫e ci vediamo alla prossima.