‫Istruttore: In questo video, promettiamo
‫le funzioni di lettura e scrittura del file.
‫Ciò significa che li faremo in modo
‫che restituiscano le promesse
‫invece di passare loro una funzione di callback.
‫Quindi, se lo desideri, è fondamentalmente una funzione di lettura
‫del file che restituisce una
‫promessa e che riceve solo un nome di file, nessuna richiamata.
‫Quindi facciamo esattamente questo.
‫Quindi, creeremo una funzione di lettura file pro.
‫Quindi pro per la promessa perché restituisce
‫di nuovo una promessa.
‫E poi tutto ciò che facciamo è
‫passare il nome del file e, come dicevamo, restituire una promessa.
‫Quindi, restituisci una nuova promessa.
‫Quindi usiamo qui il costruttore di
‫promesse che è stato introdotto nel linguaggio con ES6.
‫Quindi prima di ES6 come ES5, ES4
‫e tutte le
‫versioni precedenti, non c'era supporto per le promesse in JavaScript.
‫Ma l'hanno cambiato in ES6
‫e hanno reso la lingua molto migliore in questo senso.
‫Quindi, per quanto riguarda JavaScript asincrono.
‫Ora questo costruttore di promesse
‫qui contiene una cosiddetta funzione di esecuzione,
‫che verrà chiamata immediatamente quando viene creata la promessa.
‫E questa funzione accetterà due argomenti, quindi
‫risolvi e rifiuta.
‫Quindi risolvi e rifiuta,
‫ma per ora non preoccuparti per
‫loro, ne parleremo tra un minuto.
‫Per ora concentriamoci solo su questa funzione di esecuzione
‫stessa perché è qui che svolgiamo effettivamente
‫tutto questo lavoro asincrono.
‫In questo caso il file letto funziona.
‫Quindi è qui che chiameremo fs. readfile con
‫il nome del file
‫passato e poi la consueta funzione di callback, okay.
‫Quindi l'errore e i dati, proprio
‫come prima.
‫Quindi tieni presente che in
‫realtà non stiamo cambiando la funzione di lettura
‫file stiamo semplicemente creando una
‫nuova funzione che dietro le quinte ovviamente esegue ancora la
‫funzione di lettura file incorporata ma poi restituisce
‫una promessa in modo che
‫possiamo invece usare
‫la promessa della funzione di callback.
‫Va bene.
‫Quindi abbiamo quella funzione di lettura del file
‫qui che farà il
‫suo lavoro e quando sarà pronta tornerà con i dati.
‫Ed ora è qui che entrano
‫in gioco le funzioni di risoluzione e di rifiuto.
‫Poiché entrambi questi argomenti
‫disponibili nella funzione executor sono entrambi funzioni.
‫Ora la chiamata alla
‫funzione di risoluzione segnerà sostanzialmente la promessa come riuscita e
‫quindi come
‫soddisfatta e restituirà il valore di successo dalla promessa.
‫Quindi facciamolo davvero.
‫Quindi chiamiamo risolvere con i dati.
‫Quindi qualunque variabile passiamo alla funzione di risoluzione
‫è ciò che sarà disponibile
‫in seguito come argomento nel metodo then, va bene?
‫Quindi questi dati qui saranno il
‫valore che questa promessa ci restituisce, ok.
‫Probabilmente suona un po' confuso, giusto?
‫Quindi, di nuovo, qualunque cosa passiamo a questa funzione qui,
‫alla funzione di
‫risoluzione, è il risultato della
‫promessa che sarà disponibile nel gestore then.
‫Ora, d'altra parte,
‫possiamo anche contrassegnare la promessa come rifiutata nel caso
‫ci sia stato un errore, ok.
‫E lo facciamo
‫chiamando, come
‫puoi immaginare, la funzione di rifiuto.
‫Quindi, se c'è stato un errore
‫e questo è simile a quello che abbiamo fatto prima.
‫Quindi, se c'è stato un
‫errore qui, chiama la funzione di rifiuto.
‫E qualunque cosa passiamo a
‫questo sarà l'errore che
‫sarà successivamente disponibile nel metodo catch.
‫Quindi, in questo qui.
‫Va bene?
‫Quindi passiamo solo una stringa qui,
‫non sono riuscito a trovare quel file, qualche emoji qui forse
‫per farlo apparire un po' di più nella
‫nostra console. log, va bene?
‫E, ok.
‫In realtà è già così.
‫Quindi, rivediamo questo qui di nuovo.
‫Quindi abbiamo creato un
‫nuovo file, lì dentro passeremo il nome del file.
‫Quindi questo argomento.
‫E tutto ciò che facciamo qui è restituire questa promessa.
‫Questa promessa include una funzione di esecuzione, quindi
‫questa qui,
‫che è dove svolgiamo il nostro lavoro asincrono.
‫In tal caso qui ovviamente questo è il nostro
‫fs. file di lettura.
‫Quindi, se otteniamo i nostri dati in modo corretto,
‫chiamiamo la funzione di
‫risoluzione con il valore di risoluzione.
‫E se c'è
‫un errore chiamiamo la funzione di rifiuto, ok?
‫E quindi ora usiamolo in pratica.
‫Leggi file pro, passiamo il
‫nome del nostro file.
‫Quindi questo è ovviamente
‫e basta.
‫Quindi questo ora restituirà una promessa.
‫E così, proprio come
‫prima, possiamo usare il nostro metodo then su questo.
‫Ok, quindi questo argomento dei dati qui sarà esattamente ciò
‫che abbiamo restituito dalla promessa nel caso in
‫cui abbia avuto successo.
‫Quindi, con questa determinazione.
‫Quindi in questo momento la
‫nostra cartella del cane
‫qui contiene labrador e quindi questi dati qui saranno labrador.
‫E quindi questo è poi disponibile nel
‫nostro gestore di allora qui.
‫Ma ovviamente non ha bisogno di avere lo stesso
‫nome, potrei anche chiamarlo come risultato
‫o qualcosa che non importa, va bene?
‫Ok, ora prendiamo tutto questo e
‫mettiamolo qui.
‫Va bene.
‫Sbarazzati di tutto questo, salvalo e
‫questo lo eseguirà.
‫Ora riceviamo quell'errore qui, quindi i
‫dati non sono definiti.
‫Questo perché l'ho cambiato qui in un risultato.
‫Quindi torniamo indietro e cambiamolo in dati perché qui
‫abbiamo dati e qui
‫abbiamo dati
‫e quindi in questo modo non devo
‫andare avanti e cambiare tutti questi nomi di variabili.
‫Dagli un altro salvataggio
‫e ci siamo.
‫Quindi ha funzionato, vedi?
‫In realtà abbiamo ottenuto la
‫razza, che è
‫ancora labrador e questa volta dalla nostra promessa, ok.
‫Quindi, questo ha funzionato davvero.
‫Quindi la nostra funzione read file
‫pro ora restituisce
‫una promessa e quei dati qui sono quindi disponibili sul nostro gestore di allora.
‫Ottimo, quindi funziona già e
‫possiamo renderlo molto migliore
‫e
‫lo faremo, ma per ora voglio anche
‫promettere questa funzione di scrittura del file qui.
‫Quindi, in pratica, fai lo stesso
‫che abbiamo fatto con la funzione di lettura del file.
‫Ora, se conosci già un po'
‫di no js, forse stai pensando che in realtà esiste un
‫nodo funzione che promette automaticamente funzioni per noi.
‫Ma ovviamente volevo mostrarti qui come
‫funzionano effettivamente le promesse e
‫come le costruiamo
‫ed è per questo che sto facendo tutto questo qui, ok.
‫Quindi voglio davvero che tu impari a conoscere le promesse,
‫non solo come le consumiamo,
‫ma anche come costruirle.
‫Ed è per questo che lo sto facendo in questo modo.
‫Quindi, scrivi file e come promessa.
‫E questo in realtà non ha solo bisogno del nome
‫del file, ma anche dei dati che dovrebbero essere scritti su quel file.
‫Ma poi la logica qui è abbastanza simile.
‫Quindi, di nuovo, restituiamo una nuova promessa,
‫all'interno abbiamo la nostra funzione esecutrice
‫che accetta la risoluzione e il rifiuto come argomento.
‫E questi sono
‫nomi standard, quindi risolvi
‫e rifiuta, potresti chiamarli come volevi veramente,
‫ma questo è un po' lo standard, ok.
‫Quindi fs,
‫scrivi
‫file, passiamo il file,
‫i dati e poi la funzione di callback.
‫E ora qualcosa di molto simile a prima,
‫quindi se c'è
‫stato un errore, chiama la funzione di rifiuto
‫e passa lì un messaggio.
‫Impossibile scrivere il file,
‫di nuovo con questa emoji qui per farlo risaltare un
‫po' di più e nel caso in cui
‫tutto funzionasse bene, allora risolvi.
‫Ora non abbiamo nessun dato da passare qui, giusto?
‫Quindi passeremo in qualche stringa casuale
‫qualcosa come dire successo, ok.
‫Quindi una promessa
‫non deve sempre restituire un valore significativo.
‫In questo caso, tutto ciò che stiamo
‫veramente cercando di
‫fare qui è scrivere un file che non restituisce realmente un valore significativo.
‫Quindi ora siamo pronti per usare questa funzione promessa, ma
‫prima
‫di farlo, implementiamo effettivamente il concatenamento
‫di cui ti parlavo prima.
‫Quindi
‫in questo momento abbiamo ancora callback all'interno di
‫callback all'interno di callback, giusto?
‫Quindi abbiamo questo,
‫che ha questo callback.
‫E poi lì dentro c'è un altro gestore
‫che ha ancora un altro callback.
‫Quindi questo non cambia davvero nulla, vero?
‫Invece vogliamo concatenare questi gestori qui.
‫E il segreto per
‫farlo è far sì che ogni gestore restituisca una nuova promessa.
‫Allora come lo faremo?
‫Bene, ricorda che questa funzione qui restituisce una promessa.
‫E quindi tutto ciò che
‫dobbiamo fare è restituire quella promessa da questo prima e poi gestore.
‫Lascia che te lo mostri.
‫Quindi diciamo ritorno superagente. prendi e poi
‫la stringa e ora è una promessa, ok.
‫E poi chiudiamo effettivamente questa funzione di
‫callback qui e concateniamo questo metodo then direttamente su di esso.
‫Salvalo, ora abbiamo qualche errore qui e
‫questo è sulla riga 40.
‫Sbarazziamoci di questo qui e
‫va bene.
‫Ha cambiato di nuovo la formattazione qui
‫per noi che era
‫più carina e quindi in realtà lo abbiamo già fatto funzionare qui.
‫Allora perché funziona di nuovo?
‫Bene, ovviamente questa funzione che abbiamo
‫creato all'inizio restituisce una promessa.
‫Quindi su questo possiamo usare il metodo then.
‫Quindi facciamo in modo che questa funzione di callback che
‫è in essa restituisca nuovamente una promessa.
‫E così possiamo concatenare
‫il successivo e poi il gestore su quello.
‫Quindi questa variabile
‫di risultato qui sarà quindi il valore
‫risolto di questa promessa restituita dal gestore precedente, ok?
‫Ha senso?
‫Ora, per fare un ulteriore passo
‫avanti, andremo
‫avanti e utilizzeremo anche qui la nostra funzione di scrittura file pro.
‫E poiché vogliamo continuare a concatenare i metodi then,
‫lo restituiremo di nuovo in realtà.
‫Quindi ritorna, scrivi file pro pass nel nome
‫del file, che è questo, i
‫dati ...
‫Ed è proprio così.
‫Ok, quindi non abbiamo più bisogno di tutto questo
‫qui, commentiamolo per ora.
‫Sbarazzati di questo spazio
‫qui e poi là possiamo incatenare il successivo quindi gestore.
‫Allora, e ricorda che
‫qui dentro non avevamo alcun valore risolto significativo.
‫Quindi, non vogliamo alcun
‫argomento per questa funzione di callback
‫qui, tutto ciò che vogliamo fare è registrare questa stringa, giusto?
‫Quindi ora possiamo davvero liberarci di
‫questo e okay.
‫Quindi, quaggiù vediamo ora
‫che in realtà sta già funzionando.
‫E ancora il trucco per
‫essere in grado di concatenare tutti questi metodi qui
‫è restituire una promessa prima di chiamare ciascuno di essi.
‫Quindi questo qui ovviamente restituisce una promessa qui in modo
‫che possiamo concatenare il metodo then su di esso.
‫Quindi questo pezzo di codice
‫qui restituirà una
‫promessa e quindi possiamo usarlo su di esso.
‫Quindi questo pezzo di codice restituirà
‫una promessa e quindi possiamo usarlo di nuovo su di esso, ok?
‫Quindi questo è il segreto.
‫Salvalo di nuovo
‫e così quaggiù vediamo che la razza è ancora labrador.
‫Vediamo che questo è il collegamento, andiamo
‫qui e confermiamo che questo è
‫davvero uguale a questo.
‫E così ha scritto con successo la stringa nel file di
‫testo usando la nostra funzione di scrittura file promessa, ok.
‫E poi alla fine abbiamo questo gestore di errori.
‫E la bellezza qui è che per tutte queste catene e
‫poi gestori alla
‫fine, abbiamo semplicemente bisogno di un singolo gestore di cattura.
‫Quindi una funzione che
‫gestisce gli errori provenienti da una delle tre promesse, ok.
‫In realtà registriamo l'errore solo sulla console e
‫proviamo, ad esempio,
‫a modificare questo file qui.
‫In realtà non il
‫file, ma cambierò il nome del file qui, lo salverò
‫e ora vediamo che non sono riuscito a trovare quel file.
‫Quindi da dove viene?
‫Viene proprio qui
‫dalla chiamata alla funzione di rifiuto, ok?
‫Quindi abbiamo un errore qui perché non siamo riusciti a trovare il
‫file e quindi abbiamo chiamato la funzione di rifiuto.
‫E quella funzione di rifiuto segnerà quindi questa promessa qui, quindi ricorda
‫che questa è una promessa.
‫Lo contrassegnerà come rifiutato.
‫E quindi, viene chiamata la funzione catch.
‫E quindi registriamo quell'errore sulla console.
‫E il risultato è quello che puoi vedere quaggiù.
‫Ok, rimettiamolo a posto ora
‫funziona.
‫Ora entriamo nel file, creiamo
‫un cane che non esiste
‫e ora, oh, qui abbiamo questo grosso errore strano ed è perché
‫stiamo semplicemente registrando l'intero errore e non il messaggio
‫di errore come stavamo facendo prima ma non
‫non importa.
‫Ora salvalo qui ora, rimettilo
‫a posto
‫e va bene.
‫Quindi ora funziona tutto e
‫ci siamo sbarazzati di quella forma triangolare
‫che avevamo nel
‫nostro codice e ora abbiamo una cosiddetta struttura piatta delle promesse a catena.
‫Quindi di nuovo questo è molto
‫più facile da gestire e spero che tu possa
‫iniziare ad apprezzarlo ed è anche più
‫logico pensare e ragionare sul codice in questo modo.
‫Ora, nella
‫prossima lezione faremo un ulteriore passo avanti
‫e renderemo questo ancora più leggibile
‫e più facile da usare.
‫Quindi resta sintonizzato per questo.