﻿1
00:00:01,830 --> 00:00:03,030
‫Istruttore: Bentornato!

2
00:00:03,030 --> 00:00:06,790
‫In questo video leggeremo file e scriveremo

3
00:00:06,790 --> 00:00:11,063
‫due file proprio come prima, ma invece in modo asincrono.

4
00:00:13,160 --> 00:00:14,960
‫Aggiungiamo alcuni commenti qui prima.

5
00:00:19,630 --> 00:00:21,183
‫Quindi, questo

6
00:00:26,160 --> 00:00:31,160
‫è il modo sincrono di blocco, quindi faremo un

7
00:00:32,870 --> 00:00:36,480
‫esercizio in modo asincrono non bloccante.

8
00:00:36,480 --> 00:00:38,230
‫Quindi, non faremo

9
00:00:38,230 --> 00:00:40,300
‫la stessa cosa, inventeremo solo

10
00:00:40,300 --> 00:00:43,150
‫qualche altro tipo di esercizio folle qui.

11
00:00:43,150 --> 00:00:46,350
‫Quindi, per leggere un file in modo

12
00:00:46,350 --> 00:00:48,410
‫asincrono, funziona così.

13
00:00:48,410 --> 00:00:53,380
‫Ancora una volta, abbiamo bisogno del modulo FS e quindi di leggere il file, ma questa

14
00:00:54,890 --> 00:00:57,920
‫volta non di leggere la sincronizzazione dei file, ovviamente.

15
00:00:57,920 --> 00:01:01,930
‫E, di nuovo, passiamo il nome del file, o il percorso del

16
00:01:01,930 --> 00:01:04,060
‫file in realtà, e così di

17
00:01:04,060 --> 00:01:07,360
‫nuovo, è txt, e il file che voglio in

18
00:01:07,360 --> 00:01:11,583
‫questo momento si chiama start. txt,

19
00:01:12,460 --> 00:01:14,603
‫quindi questo.

20
00:01:16,040 --> 00:01:17,860
‫Ops, mi dispiace per quello.

21
00:01:17,860 --> 00:01:21,790
‫Quindi, questo è il file che voglio, sul compito è leggere questo,

22
00:01:21,790 --> 00:01:24,660
‫e ti spiegherò perché un po' più tardi.

23
00:01:24,660 --> 00:01:26,860
‫Per ora, non preoccuparti per il contenuto qui.

24
00:01:28,220 --> 00:01:29,360
‫Quindi, nel

25
00:01:29,360 --> 00:01:34,360
‫file letto, in realtà non dobbiamo specificare la codifica del file, ok.

26
00:01:34,580 --> 00:01:36,090
‫E così, il

27
00:01:36,090 --> 00:01:39,500
‫prossimo parametro, il secondo sarà una funzione di callback,

28
00:01:39,500 --> 00:01:42,270
‫ed è quello che abbiamo imparato nell'ultima lezione.

29
00:01:42,270 --> 00:01:45,380
‫Quindi, Node JS è interamente costruito attorno

30
00:01:45,380 --> 00:01:48,750
‫ai callback per implementare un comportamento asincrono, ed è

31
00:01:48,750 --> 00:01:50,200
‫così che funziona.

32
00:01:50,200 --> 00:01:53,080
‫Quindi, Node inizierà a leggere

33
00:01:53,080 --> 00:01:56,470
‫questo file qui in background, e non appena

34
00:01:56,470 --> 00:02:00,543
‫sarà pronto, avvierà la funzione di callback che specifichiamo qui.

35
00:02:03,880 --> 00:02:06,730
‫Ok, e chiama questa funzione di callback

36
00:02:06,730 --> 00:02:08,450
‫con due argomenti.

37
00:02:08,450 --> 00:02:11,440
‫Il primo è l'errore e

38
00:02:11,440 --> 00:02:15,560
‫il secondo sono i dati effettivi, ok?

39
00:02:15,560 --> 00:02:19,130
‫Quindi, questo primo stile di callback di errore è

40
00:02:19,130 --> 00:02:22,090
‫molto tipico in Node JS, ok.

41
00:02:22,090 --> 00:02:24,910
‫Quindi, molte, molte volte, il primo

42
00:02:24,910 --> 00:02:28,730
‫parametro in un callback sarà l'errore, nel caso ce

43
00:02:28,730 --> 00:02:33,060
‫ne fosse, e il secondo sarà quindi i dati stessi.

44
00:02:33,060 --> 00:02:34,403
‫Ciò che conta

45
00:02:34,403 --> 00:02:38,610
‫qui è che l'errore di solito è sempre il primo, ok?

46
00:02:38,610 --> 00:02:41,740
‫E quindi, solo per testarlo

47
00:02:41,740 --> 00:02:46,740
‫per ora, accediamo semplicemente alla console, i dati.

48
00:02:47,100 --> 00:02:50,050
‫E quindi, ora proviamolo effettivamente.

49
00:02:50,050 --> 00:02:51,520
‫Ma, prima di

50
00:02:51,520 --> 00:02:55,793
‫farlo, specifichiamo ancora qui il codice di archiviazione, ok?

51
00:02:57,820 --> 00:03:00,160
‫Quindi, non sono sicuro al cento

52
00:03:00,160 --> 00:03:01,933
‫per cento che funzioni

53
00:03:04,190 --> 00:03:09,190
‫senza questo, quindi puliscilo ora, eseguilo di nuovo, e qui vediamo leggere questo.

54
00:03:10,400 --> 00:03:13,790
‫Quindi, analizziamo, ancora una volta, cosa è successo qui.

55
00:03:13,790 --> 00:03:17,260
‫Non appena questa funzione viene eseguita, inizierà

56
00:03:17,260 --> 00:03:20,980
‫a leggere questo file in background senza bloccare

57
00:03:20,980 --> 00:03:24,083
‫il resto dell'esecuzione del codice.

58
00:03:24,970 --> 00:03:27,663
‫Quindi, lasciatemi effettivamente dimostrare questo qui.

59
00:03:29,290 --> 00:03:30,690
‫Quindi, una console. log

60
00:03:33,370 --> 00:03:38,370
‫leggerà il file e, solo per avere un po'

61
00:03:38,530 --> 00:03:43,170
‫meno confusione, lasciami commentare questa parte qui, ok.

62
00:03:43,170 --> 00:03:45,970
‫E quindi, cosa pensi che accadrà ora?

63
00:03:45,970 --> 00:03:48,533
‫Quale registro vedremo per primo?

64
00:03:51,830 --> 00:03:55,060
‫E infatti, prima vediamo will read

65
00:03:55,060 --> 00:03:58,470
‫file e, solo allora, vediamo read this.

66
00:03:58,470 --> 00:04:00,960
‫Quindi, di nuovo, perché è successo?

67
00:04:00,960 --> 00:04:04,400
‫Quindi, come ho detto, Node JS inizierà a leggere

68
00:04:04,400 --> 00:04:07,570
‫il file in background qui e non

69
00:04:07,570 --> 00:04:11,760
‫bloccherà il codice, quindi passerà immediatamente alla riga di codice successiva.

70
00:04:11,760 --> 00:04:15,240
‫E la prossima riga di codice, beh, è questo registro qui,

71
00:04:15,240 --> 00:04:17,030
‫quindi questa è la prima

72
00:04:17,030 --> 00:04:19,520
‫cosa che verrà registrata qui sul terminale.

73
00:04:19,520 --> 00:04:22,760
‫Solo allora, quando un file viene letto

74
00:04:22,760 --> 00:04:26,580
‫completamente, questa funzione di callback qui verrà eseguita, ok?

75
00:04:26,580 --> 00:04:30,810
‫E ancora, questa funzione di callback ha accesso all'errore e ai

76
00:04:30,810 --> 00:04:33,070
‫dati che sono stati

77
00:04:33,070 --> 00:04:36,260
‫letti, e potremmo davvero chiamarlo qui come volevamo.

78
00:04:36,260 --> 00:04:39,250
‫Potremmo chiamarlo anche testo, non ha molta importanza, tutto ciò

79
00:04:39,250 --> 00:04:42,240
‫che importa è che è il secondo argomento in

80
00:04:42,240 --> 00:04:43,713
‫questa funzione di callback.

81
00:04:44,670 --> 00:04:47,070
‫In realtà torniamo ai dati

82
00:04:47,070 --> 00:04:49,740
‫perché mi piace di più così.

83
00:04:49,740 --> 00:04:54,740
‫E così, solo allora, questa console. log verrà eseguito con i dati,

84
00:04:54,900 --> 00:04:57,510
‫quindi con il testo che era nel file.

85
00:04:57,510 --> 00:05:01,480
‫E quindi, ecco perché lo vediamo qui come secondo registro.

86
00:05:01,480 --> 00:05:04,430
‫Va bene, ora per andare

87
00:05:04,430 --> 00:05:08,860
‫ancora oltre, facciamo un altro file letto, ma invece di

88
00:05:08,860 --> 00:05:11,990
‫questo, così posso mostrarti che possiamo fondamentalmente

89
00:05:11,990 --> 00:05:16,130
‫fare più passaggi, uno dopo l'altro, con i callback.

90
00:05:16,130 --> 00:05:20,810
‫Quindi, passaggi che dipendono dal risultato del passaggio precedente.

91
00:05:20,810 --> 00:05:25,310
‫Ok, ecco perché in realtà nel file di avvio ho letto

92
00:05:25,310 --> 00:05:26,610
‫questo perché

93
00:05:26,610 --> 00:05:29,930
‫poi c'è un file chiamato leggi questo, che

94
00:05:29,930 --> 00:05:33,103
‫ha il contenuto a cui siamo effettivamente interessati.

95
00:05:34,090 --> 00:05:34,923
‫Bene?

96
00:05:37,060 --> 00:05:39,963
‫Quindi, quello che farò qui è copiare questo

97
00:05:40,890 --> 00:05:42,793
‫codice e inserirlo qui.

98
00:05:44,740 --> 00:05:48,210
‫Chiamerò questo dato uno, quindi dati due

99
00:05:48,210 --> 00:05:52,900
‫e il risultato del secondo passaggio, quindi il secondo file

100
00:05:52,900 --> 00:05:55,140
‫letto dipenderà dal primo.

101
00:05:55,140 --> 00:06:00,140
‫Questo perché useremo i dati per il nome del file, ricordi?

102
00:06:02,030 --> 00:06:05,340
‫Quindi, qui stiamo facendo un (mumbles) ora

103
00:06:06,290 --> 00:06:10,730
‫perché dobbiamo inserire quella variabile e si chiama data

104
00:06:14,490 --> 00:06:15,323
‫one.

105
00:06:16,330 --> 00:06:18,290
‫Ok, ha senso?

106
00:06:18,290 --> 00:06:22,900
‫Quindi, i dati uno verranno letti questo, ok, e quindi,

107
00:06:22,900 --> 00:06:27,900
‫nel passaggio successivo, leggeremo txt/readthis. txt, che è

108
00:06:30,090 --> 00:06:31,910
‫quindi questo.

109
00:06:31,910 --> 00:06:35,110
‫Ok, ecco perché questo nome di file qui è

110
00:06:35,110 --> 00:06:37,053
‫lo stesso di questo contenuto.

111
00:06:39,340 --> 00:06:42,283
‫E quindi, questo viene registrato tramite i dati della console su quello.

112
00:06:43,310 --> 00:06:45,833
‫E, testiamo rapidamente se funziona, e in effetti,

113
00:06:48,370 --> 00:06:53,370
‫questo è il contenuto di leggi questo. TXT.

114
00:06:53,860 --> 00:06:57,030
‫E ora farò un ulteriore passo avanti anche

115
00:06:57,030 --> 00:07:00,740
‫perché c'è dell'altro testo in questo file di aggiunta che

116
00:07:00,740 --> 00:07:04,080
‫voglio aggiungere a questa prima stringa, quindi c'è

117
00:07:04,080 --> 00:07:06,420
‫del testo proveniente dall'altro file.

118
00:07:06,420 --> 00:07:08,590
‫E così, abbiamo ancora un

119
00:07:08,590 --> 00:07:10,840
‫altro passaggio che dipende dal passaggio precedente,

120
00:07:10,840 --> 00:07:14,563
‫quindi quello che farò è aggiungere un altro file letto qui.

121
00:07:15,560 --> 00:07:17,660
‫Quindi, proprio così.

122
00:07:17,660 --> 00:07:19,313
‫Quindi, questo si chiama

123
00:07:21,610 --> 00:07:26,610
‫append, e questo lo chiamerò i dati tre, i dati tre qui, e

124
00:07:27,720 --> 00:07:30,133
‫quindi questo è, di nuovo, eseguilo.

125
00:07:32,760 --> 00:07:37,570
‫E, ok, ora abbiamo questi due risultati qui.

126
00:07:37,570 --> 00:07:40,830
‫Va bene, e ora finalmente, come ultimo

127
00:07:40,830 --> 00:07:44,030
‫passaggio, voglio scrivere queste due stringhe insieme

128
00:07:44,030 --> 00:07:46,360
‫in un file, ok?

129
00:07:46,360 --> 00:07:48,500
‫Finora abbiamo solo letto

130
00:07:48,500 --> 00:07:51,160
‫file, ma voglio scrivere anche un

131
00:07:51,160 --> 00:07:53,730
‫file, quindi facciamolo anche qui.

132
00:07:53,730 --> 00:07:54,623
‫Quindi, f.

133
00:07:57,480 --> 00:08:01,100
‫writeFile e, naturalmente, non stiamo usando quella sincrona come

134
00:08:01,100 --> 00:08:02,140
‫abbiamo fatto prima,

135
00:08:02,140 --> 00:08:06,320
‫ma ancora una volta usiamo, proprio come qui e qui

136
00:08:06,320 --> 00:08:10,113
‫e qui, usiamo la versione asincrona, non quella sincrona.

137
00:08:11,600 --> 00:08:16,600
‫Quindi, txt slash, manca questo qui,

138
00:08:19,240 --> 00:08:20,143
‫finale.

139
00:08:22,314 --> 00:08:25,933
‫Quindi, dovremmo aggiungere anche qui la codifica del testo, e quindi

140
00:08:29,650 --> 00:08:33,040
‫anche questa accetta una funzione di callback, ma in questo

141
00:08:33,040 --> 00:08:36,220
‫caso non ci sono dati che leggiamo, quindi non

142
00:08:36,220 --> 00:08:38,370
‫abbiamo bisogno di due argomenti.

143
00:08:38,370 --> 00:08:41,933
‫Quindi, l'unico argomento che abbiamo è l'errore, in realtà.

144
00:08:44,100 --> 00:08:48,980
‫Ok, quindi qui abbiamo l'errore e i dati che sono stati letti,

145
00:08:48,980 --> 00:08:52,270
‫ma qui in writeFile non ci sono dati.

146
00:08:52,270 --> 00:08:56,690
‫Tutto ciò che c'è, o può essere, è un errore, ok?

147
00:08:56,690 --> 00:08:58,530
‫E in realtà, qui

148
00:08:58,530 --> 00:09:03,063
‫ci manca qualcosa, che è ciò che in realtà vogliamo scrivere nel file.

149
00:09:03,910 --> 00:09:06,430
‫Ok, quindi questo è il secondo argomento,

150
00:09:06,430 --> 00:09:11,100
‫e di cosa si tratta, sono i dati due e i dati tre.

151
00:09:11,100 --> 00:09:12,823
‫Quindi, di nuovo una stringa

152
00:09:14,340 --> 00:09:16,063
‫(mumbles) qui, i dati

153
00:09:17,620 --> 00:09:21,323
‫due, quindi un nuovo carattere di riga, che di nuovo è una

154
00:09:23,010 --> 00:09:25,523
‫barra rovesciata n, e quindi i dati 3.

155
00:09:27,360 --> 00:09:32,010
‫Va bene, e quindi, proprio come con le funzioni di lettura dei file, questo

156
00:09:32,010 --> 00:09:35,800
‫callback è ciò che viene eseguito alla fine, quindi quello che farò

157
00:09:35,800 --> 00:09:38,660
‫qui è semplicemente accedere tramite console che i file

158
00:09:38,660 --> 00:09:40,613
‫sono stati scritti o che il

159
00:09:41,490 --> 00:09:43,190
‫file ha stato scritto.

160
00:09:44,430 --> 00:09:49,360
‫Il tuo file è stato scritto, e usiamo solo

161
00:09:49,360 --> 00:09:53,220
‫qualche emoji divertente qui, solo per rendere

162
00:09:53,220 --> 00:09:56,883
‫la console un po' più

163
00:09:58,300 --> 00:10:03,080
‫luminosa per noi, e penso che dovremmo fare così.

164
00:10:03,080 --> 00:10:06,023
‫Quindi, ripuliamo la console ancora una volta, eseguiamola e

165
00:10:07,370 --> 00:10:10,560
‫in effetti vediamo che il tuo file è stato scritto.

166
00:10:10,560 --> 00:10:11,833
‫Quindi, lo ha davvero?

167
00:10:13,460 --> 00:10:14,990
‫Finale.

168
00:10:14,990 --> 00:10:16,433
‫Oh, sì, eccolo qui.

169
00:10:18,140 --> 00:10:22,040
‫Quindi, questo è leggere questo testo

170
00:10:22,040 --> 00:10:27,040
‫e aggiungere testo, entrambi insieme, entrambi nello stesso file.

171
00:10:27,490 --> 00:10:32,490
‫Ok, è così che eseguiamo più passaggi negli ordini, utilizzando

172
00:10:33,160 --> 00:10:36,270
‫le funzioni di callback, giusto?

173
00:10:36,270 --> 00:10:40,180
‫Perché immagina di aver semplicemente letto lo stesso file e

174
00:10:40,180 --> 00:10:42,490
‫poi letto il secondo file, quindi

175
00:10:42,490 --> 00:10:44,060
‫questo, subito dopo.

176
00:10:44,060 --> 00:10:46,770
‫Bene, come avresti quindi accesso ai

177
00:10:46,770 --> 00:10:49,200
‫dati dal primo, giusto?

178
00:10:49,200 --> 00:10:52,420
‫E così, è così che emerge questo schema.

179
00:10:52,420 --> 00:10:53,720
‫In realtà ha

180
00:10:53,720 --> 00:10:55,930
‫il suo nome, e penso di aver

181
00:10:55,930 --> 00:10:58,240
‫detto che nell'ultimo video, è chiamato callback

182
00:10:58,240 --> 00:11:01,490
‫hell, e ci sono alcune soluzioni per rendere questo codice

183
00:11:01,490 --> 00:11:04,080
‫qui più leggibile e migliore da capire, ma

184
00:11:04,080 --> 00:11:07,130
‫per ora, questo non lo fa importa affatto per te.

185
00:11:07,130 --> 00:11:10,650
‫Ciò che conta è che Node JS è

186
00:11:10,650 --> 00:11:13,480
‫costruito attorno a questa filosofia dei callback,

187
00:11:13,480 --> 00:11:17,530
‫quindi è così che Node JS implementa le operazioni asincrone,

188
00:11:17,530 --> 00:11:20,330
‫chiamando i callback non appena

189
00:11:20,330 --> 00:11:23,260
‫l'operazione che sta facendo è stata completata.

190
00:11:23,260 --> 00:11:26,280
‫E, a proposito, questo modo di scrivere funzione

191
00:11:26,280 --> 00:11:28,110
‫che vedi qui, di nuovo,

192
00:11:28,110 --> 00:11:29,870
‫nel caso non

193
00:11:29,870 --> 00:11:33,420
‫lo avessi familiarità, è anche la nuova sintassi ES6, ok?

194
00:11:33,420 --> 00:11:36,320
‫Quindi, di nuovo, spero che tu abbia familiarità

195
00:11:36,320 --> 00:11:38,550
‫con ES6 a questo punto

196
00:11:38,550 --> 00:11:41,950
‫e che tutto questo abbia perfettamente senso per te.

197
00:11:41,950 --> 00:11:44,580
‫Se dovessi scrivere questa funzione

198
00:11:45,700 --> 00:11:49,461
‫qui senza la sintassi della funzione di

199
00:11:49,461 --> 00:11:54,461
‫errore, faremmo semplicemente così, funzione, err, dati uno, e

200
00:11:55,950 --> 00:11:57,600
‫poi così.

201
00:11:57,600 --> 00:11:59,470
‫Quindi, questa è

202
00:11:59,470 --> 00:12:02,210
‫una funzione normale, diciamo una funzione

203
00:12:02,210 --> 00:12:05,470
‫vecchio stile, e la nuova versione funziona così.

204
00:12:05,470 --> 00:12:09,490
‫La differenza tra loro è principalmente la sintassi, ma anche

205
00:12:09,490 --> 00:12:12,690
‫il fatto che una funzione di errore, quindi

206
00:12:12,690 --> 00:12:14,360
‫questo tipo di

207
00:12:14,360 --> 00:12:17,070
‫funzione, non ottiene la propria parola chiave

208
00:12:17,070 --> 00:12:20,860
‫disco, quindi utilizza la parola chiave disco dalla funzione padre.

209
00:12:20,860 --> 00:12:24,540
‫E questa è chiamata la parola chiave del disco lessicale,

210
00:12:24,540 --> 00:12:27,500
‫mentre una funzione normale come questa

211
00:12:27,500 --> 00:12:30,920
‫ottiene sempre la propria parola chiave del disco, giusto?

212
00:12:30,920 --> 00:12:33,610
‫Sono sicuro che hai familiarità con quel tipo di

213
00:12:33,610 --> 00:12:37,640
‫cose, ma solo facendo una piccola recensione qui nel caso in cui non lo fossi.

214
00:12:37,640 --> 00:12:39,673
‫Ok, spero di averlo fatto da allora.

215
00:12:40,600 --> 00:12:44,150
‫In realtà non abbiamo mai usato questo errore, non

216
00:12:44,150 --> 00:12:46,160
‫abbiamo gestito alcun errore,

217
00:12:46,160 --> 00:12:50,060
‫quindi, ad esempio, immagina che questo file qui non esistesse.

218
00:12:50,060 --> 00:12:52,490
‫Bene, avremmo potuto usare questo errore,

219
00:12:52,490 --> 00:12:56,300
‫e facciamolo davvero, ma solo per questo qui, quindi non

220
00:12:56,300 --> 00:13:00,820
‫voglio creare tutti questi gestori di errori qui, ma proprio in questa

221
00:13:00,820 --> 00:13:04,100
‫situazione, diciamo che c'è stato un errore, e

222
00:13:04,100 --> 00:13:06,463
‫quindi diciamo se errore, il

223
00:13:07,340 --> 00:13:10,373
‫ritorno da questa funzione, quindi non fare nient'altro,

224
00:13:12,290 --> 00:13:13,743
‫e accedere alla

225
00:13:18,050 --> 00:13:22,260
‫console, errore, e poi possiamo aggiungere qualche altra emoji qui, come

226
00:13:22,260 --> 00:13:25,653
‫questa esplosione, quindi come se qualcosa fosse esploso qui.

227
00:13:28,010 --> 00:13:32,933
‫Quindi, ora cambiamo questo qui, come inizio. txt, eseguilo di nuovo, e

228
00:13:33,900 --> 00:13:34,973
‫quindi,

229
00:13:36,090 --> 00:13:39,980
‫abbiamo questo errore ora, quindi ci dà questo registro

230
00:13:39,980 --> 00:13:42,570
‫alla console e, poiché siamo tornati,

231
00:13:42,570 --> 00:13:46,200
‫non farà nulla dopo, quindi tutto questo viene

232
00:13:46,200 --> 00:13:49,990
‫sostanzialmente ignorato e non verrà eseguito , che è

233
00:13:49,990 --> 00:13:51,823
‫esattamente quello che vogliamo.

234
00:13:52,680 --> 00:13:55,863
‫Giusto, ma se lo riportiamo alla normalità e poi

235
00:13:57,720 --> 00:13:59,090
‫lo eseguiamo di

236
00:13:59,090 --> 00:14:02,010
‫nuovo, beh, allora tutto funziona come prima.

237
00:14:02,010 --> 00:14:05,270
‫Quindi, abituati a questo modello di callback perché

238
00:14:05,270 --> 00:14:08,270
‫lo vedrai ovunque in Node JS e

239
00:14:08,270 --> 00:14:10,163
‫in tutta questa sezione.

