‫Jonas: In questa lezione voglio
‫mostrarti un paio di cose diverse che coinvolgono i moduli.
‫E voglio iniziare dimostrandoti sostanzialmente che Node in
‫effetti avvolge il codice nei nostri moduli in una
‫funzione wrapper, come
‫ti ho mostrato nell'ultima lezione.
‫Quindi creiamo di nuovo un nuovo file, module. js, e questi
‫sono i moduli, come questo.
‫Ok, e quello
‫che farò qui è registrare gli argomenti sulla console, ok?
‫Quindi gli argomenti sono un array in JavaScript e questo
‫array contiene tutti i valori
‫che sono stati passati a una funzione.
‫Quindi, quando registro questo array di argomenti sulla
‫console, se effettivamente vediamo alcuni valori
‫lì, beh, allora significa che siamo davvero in una funzione, ok?
‫Quindi eseguiamo i moduli.
‫E infatti, qui abbiamo il codice nei nostri argomenti.
‫E quindi ricordiamo i cinque argomenti
‫della funzione wrapper.
‫Il primo è l'esportazione, quindi questo, che al
‫momento è
‫vuoto perché non esportiamo nulla.
‫La seconda è la funzione require, quindi
‫possiamo vedere
‫che qui abbiamo effettivamente la funzione require.
‫Quindi il terzo si chiama modulo, ok.
‫E nel modulo abbiamo poi le esportazioni del modulo,
‫di cui abbiamo parlato nell'ultima lezione.
‫E quello che abbiamo qui non è così importante, di
‫nuovo, volevo solo
‫mostrarti che siamo effettivamente in una funzione in questo
‫momento, quindi tutto questo codice che abbiamo
‫in questo modulo è davvero racchiuso in questa funzione wrapper, ok ?
‫Quindi il numero tre e il numero quattro sono il nome del
‫file e il nome della directory.
‫E infatti, questo è il nome del modulo in cui ci troviamo
‫attualmente, quindi moduli. js.
‫E poi qui abbiamo il nome della directory.
‫Quindi sono sul
‫mio desktop, e poi in questa cartella Node funziona.
‫Così simile a questo
‫qui, ma poi questo ha barrato il nome del modulo, ok?
‫Quindi questo ci dimostra che,
‫in effetti, tutto il codice all'interno di
‫un modulo è avvolto e che abbiamo accesso a tutte
‫queste variabili, quindi questi argomenti, ok?
‫Quindi trovo che questo sia un esperimento interessante
‫che possiamo fare.
‫E possiamo effettivamente fare un'altra cosa interessante.
‫Quindi, per mostrarti effettivamente
‫la funzione wrapper, possiamo richiedere il modulo module, ok.
‫Quindi c'è un modulo chiamato
‫module, che in realtà non abbiamo mai usato ma internamente Node lo usa.
‫E lì dentro abbiamo l'involucro.
‫E quindi questa è in realtà questa proprietà
‫è in realtà la funzione wrapper.
‫Quindi ora possiamo dare un'occhiata a questo.
‫E dov'è quello, ah, sì.
‫Quindi ecco, eccolo in realtà.
‫Quindi questa è la funzione wrapper.
‫E così effettivamente vedi export, require,
‫module, filename e directory name, e poi il
‫corpo della funzione.
‫E quindi questo è ciò che
‫Node usa internamente, quindi fondamentalmente questo modello qui, lo
‫usa e poi riempie il corpo di questa funzione con il nostro codice.
‫Ok, di nuovo, solo un esperimento interessante qui.
‫Ora la cosa più importante
‫che voglio mostrarti qui è come possiamo esportare
‫e importare dati da un modulo all'altro.
‫E quindi iniziamo creando un nuovo modulo qui,
‫in cui creerò una calcolatrice,
‫un po' come ho detto nell'ultimo video.
‫Quindi chiamiamo questo modulo di test-1, perché ne
‫avremo un paio.
‫E qui creerò una classe calcolatrice.
‫Quindi, di nuovo, questa è la
‫sintassi ES6 per scrivere classi in JavaScript.
‫Quindi aggiungiamo un paio di metodi qui, quindi
‫aggiungi a e b, ovviamente restituirà a
‫più b, quindi cose molto semplici, moltiplica a, b, restituirà
‫a per b, e poi solo,
‫dividiamo anche
‫noi, solo per completezza qui, a, b, così.
‫Dagli un salvataggio, lo formatta bene e
‫ora possiamo fare il modulo. esportazioni, proprio come abbiamo appreso
‫nell'ultimo video e
‫stiamo esportando la nostra calcolatrice, ok?
‫Quindi, di nuovo, usiamo module. exports
‫quando vogliamo esportare un singolo valore.
‫E in questo caso il nostro
‫unico valore qui è la classe calcolatrice.
‫Quindi modulo. exports è esattamente ciò
‫che viene restituito da un modulo, quindi qualunque
‫cosa mettiamo lì, beh, viene esportata automaticamente, giusto?
‫Possiamo quindi salvare il valore
‫esportato in una variabile durante l'importazione, quindi facciamolo ora.
‫E ora qui possiamo effettivamente dargli il nome che vogliamo.
‫Quindi il nome che stiamo esportando dall'altra parte, quindi in questo
‫altro modulo, non ha importanza.
‫Possiamo chiamarlo come vogliamo qui.
‫Quindi in questo senso è proprio come un normale ritorno
‫di una funzione, giusto, quindi possiamo sempre
‫restituire qualsiasi variabile, ma poi chiamarla
‫qualcos'altro quando fondamentalmente salviamo il risultato di una funzione in
‫una variabile, giusto?
‫Quindi, dal momento che
‫è il nostro modulo, dobbiamo usare il punto barra, quindi quello che
‫ho fatto qui, e poi test-module-1.
‫E il JS, ricorda, possiamo semplicemente lasciar perdere,
‫non è necessario, ok?
‫E quindi questa variabile C qui, che è maiuscola
‫perché per la classe di solito usiamo sempre nomi in maiuscolo.
‫E ricorda, stiamo effettivamente esportando una classe qui.
‫Ok, ora possiamo usare quella classe per fare alcuni calcoli.
‫Quindi prima di tutto creiamo una
‫nuova calcolatrice, calcolatrice una, perché più
‫avanti ne avremo un'altra, ok?
‫E così ora creiamo una nuova istanza di una calcolatrice come
‫questa, e questa non dovrebbe
‫essere una novità per te a questo punto.
‫E poi registriamo attraverso la console il
‫risultato dell'utilizzo effettivo di questo.
‫Quindi calcola1. aggiungiamo e diciamo due più cinque.
‫Dagli un salvataggio e in realtà commentiamo questi due.
‫Salvalo di nuovo, quindi Moduli nodo e qui
‫abbiamo il risultato, sette.
‫Quindi fa due più cinque, quindi funziona, giusto?
‫E qui nel nostro modulo
‫di test, potremmo effettivamente farlo in un modo più elegante.
‫Quindi potremmo assegnare questa classe qui
‫direttamente a module. esportazioni, giusto?
‫Quindi in questo momento abbiamo una dichiarazione di classe,
‫quindi è un po' come
‫una dichiarazione di funzione, dove diciamo calcolatrice di funzioni, e
‫poi questo, e qui diciamo classe, ok?
‫Ma potremmo farlo anche con un'espressione di classe.
‫E così in questo modo semplicemente non usiamo comunque
‫il nome della calcolatrice.
‫Quindi copialo, commentalo.
‫Ok, quindi proprio così.
‫Quindi diciamo solo che questa è
‫una classe e poi la assegniamo a una variabile.
‫E quindi questa è ora un'espressione.
‫Quindi eseguiamo di nuovo
‫questo, e ovviamente vediamo di nuovo i nostri sette, ok?
‫Quindi, di nuovo, questo è solo per assegnare immediatamente il valore
‫che vogliamo modulo. exports, e questo
‫ci farà risparmiare alcune righe di codice
‫e probabilmente migliorerà un po' il nostro codice.
‫Ok, è così che esportiamo le cose con module. exports, e ora vediamo
‫come e quando possiamo usare la stenografia export
‫di cui ho parlato anche nel
‫video precedente.
‫Quindi creiamo un semplice commento qui, module. esportazioni.
‫Quindi qui solo esportazioni.
‫Quindi un nuovo modulo di test e ancora modulo-2. js.
‫E così l'alternativa per fare module. exports consiste
‫nell'aggiungere proprietà all'oggetto export stesso.
‫Quindi potremmo farlo in
‫questo modo, e usando di nuovo l'esempio della calcolatrice di
‫prima, potremmo farlo in questo modo.
‫Quindi possiamo semplicemente aggiungere proprietà all'oggetto export.
‫Quindi a e b restituiranno a
‫più b, esportazioni. moltiplicare a, b restituirà a
‫per b,
‫e ora duplichiamo di nuovo solo per completezza, e va bene.
‫Quindi abbiamo creato fondamentalmente tre funzioni anonime
‫qui, queste tre, e
‫le abbiamo assegnate a tre proprietà delle esportazioni.
‫E così ora quando esportiamo questo modulo dall'altra
‫parte, quindi in moduli. js, avremo sostanzialmente
‫accesso a questo oggetto di esportazione.
‫Quindi lascia che te lo mostri.
‫Quindi diciamo che const calc2 è richiesto.
‫Ancora una volta, non dimenticare il punto e la barra,
‫perché è il nostro modulo.
‫Ok, quindi ora questo calc2 qui è l'oggetto export.
‫Ok, allora lascia che te lo mostri.
‫Consolle. log, cal2. aggiungere, due e cinque.
‫Quindi questo dovrebbe darci lo stesso identico risultato di prima.
‫E infatti, ecco i nostri sette, proprio come prima.
‫E se
‫moltiplichiamo, beh, allora dovrebbe essere ovviamente 10.
‫E quindi sì, abbiamo sette qui dall'addizione qui, e
‫poi questa moltiplicazione ci dà 10.
‫Quindi spero che questo faccia davvero la
‫differenza tra i moduli. esportazioni ed esportazioni chiare.
‫E così di nuovo, quando usiamo semplicemente
‫le esportazioni, possiamo aggiungere cose a questo oggetto, quindi fondamentalmente proprietà,
‫e poi quando lo importiamo,
‫quindi quando abbiamo bisogno di questo modulo,
‫il risultato che
‫otterremo è un oggetto contenente tutte queste proprietà.
‫E dal momento che stiamo
‫ottenendo un oggetto, possiamo usare il potere della destrutturazione di
‫ES6 per fare delle magie fantastiche qui, in pratica.
‫Quindi lasciami liberare di questo, o
‫effettivamente duplicarlo, commentare questo, e così possiamo usare
‫la destrutturazione per destrutturare l'oggetto che otteniamo, ok?
‫E funziona così, quindi usiamo le parentesi graffe e
‫poi creiamo semplicemente nomi
‫di variabili per le proprietà in quell'oggetto.
‫Quindi, ancora una volta, usiamo somma, moltiplicazione e divisione.
‫Quindi questi sono i nomi che abbiamo effettivamente su
‫questo oggetto di esportazione.
‫Quindi aggiungi, moltiplica e
‫dividi, e questi devono essere esattamente
‫lo stesso nome dell'oggetto originale, ok?
‫Ora la cosa che
‫farà è che fondamentalmente creerà una variabile
‫chiamata semplicemente moltiplicare.
‫E così infatti, ecco il nostro risultato.
‫E in realtà possiamo importare solo quelli che vogliamo.
‫Quindi diciamo che vogliamo solo aggiungere e moltiplicare, ok?
‫E così avremo accesso solo a
‫questi due, invece di importare tutto dal modulo.
‫E questo è uno schema
‫abbastanza comune che vedrai usato in
‫Node, e lo faremo anche durante il progetto.
‫Ok, in questo
‫video abbiamo parlato della funzione wrapper
‫qui, quindi abbiamo parlato dell'esportazione
‫e dell'importazione utilizzando il modulo. esportazioni e la stenografia delle esportazioni.
‫E ora finalmente, solo per
‫finire, parliamo della memorizzazione nella cache molto rapidamente.
‫Ok, quindi creiamo il modulo di test-3 qui.
‫E quello che farò qui è creare una console. log, quindi fondamentalmente del
‫codice di primo livello all'interno di questo modulo.
‫Ciao dal modulo, ok, e poi
‫voglio anche esportare una funzione.
‫Solo una singola funzione, quindi dico modulo. exports equals
‫function senza alcun argomento, uno che si
‫registrerà semplicemente nella
‫console: registra questo bellissimo testo.
‫Solo qualche piccola emoji qui per farla risaltare un po'.
‫Ok, ora richiediamo questo modulo di prova.
‫Test-module-3 e non lo sto salvando su nessuna variabile.
‫Invece chiamerò subito la funzione senza
‫salvarla in una variabile.
‫Quindi potremmo ovviamente farlo, quindi
‫avremmo la funzione in una variabile e
‫potremmo quindi chiamarla.
‫Ma questa è esattamente
‫la stessa cosa, perché questo restituirà questa funzione che
‫abbiamo definito, quindi questa qui, giusto?
‫Restituirà questo perché stiamo usando module. exports, e
‫poi chiamiamo subito questa funzione qui, ok?
‫E quindi in realtà facciamolo tre volte.
‫E tenendo presente che abbiamo la memorizzazione nella cache in Node. js, cosa pensi
‫che accadrà quando eseguiremo questo codice?
‫Ok, allora eseguiamo questo e vediamo cosa succederà.
‫Qui abbiamo il risultato, ciao dal
‫modulo, e poi registriamo tre volte questo bellissimo testo.
‫Quindi abbiamo questa registrazione qui tre volte, beh, perché
‫abbiamo chiamato la stessa funzione tre volte.
‫Ma abbiamo ricevuto il saluto dal modulo solo una volta, ok?
‫E questo a causa della memorizzazione nella cache.
‫Quindi tecnicamente questo modulo è stato caricato solo una volta,
‫quindi anche il codice al suo interno è stato eseguito una sola volta.
‫Ed ecco perché questa riga di codice
‫qui, questa registrazione è stata eseguita solo una volta, ok?
‫E quindi questi altri due log qui, beh, provengono
‫dalla cache, quindi sono stati memorizzati da qualche parte nella
‫cache dei processi del nodo.
‫E una volta che abbiamo chiamato la funzione qui per
‫la seconda volta, è stata semplicemente
‫recuperata da lì, invece di caricare di nuovo il modulo, ok?
‫Quindi sono sicuro che ha molto senso per te.
‫E così quella era la nostra lezione, in realtà.
‫Se hai domande, puoi ovviamente, come
‫sempre, pubblicarle nella sezione Domande e risposte e lì riceverai aiuto.
‫Così finisce questa intera sezione.
‫So che è stata una bella corsa fino a quando non siamo arrivati a questo punto,
‫quindi un sacco di cose da prendere in considerazione.
‫E se hai corretto tutto al
‫100%, non preoccuparti troppo, perché
‫durante il
‫corso, la maggior parte delle cose alla fine diventerà chiara, ok?
‫Quindi non preoccuparti, continua ad andare avanti nel corso
‫e ci vediamo nella prossima sezione.