‫Istruttore: Bentornato!
‫In questo video leggeremo file e scriveremo
‫due file proprio come prima, ma invece in modo asincrono.
‫Aggiungiamo alcuni commenti qui prima.
‫Quindi, questo
‫è il modo sincrono di blocco, quindi faremo un
‫esercizio in modo asincrono non bloccante.
‫Quindi, non faremo
‫la stessa cosa, inventeremo solo
‫qualche altro tipo di esercizio folle qui.
‫Quindi, per leggere un file in modo
‫asincrono, funziona così.
‫Ancora una volta, abbiamo bisogno del modulo FS e quindi di leggere il file, ma questa
‫volta non di leggere la sincronizzazione dei file, ovviamente.
‫E, di nuovo, passiamo il nome del file, o il percorso del
‫file in realtà, e così di
‫nuovo, è txt, e il file che voglio in
‫questo momento si chiama start. txt,
‫quindi questo.
‫Ops, mi dispiace per quello.
‫Quindi, questo è il file che voglio, sul compito è leggere questo,
‫e ti spiegherò perché un po' più tardi.
‫Per ora, non preoccuparti per il contenuto qui.
‫Quindi, nel
‫file letto, in realtà non dobbiamo specificare la codifica del file, ok.
‫E così, il
‫prossimo parametro, il secondo sarà una funzione di callback,
‫ed è quello che abbiamo imparato nell'ultima lezione.
‫Quindi, Node JS è interamente costruito attorno
‫ai callback per implementare un comportamento asincrono, ed è
‫così che funziona.
‫Quindi, Node inizierà a leggere
‫questo file qui in background, e non appena
‫sarà pronto, avvierà la funzione di callback che specifichiamo qui.
‫Ok, e chiama questa funzione di callback
‫con due argomenti.
‫Il primo è l'errore e
‫il secondo sono i dati effettivi, ok?
‫Quindi, questo primo stile di callback di errore è
‫molto tipico in Node JS, ok.
‫Quindi, molte, molte volte, il primo
‫parametro in un callback sarà l'errore, nel caso ce
‫ne fosse, e il secondo sarà quindi i dati stessi.
‫Ciò che conta
‫qui è che l'errore di solito è sempre il primo, ok?
‫E quindi, solo per testarlo
‫per ora, accediamo semplicemente alla console, i dati.
‫E quindi, ora proviamolo effettivamente.
‫Ma, prima di
‫farlo, specifichiamo ancora qui il codice di archiviazione, ok?
‫Quindi, non sono sicuro al cento
‫per cento che funzioni
‫senza questo, quindi puliscilo ora, eseguilo di nuovo, e qui vediamo leggere questo.
‫Quindi, analizziamo, ancora una volta, cosa è successo qui.
‫Non appena questa funzione viene eseguita, inizierà
‫a leggere questo file in background senza bloccare
‫il resto dell'esecuzione del codice.
‫Quindi, lasciatemi effettivamente dimostrare questo qui.
‫Quindi, una console. log
‫leggerà il file e, solo per avere un po'
‫meno confusione, lasciami commentare questa parte qui, ok.
‫E quindi, cosa pensi che accadrà ora?
‫Quale registro vedremo per primo?
‫E infatti, prima vediamo will read
‫file e, solo allora, vediamo read this.
‫Quindi, di nuovo, perché è successo?
‫Quindi, come ho detto, Node JS inizierà a leggere
‫il file in background qui e non
‫bloccherà il codice, quindi passerà immediatamente alla riga di codice successiva.
‫E la prossima riga di codice, beh, è questo registro qui,
‫quindi questa è la prima
‫cosa che verrà registrata qui sul terminale.
‫Solo allora, quando un file viene letto
‫completamente, questa funzione di callback qui verrà eseguita, ok?
‫E ancora, questa funzione di callback ha accesso all'errore e ai
‫dati che sono stati
‫letti, e potremmo davvero chiamarlo qui come volevamo.
‫Potremmo chiamarlo anche testo, non ha molta importanza, tutto ciò
‫che importa è che è il secondo argomento in
‫questa funzione di callback.
‫In realtà torniamo ai dati
‫perché mi piace di più così.
‫E così, solo allora, questa console. log verrà eseguito con i dati,
‫quindi con il testo che era nel file.
‫E quindi, ecco perché lo vediamo qui come secondo registro.
‫Va bene, ora per andare
‫ancora oltre, facciamo un altro file letto, ma invece di
‫questo, così posso mostrarti che possiamo fondamentalmente
‫fare più passaggi, uno dopo l'altro, con i callback.
‫Quindi, passaggi che dipendono dal risultato del passaggio precedente.
‫Ok, ecco perché in realtà nel file di avvio ho letto
‫questo perché
‫poi c'è un file chiamato leggi questo, che
‫ha il contenuto a cui siamo effettivamente interessati.
‫Bene?
‫Quindi, quello che farò qui è copiare questo
‫codice e inserirlo qui.
‫Chiamerò questo dato uno, quindi dati due
‫e il risultato del secondo passaggio, quindi il secondo file
‫letto dipenderà dal primo.
‫Questo perché useremo i dati per il nome del file, ricordi?
‫Quindi, qui stiamo facendo un (mumbles) ora
‫perché dobbiamo inserire quella variabile e si chiama data
‫one.
‫Ok, ha senso?
‫Quindi, i dati uno verranno letti questo, ok, e quindi,
‫nel passaggio successivo, leggeremo txt/readthis. txt, che è
‫quindi questo.
‫Ok, ecco perché questo nome di file qui è
‫lo stesso di questo contenuto.
‫E quindi, questo viene registrato tramite i dati della console su quello.
‫E, testiamo rapidamente se funziona, e in effetti,
‫questo è il contenuto di leggi questo. TXT.
‫E ora farò un ulteriore passo avanti anche
‫perché c'è dell'altro testo in questo file di aggiunta che
‫voglio aggiungere a questa prima stringa, quindi c'è
‫del testo proveniente dall'altro file.
‫E così, abbiamo ancora un
‫altro passaggio che dipende dal passaggio precedente,
‫quindi quello che farò è aggiungere un altro file letto qui.
‫Quindi, proprio così.
‫Quindi, questo si chiama
‫append, e questo lo chiamerò i dati tre, i dati tre qui, e
‫quindi questo è, di nuovo, eseguilo.
‫E, ok, ora abbiamo questi due risultati qui.
‫Va bene, e ora finalmente, come ultimo
‫passaggio, voglio scrivere queste due stringhe insieme
‫in un file, ok?
‫Finora abbiamo solo letto
‫file, ma voglio scrivere anche un
‫file, quindi facciamolo anche qui.
‫Quindi, f.
‫writeFile e, naturalmente, non stiamo usando quella sincrona come
‫abbiamo fatto prima,
‫ma ancora una volta usiamo, proprio come qui e qui
‫e qui, usiamo la versione asincrona, non quella sincrona.
‫Quindi, txt slash, manca questo qui,
‫finale.
‫Quindi, dovremmo aggiungere anche qui la codifica del testo, e quindi
‫anche questa accetta una funzione di callback, ma in questo
‫caso non ci sono dati che leggiamo, quindi non
‫abbiamo bisogno di due argomenti.
‫Quindi, l'unico argomento che abbiamo è l'errore, in realtà.
‫Ok, quindi qui abbiamo l'errore e i dati che sono stati letti,
‫ma qui in writeFile non ci sono dati.
‫Tutto ciò che c'è, o può essere, è un errore, ok?
‫E in realtà, qui
‫ci manca qualcosa, che è ciò che in realtà vogliamo scrivere nel file.
‫Ok, quindi questo è il secondo argomento,
‫e di cosa si tratta, sono i dati due e i dati tre.
‫Quindi, di nuovo una stringa
‫(mumbles) qui, i dati
‫due, quindi un nuovo carattere di riga, che di nuovo è una
‫barra rovesciata n, e quindi i dati 3.
‫Va bene, e quindi, proprio come con le funzioni di lettura dei file, questo
‫callback è ciò che viene eseguito alla fine, quindi quello che farò
‫qui è semplicemente accedere tramite console che i file
‫sono stati scritti o che il
‫file ha stato scritto.
‫Il tuo file è stato scritto, e usiamo solo
‫qualche emoji divertente qui, solo per rendere
‫la console un po' più
‫luminosa per noi, e penso che dovremmo fare così.
‫Quindi, ripuliamo la console ancora una volta, eseguiamola e
‫in effetti vediamo che il tuo file è stato scritto.
‫Quindi, lo ha davvero?
‫Finale.
‫Oh, sì, eccolo qui.
‫Quindi, questo è leggere questo testo
‫e aggiungere testo, entrambi insieme, entrambi nello stesso file.
‫Ok, è così che eseguiamo più passaggi negli ordini, utilizzando
‫le funzioni di callback, giusto?
‫Perché immagina di aver semplicemente letto lo stesso file e
‫poi letto il secondo file, quindi
‫questo, subito dopo.
‫Bene, come avresti quindi accesso ai
‫dati dal primo, giusto?
‫E così, è così che emerge questo schema.
‫In realtà ha
‫il suo nome, e penso di aver
‫detto che nell'ultimo video, è chiamato callback
‫hell, e ci sono alcune soluzioni per rendere questo codice
‫qui più leggibile e migliore da capire, ma
‫per ora, questo non lo fa importa affatto per te.
‫Ciò che conta è che Node JS è
‫costruito attorno a questa filosofia dei callback,
‫quindi è così che Node JS implementa le operazioni asincrone,
‫chiamando i callback non appena
‫l'operazione che sta facendo è stata completata.
‫E, a proposito, questo modo di scrivere funzione
‫che vedi qui, di nuovo,
‫nel caso non
‫lo avessi familiarità, è anche la nuova sintassi ES6, ok?
‫Quindi, di nuovo, spero che tu abbia familiarità
‫con ES6 a questo punto
‫e che tutto questo abbia perfettamente senso per te.
‫Se dovessi scrivere questa funzione
‫qui senza la sintassi della funzione di
‫errore, faremmo semplicemente così, funzione, err, dati uno, e
‫poi così.
‫Quindi, questa è
‫una funzione normale, diciamo una funzione
‫vecchio stile, e la nuova versione funziona così.
‫La differenza tra loro è principalmente la sintassi, ma anche
‫il fatto che una funzione di errore, quindi
‫questo tipo di
‫funzione, non ottiene la propria parola chiave
‫disco, quindi utilizza la parola chiave disco dalla funzione padre.
‫E questa è chiamata la parola chiave del disco lessicale,
‫mentre una funzione normale come questa
‫ottiene sempre la propria parola chiave del disco, giusto?
‫Sono sicuro che hai familiarità con quel tipo di
‫cose, ma solo facendo una piccola recensione qui nel caso in cui non lo fossi.
‫Ok, spero di averlo fatto da allora.
‫In realtà non abbiamo mai usato questo errore, non
‫abbiamo gestito alcun errore,
‫quindi, ad esempio, immagina che questo file qui non esistesse.
‫Bene, avremmo potuto usare questo errore,
‫e facciamolo davvero, ma solo per questo qui, quindi non
‫voglio creare tutti questi gestori di errori qui, ma proprio in questa
‫situazione, diciamo che c'è stato un errore, e
‫quindi diciamo se errore, il
‫ritorno da questa funzione, quindi non fare nient'altro,
‫e accedere alla
‫console, errore, e poi possiamo aggiungere qualche altra emoji qui, come
‫questa esplosione, quindi come se qualcosa fosse esploso qui.
‫Quindi, ora cambiamo questo qui, come inizio. txt, eseguilo di nuovo, e
‫quindi,
‫abbiamo questo errore ora, quindi ci dà questo registro
‫alla console e, poiché siamo tornati,
‫non farà nulla dopo, quindi tutto questo viene
‫sostanzialmente ignorato e non verrà eseguito , che è
‫esattamente quello che vogliamo.
‫Giusto, ma se lo riportiamo alla normalità e poi
‫lo eseguiamo di
‫nuovo, beh, allora tutto funziona come prima.
‫Quindi, abituati a questo modello di callback perché
‫lo vedrai ovunque in Node JS e
‫in tutta questa sezione.