By Leave a Comment on Come creare un modulo Node.js

L’autore ha selezionato l’Open Internet/Free Speech Fund per ricevere una donazione come parte del programma Write for DOnations.

Introduzione

In Node.js, un modulo è una collezione di funzioni e oggetti JavaScript che possono essere usati da applicazioni esterne. Descrivere un pezzo di codice come un modulo si riferisce meno a ciò che il codice è e più a ciò che fa – qualsiasi file o collezione di file Node.js può essere considerato un modulo se le sue funzioni e i suoi dati sono resi utilizzabili da programmi esterni.

Perché i moduli forniscono unità di funzionalità che possono essere riutilizzate in molti programmi più grandi, essi ti permettono di creare applicazioni liberamente accoppiate che scalano con la complessità, e ti aprono la porta per condividere il tuo codice con altri sviluppatori. Essere in grado di scrivere moduli che esportano funzioni e dati utili vi permetterà di contribuire alla più ampia comunità di Node.js – infatti, tutti i pacchetti che usate su npm sono stati impacchettati e condivisi come moduli. Questo rende la creazione di moduli un’abilità essenziale per uno sviluppatore Node.js.

In questo tutorial, creerai un modulo Node.js che suggerisce quale colore gli sviluppatori web dovrebbero usare nei loro progetti. Svilupperai il modulo memorizzando i colori come un array e fornendo una funzione per recuperarne uno in modo casuale. In seguito, si analizzeranno i vari modi di importare un modulo in un’applicazione Node.js.

Prequisiti

  • Avrai bisogno di Node.js e npm installati nel tuo ambiente di sviluppo. Questo tutorial usa la versione 10.17.0. Per installarlo su macOS o Ubuntu 18.04, segui i passi in Come installare Node.js e creare un ambiente di sviluppo locale su macOS o la sezione Installare usando un PPA di Come installare Node.js su Ubuntu 18.04. Avendo installato Node.js avrai anche installato npm; questo tutorial usa la versione 6.11.3.
  • Dovresti anche avere familiarità con il file package.json, e sarebbe utile anche l’esperienza con i comandi npm. Per acquisire questa esperienza, segui Come usare i moduli Node.js con npm e package.json, in particolare il Passo 1 – Creare un file package.json.
  • Sarà utile anche essere a proprio agio con il Node.js REPL (Read-Evaluate-Print-Loop). Lo userete per testare il vostro modulo. Se hai bisogno di maggiori informazioni su questo, leggi la nostra guida su Come usare il Node.js REPL.

Step 1 – Creare un modulo

Questo passo ti guiderà nella creazione del tuo primo modulo Node.js. Il tuo modulo conterrà una collezione di colori in un array e fornirà una funzione per ottenerne uno a caso. Userai la proprietà exports incorporata in Node.js per rendere la funzione e l’array disponibili a programmi esterni.

Primo, inizierai a decidere quali dati sui colori memorizzerai nel tuo modulo. Ogni colore sarà un oggetto che contiene una proprietà name che gli umani possono facilmente identificare, e una proprietà code che è una stringa contenente un codice colore HTML. I codici colore HTML sono numeri esadecimali a sei cifre che ti permettono di cambiare il colore degli elementi in una pagina web. Puoi imparare di più sui codici colore HTML leggendo questo articolo HTML Color Codes and Names.

Poi deciderai quali colori vuoi supportare nel tuo modulo. Il tuo modulo conterrà un array chiamato allColors che conterrà sei colori. Il tuo modulo includerà anche una funzione chiamata getRandomColor() che selezionerà casualmente un colore dal tuo array e lo restituirà.

Nel tuo terminale, crea una nuova cartella chiamata colors e spostati in essa:

     
  • mkdir colors
    •  
  • cd colors
    •

Inizializza npm in modo che altri programmi possano importare questo modulo più avanti nel tutorial:

  • npm init -y

Hai usato il flag -y per saltare le solite richieste di personalizzare il tuo package.json. Se questo fosse un modulo che vuoi pubblicare su npm, dovresti rispondere a tutte queste richieste con dati rilevanti, come spiegato in Come usare i moduli Node.js con npm e package.json.

In questo caso, il tuo output sarà:

Output
{ "name": "colors", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": , "author": "", "license": "ISC"}

Ora, apri un editor di testo a riga di comando come nano e crea un nuovo file che serva come punto di ingresso per il tuo modulo:

  • nano index.js

Il tuo modulo farà alcune cose. Per prima cosa, definirete una classe Color. La tua classe Color sarà istanziata con il suo nome e il suo codice HTML. Aggiungi le seguenti linee per creare la classe:

~/colors/index.js
class Color { constructor(name, code) { this.name = name; this.code = code; }}

Ora che hai la tua struttura dati per Color, aggiungi alcune istanze nel tuo modulo. Scrivi il seguente array evidenziato nel tuo file:

~/colors/index.js
class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;

Infine, inserisci una funzione che selezioni casualmente un elemento dall’array allColors che hai appena creato:

~/colors/index.js
class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;exports.getRandomColor = () => { return allColors;}exports.allColors = allColors;

La parola chiave exports fa riferimento a un oggetto globale disponibile in ogni modulo Node.js. Tutte le funzioni e gli oggetti memorizzati nell’oggetto exports di un modulo sono esposti quando altri moduli Node.js lo importano. La funzione getRandomColor() è stata creata direttamente sull’oggetto exports, per esempio. Hai poi aggiunto una proprietà allColors all’oggetto exports che fa riferimento all’array di costanti locali allColors creato in precedenza nello script.

Quando altri moduli importano questo modulo, sia allColors che getRandomColor() saranno esposti e disponibili all’uso.

Salva e chiudi il file.

Finora hai creato un modulo che contiene un array di colori e una funzione che ne restituisce uno in modo casuale. Avete anche esportato l’array e la funzione, in modo che programmi esterni possano usarli. Nel prossimo passo, userete il vostro modulo in altre applicazioni per dimostrare gli effetti di export.

Passo 2 – Testare il tuo modulo con il REPL

Prima di costruire un’applicazione completa, prenditi un momento per confermare che il tuo modulo funziona. In questo passo, userai il REPL per caricare il modulo colors. Mentre siete nel REPL, chiamerete la funzione getRandomColor() per vedere se si comporta come vi aspettate.

Avvia il Node.js REPL nella stessa cartella del file index.js:

  • node

Quando il REPL è partito, vedrai il prompt >. Questo significa che potete inserire del codice JavaScript che verrà immediatamente valutato. Se vuoi saperne di più, segui la nostra guida sull’uso del REPL.

Prima, inserisci quanto segue:

  • colors = require('./index');

In questo comando, require() carica il modulo colors al suo punto di ingresso. Quando premete ENTER otterrete:

Output
{ getRandomColor: , allColors: }

Il REPL ci mostra il valore di colors, che sono tutte le funzioni e gli oggetti importati dal file index.js. Quando usi la parola chiave require, Node.js restituisce tutti i contenuti all’interno dell’oggetto exports di un modulo.

Ricorda che hai aggiunto getRandomColor() e allColors a exports nel modulo colors. Per questo motivo, li vedete entrambi nel REPL quando vengono importati.

Al prompt, testate la funzione getRandomColor():

  • colors.getRandomColor();

Vi verrà richiesto un colore casuale:

Output
Color { name: 'groovygray', code: '#D7DBDD' }

Poiché l’indice è casuale, il vostro risultato può variare. Ora che avete confermato che il modulo colors funziona, uscite dal Node.js REPL:

  • .exit

Questo vi riporterà alla vostra linea di comando terminale.

Avete appena confermato che il vostro modulo funziona come previsto usando il REPL. In seguito, applicherete questi stessi concetti e caricherete il vostro modulo in un’applicazione, come fareste in un progetto reale.

Step 3 – Salvare il vostro modulo locale come dipendenza

Nel testare il vostro modulo nel REPL, lo avete importato con un percorso relativo. Questo significa che hai usato la posizione del file index.jsin relazione alla directory di lavoro per ottenere il suo contenuto. Anche se questo funziona, di solito è un’esperienza di programmazione migliore importare i moduli con i loro nomi in modo che l’importazione non venga interrotta quando il contesto viene cambiato. In questo passo, installerete il modulo colors con la funzione local module install di npm.

Imposta un nuovo modulo Node.js fuori dalla cartella colors. Per prima cosa, vai nella directory precedente e crea una nuova cartella:

     
  • cd ..
    •  
  • mkdir really-large-application
    •

Ora spostati nel tuo nuovo progetto:

  • cd really-large-application

Come per il modulo colors, inizializza la tua cartella con npm:

  • npm init -y

Sarà generato il seguente package.json:

Output
{ "name": "really-large-application", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": , "author": "", "license": "ISC"}

Ora, installa il tuo modulo colors e usa il flag --save così sarà registrato nel tuo file package.json:

  • npm install --save ../colors

Hai appena installato il tuo modulo colors nel nuovo progetto. Apri il file package.json per vedere la nuova dipendenza locale:

  • nano package.json

Troverai che sono state aggiunte le seguenti linee evidenziate:

~/really-large-application/package.json
{ "name": "really-large-application", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": , "author": "", "license": "ISC", "dependencies": { "colors": "file:../colors" }}

Esci dal file.

Il modulo colors è stato copiato nella tua directory node_modules. Verifica che sia lì con il seguente comando:

  • ls node_modules

Questo darà il seguente output:

Output
colors

Usa il tuo modulo locale installato in questo nuovo programma. Riapri il tuo editor di testo e crea un altro file JavaScript:

  • nano index.js

Il tuo programma importerà prima il modulo colors. Poi sceglierà un colore a caso usando la funzione getRandomColor() fornita dal modulo. Infine, stamperà un messaggio alla console che dice all’utente quale colore usare.

Inserisci il seguente codice in index.js:

~/really-large-application/index.js
const colors = require('colors');const chosenColor = colors.getRandomColor();console.log(`You should use ${chosenColor.name} on your website. It's HTML code is ${chosenColor.code}`);

Salva e chiudi questo file.

La vostra applicazione ora comunicherà all’utente un’opzione di colore casuale per un componente del sito web.

Eseguite questo script con:

  • node index.js

Il vostro output sarà simile a:

Output
You should use leafygreen on your website. It's HTML code is #48C9B0

Ora avete installato con successo il modulo colors e potete gestirlo come qualsiasi altro pacchetto npm usato nel vostro progetto. Tuttavia, se avete aggiunto più colori e funzioni al vostro modulo locale colors, dovrete eseguire npm update nelle vostre applicazioni per poter utilizzare le nuove opzioni. Nel prossimo passo, userai il modulo locale colors in un altro modo e otterrai aggiornamenti automatici quando il codice del modulo cambia.

Passo 4 – Collegare un modulo locale

Se il tuo modulo locale è in forte sviluppo, aggiornare continuamente i pacchetti può essere noioso. Un’alternativa sarebbe quella di collegare i moduli. Collegare un modulo assicura che qualsiasi aggiornamento del modulo si rifletta immediatamente nelle applicazioni che lo utilizzano.

In questo passo, collegherai il modulo colors alla tua applicazione. Modificherai anche il modulo colors e confermerai che i suoi cambiamenti più recenti funzionano nell’applicazione senza dover reinstallare o aggiornare.

Prima di tutto, disinstalla il tuo modulo locale:

  • npm un colors

npm collega i moduli usando collegamenti simbolici (o symlink), che sono riferimenti che puntano a file o directory nel tuo computer. Il collegamento di un modulo avviene in due passi:

  1. Creazione di un collegamento globale al modulo. npm crea un collegamento simbolico tra la vostra directory globale node_modules e la directory del vostro modulo. La directory globale node_modules è la posizione in cui sono installati tutti i tuoi pacchetti npm a livello di sistema (qualsiasi pacchetto che installi con il flag -g).
  2. Creare un link locale. npm crea un symlink tra il tuo progetto locale che sta usando il modulo e il link globale del modulo.

Prima di tutto, crea il link globale tornando alla cartella colors e usando il comando link:

     
  • cd ../colors
    •  
  • sudo npm link
    •

Una volta completato, la tua shell mostrerà:

Output
/usr/local/lib/node_modules/colors -> /home/sammy/colors

Hai appena creato un link simbolico nella tua cartella node_modules alla tua cartella colors.

Ritornate alla cartella really-large-application e collegate il pacchetto:

     
  • cd ../really-large-application
    •  
  • sudo npm link colors
    •

Voi riceverete un output simile al seguente:

Output
/home/sammy/really-large-application/node_modules/colors -> /usr/local/lib/node_modules/colors -> /home/sammy/colors

Nota: Se volete digitare un po’ meno, potete usare ln invece di link. Per esempio, npm ln colors avrebbe funzionato esattamente allo stesso modo.

Come mostra l’output, hai appena creato un link simbolico dalla directory locale node_modules del tuo really-large-application al link simbolico colors nel tuo node_modules globale, che punta alla directory reale con il modulo colors.

Il processo di collegamento è completo. Esegui il tuo file per assicurarti che funzioni ancora:

  • node index.js

Il tuo output sarà simile a:

Output
You should use sunkissedyellow on your website. It's HTML code is #F4D03F

La funzionalità del tuo programma è intatta. Successivamente, verificate che gli aggiornamenti vengano applicati immediatamente. Nel tuo editor di testo, riapri il file index.js nel modulo colors:

     
  • cd ../colors
    •  
  • nano index.js
    •

Ora aggiungi una funzione che selezioni la migliore tonalità di blu esistente. Non prende argomenti e restituisce sempre il terzo elemento dell’array allColors. Aggiungi queste righe alla fine del file:

~/colors/index.js
class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;exports.getRandomColor = () => { return allColors; }exports.allColors = allColors;exports.getBlue = () => { return allColors;}

Salva ed esci dal file, poi riapri il file index.js nella cartella really-large-application:

     
  • cd ../really-large-application
    •  
  • nano index.js
    •

Fai una chiamata alla funzione getBlue() appena creata, e stampa una frase con le proprietà del colore. Aggiungete queste dichiarazioni alla fine del file:

~/really-large-application/index.js
const colors = require('colors');const chosenColor = colors.getRandomColor();console.log(`You should use ${chosenColor.name} on your website. It's HTML code is ${chosenColor.code}`);const favoriteColor = colors.getBlue();console.log(`My favorite color is ${favoriteColor.name}/${favoriteColor.code}, btw`);

Salvate ed uscite dal file.

Il codice ora usa la funzione getBlue() appena creata. Eseguite il file come prima:

  • node index.js

Avrete un output come:

Output
You should use brightred on your website. It's HTML code is #E74C3CMy favorite color is skyblue/#5DADE2, btw

Il vostro script è stato in grado di usare l’ultima funzione nel vostro modulo colors, senza dover eseguire npm update. Questo renderà più facile fare cambiamenti a questa applicazione durante lo sviluppo.

Quando scrivi applicazioni più grandi e complesse, pensa a come il codice correlato può essere raggruppato in moduli, e come vuoi che questi moduli siano impostati. Se il vostro modulo sarà usato solo da un programma, può rimanere all’interno dello stesso progetto ed essere referenziato da un percorso relativo. Se il vostro modulo sarà in seguito condiviso separatamente o esiste in una posizione molto diversa dal progetto su cui state lavorando ora, l’installazione o il collegamento potrebbe essere più conveniente. I moduli in sviluppo attivo beneficiano anche degli aggiornamenti automatici del collegamento. Se il modulo non è in sviluppo attivo, usare npm install potrebbe essere l’opzione più facile.

Conclusione

In questo tutorial, hai imparato che un modulo Node.js è un file JavaScript con funzioni e oggetti che possono essere usati da altri programmi. Hai poi creato un modulo e collegato le tue funzioni e i tuoi oggetti all’oggetto globale exports per renderli disponibili ai programmi esterni. Infine, avete importato quel modulo in un programma, dimostrando come i moduli si uniscono in applicazioni più grandi.

Ora che sapete come creare moduli, pensate al tipo di programma che volete scrivere e dividetelo in vari componenti, mantenendo ogni set unico di attività e dati nei propri moduli. Più fai pratica scrivendo moduli, migliore sarà la tua capacità di scrivere programmi Node.js di qualità nel tuo viaggio di apprendimento. Per lavorare su un esempio di un’applicazione Node.js che usa moduli, vedi il nostro tutorial Come impostare un’applicazione Node.js per la produzione su Ubuntu 18.04.

.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.