Nella programmazione, i moduli sono unità autonome di funzionalità che possono essere condivise e riutilizzate tra i progetti. Rendono la nostra vita come sviluppatori più facile, in quanto possiamo usarli per aumentare le nostre applicazioni con funzionalità che non abbiamo dovuto scrivere noi stessi. Ci permettono anche di organizzare e disaccoppiare il nostro codice, portando ad applicazioni che sono più facili da capire, eseguire il debug e mantenere.

In questo articolo, esaminerò come lavorare con i moduli nel nodo.js, concentrandosi su come esportarli e consumarli.,

Diversi formati di moduli

Poiché JavaScript originariamente non aveva il concetto di moduli, nel tempo sono emersi una varietà di formati concorrenti. Ecco un elenco dei principali di cui essere a conoscenza:

• Il formato AMD (Asynchronous Module Definition) viene utilizzato nei browser e utilizza una funzionedefine per definire i moduli.
• Il formato CommonJS (CJS) viene utilizzato nel nodo.js e utilizza requireemodule.exports per definire dipendenze e moduli. L’ecosistema npm è costruito su questo formato.
• Il formato del modulo ES (ESM)., A partire da ES6 (ES2015), JavaScript supporta un formato modulo nativo. Utilizza una parola chiave export per esportare l’API pubblica di un modulo e una parola chiave import per importarla.
• Il sistema.register format è stato progettato per supportare i moduli ES6 all’interno di ES5.
• Il formato UMD (Universal Module Definition) può essere utilizzato sia nel browser che nel Nodo.js. È utile quando un modulo deve essere importato da un numero di diversi caricatori di moduli.

Tieni presente che questo articolo riguarda esclusivamente il formato CommonJS, lo standard in Node.js., Se vuoi leggere in uno qualsiasi degli altri formati, vi consiglio questo articolo, da SitePoint autore Jurgen Van de Moere.

Che richiede un modulo

Nodo.js viene fornito con un set di moduli integrati che possiamo utilizzare nel nostro codice senza doverli installare. Per fare ciò, dobbiamo richiedere il modulo utilizzando la parola chiave require e assegnare il risultato a una variabile. Questo può quindi essere usato per richiamare qualsiasi metodo esposto dal modulo.,

Ad esempio, per elencare il contenuto di una directory, è possibile utilizzare il modulo del file system e il suo metodoreaddir:

Si noti che in CommonJS, i moduli vengono caricati in modo sincrono ed elaborati nell’ordine in cui si verificano.

Creazione ed esportazione di un modulo

Ora diamo un’occhiata a come creare il nostro modulo ed esportarlo per l’uso altrove nel nostro programma., Iniziare con la creazione di un user.js file e aggiunta la seguente:

const getName = () => { return 'Jim';};exports.getName = getName;

creare un index.js file nella stessa cartella e aggiungere questo:

const user = require('./user');console.log(`User: ${user.getName()}`);

Eseguire il programma utilizzando node index.js e si dovrebbe vedere il seguente output del terminale:

User: Jim

cosa è successo qui?, Bene, se guardi il fileuser.js, noterai che stiamo definendo una funzionegetName, quindi usando la parola chiaveexports per renderla disponibile per l’importazione altrove. Quindi nel fileindex.js, stiamo importando questa funzione ed eseguendola. Si noti inoltre che nell’istruzionerequire, il nome del modulo è preceduto da./, poiché si tratta di un file locale. Si noti inoltre che non è necessario aggiungere l’estensione del file.,

Esportazione di Più i Metodi e i Valori

E ‘ possibile esportare più metodi e valori nello stesso modo:

E nel index.js:

const user = require('./user');console.log( `${user.getName()} lives in ${user.getLocation()} and was born on ${user.dob}.`);

Il codice di cui sopra produce questo:

Jim lives in Munich and was born on 12.01.1982.

da Notare come il nome che vogliamo dare esportato dateOfBirth variabile può essere qualsiasi cosa abbiamo di fantasia (dob in questo caso). Non deve essere uguale al nome della variabile originale.,

Variazioni nella sintassi

Dovrei anche menzionare che è possibile esportare metodi e valori mentre si va, non solo alla fine del file.

Per esempio:

exports.getName = () => { return 'Jim';};exports.getLocation = () => { return 'Munich';};exports.dob = '12.01.1982';

E grazie per la destrutturazione di assegnazione, siamo in grado di ciliegio scegliere ciò che si desidera importare:

const { getName, dob } = require('./user');console.log( `${getName()} was born on ${dob}.`);

Come ci si potrebbe aspettare, questo log:

Jim was born on 12.01.1982.

l’Esportazione di un Valore Predefinito

Nell’esempio di cui sopra, siamo le funzioni di esportazione e i singoli valori., Questo è utile per le funzioni di supporto che potrebbe essere necessario in tutto una app, ma quando si ha un modulo che esporta solo una cosa, è più comune l’uso di module.exports:

E nel index.js:

const User = require('./user');const jim = new User('Jim', 37, '[email protected]');console.log(jim.getUserStats());

Il codice di cui sopra registri di questo:

Name: JimAge: 37Email: [email protected]

Qual è la Differenza Tra i moduli.esportazioni ed esportazioni?,

In viaggio attraverso il Web, si potrebbe venire attraverso la seguente sintassi:

module.exports = { getName: () => { return 'Jim'; }, getLocation: () => { return 'Munich'; }, dob: '12.01.1982',};

Qui si sta assegnando le funzioni e i valori che si desidera esportare in un exports proprietà module — e, naturalmente, questo funziona bene:

const { getName, dob } = require('./user');console.log( `${getName()} was born on ${dob}.`);

Questo registra il seguente:

Jim was born on 12.01.1982.

allora, qual è la differenza tra module.exports e exports? Uno è solo un alias utile per l’altro?,

Bene, un pò, ma non del tutto …

Per illustrare quello che voglio dire, andiamo a modificare il codice index.js per memorizzare il valore di module:

console.log(module);

Questo produce:

Come si può vedere, module è un exports proprietà. Aggiungiamo qualcosa:

// index.jsexports.foo = 'foo';console.log(module);

Questo output:

Module { id: '.', exports: { foo: 'foo' }, ...

Assegnazione di proprietà a exportsle aggiunge anche a module.exports., Questo perché (inizialmente, almeno)exports è un riferimento amodule.exports.

Quindi quale dovrei usare?

Asmodule.exports eexports puntano entrambi allo stesso oggetto, normalmente non importa quale si usa. Ad esempio:

exports.foo = 'foo';module.exports.bar = 'bar';

Questo codice risulterebbe nell’oggetto esportato del modulo { foo: 'foo', bar: 'bar' }.

Tuttavia, c’è un avvertimento. Qualunque cosa tu assegnimodule.exports è ciò che viene esportato dal tuo modulo.,

Quindi, prendi quanto segue:

exports.foo = 'foo';module.exports = () => { console.log('bar'); };

Ciò comporterebbe solo l’esportazione di una funzione anonima. La variabilefoo verrebbe ignorata.

Se vuoi leggere di più nella differenza, vi consiglio questo articolo.

Conclusione

I moduli sono diventati parte integrante dell’ecosistema JavaScript, permettendoci di comporre programmi di grandi dimensioni da parti più piccole. Spero che questo articolo ti abbia dato una buona introduzione a lavorare con loro in Node.js, oltre ad aiutare a demistificare la loro sintassi.