Alai

Autorul a selectat Open Internet/Free Speech Fund pentru a primi o donație ca parte a programului Write for DOnations.

Introducere

În Node.js, un modul este o colecție de funcții și obiecte JavaScript care pot fi utilizate de aplicații externe. Descrierea unei bucăți de cod ca fiind un modul se referă mai puțin la ceea ce este codul și mai mult la ceea ce face – orice fișier sau colecție de fișiere Node.js poate fi considerat un modul dacă funcțiile și datele sale sunt făcute utilizabile de programe externe.

Pentru că modulele oferă unități de funcționalitate care pot fi reutilizate în multe programe mai mari, ele vă permit să creați aplicații cuplate lejer care se extind odată cu complexitatea și vă deschid ușa pentru a vă partaja codul cu alți dezvoltatori. Faptul că puteți scrie module care exportă funcții și date utile vă va permite să contribuiți la comunitatea Node.js mai largă – de fapt, toate pachetele pe care le utilizați pe npm au fost grupate și partajate ca module. Acest lucru face ca crearea de module să fie o abilitate esențială pentru un dezvoltator Node.js.

În acest tutorial, veți crea un modul Node.js care sugerează ce culoare ar trebui să folosească dezvoltatorii web în proiectele lor. Veți dezvolta modulul prin stocarea culorilor ca o matrice și prin furnizarea unei funcții pentru a prelua una la întâmplare. După aceea, veți parcurge diverse modalități de a importa un modul într-o aplicație Node.js.

Precondiții

• Voi avea nevoie de Node.js și npm instalate în mediul dumneavoastră de dezvoltare. Acest tutorial utilizează versiunea 10.17.0. Pentru a instala acest lucru pe macOS sau Ubuntu 18.04, urmați pașii din secțiunea Cum să instalați Node.js și să creați un mediu de dezvoltare local pe macOS sau secțiunea Instalare utilizând un PPA din Cum să instalați Node.js pe Ubuntu 18.04. Având Node.js instalat, veți avea instalat și npm; acest tutorial utilizează versiunea 6.11.3.
• De asemenea, ar trebui să fiți familiarizat cu fișierul package.json, iar experiența cu comenzile npm ar fi de asemenea utilă. Pentru a dobândi această experiență, urmăriți How To Use Node.js Modules with npm and package.json, în special Pasul 1 – Crearea unui fișier package.json.
• De asemenea, va fi util să vă simțiți confortabil cu Node.js REPL (Read-Evaluate-Print-Loop). Îl veți folosi pentru a vă testa modulul. Dacă aveți nevoie de mai multe informații în acest sens, citiți ghidul nostru despre Cum să utilizați REPL-ul Node.js.

Pasul 1 – Crearea unui modul

Acest pas vă va ghida în crearea primului dumneavoastră modul Node.js. Modulul dvs. va conține o colecție de culori într-o matrice și va furniza o funcție pentru a obține una la întâmplare. Veți folosi proprietatea exports încorporată în Node.js pentru a face funcția și array-ul disponibile pentru programele externe.

În primul rând, veți începe prin a decide ce date despre culori veți stoca în modulul dumneavoastră. Fiecare culoare va fi un obiect care conține o proprietate name pe care oamenii o pot identifica cu ușurință și o proprietate code care este un șir de caractere care conține un cod de culoare HTML. Codurile de culoare HTML sunt numere hexazecimale din șase cifre care vă permit să modificați culoarea elementelor de pe o pagină web. Puteți afla mai multe despre codurile de culoare HTML citind acest articol Coduri și nume de culori HTML.

Apoi veți decide ce culori doriți să suportați în modulul dumneavoastră. Modulul dvs. va conține o matrice numită allColors care va conține șase culori. Modulul dvs. va include, de asemenea, o funcție numită getRandomColor() care va selecta aleatoriu o culoare din tabloul dvs. și o va returna.

În terminalul dvs., faceți un nou folder numit colors și mutați-vă în el:

 
mkdir colors
 
cd colors
 

Inițializați npm astfel încât alte programe să poată importa acest modul mai târziu în tutorial:

npm init -y 

Ați folosit stegulețul -y pentru a sări peste solicitările obișnuite de personalizare a package.json dvs. Dacă acesta ar fi un modul pe care doriți să îl publicați în npm, ați răspunde la toate aceste solicitări cu date relevante, așa cum este explicat în How To Use Node.js Modules with npm and package.json.

În acest caz, rezultatul dvs. va fi:

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

Acum, deschideți un editor de text în linie de comandă, cum ar fi nano și creați un nou fișier care să servească drept punct de intrare pentru modulul dvs.:

nano index.js

Modulul dvs. va face câteva lucruri. În primul rând, veți defini o clasă Color. Clasa dvs. Color va fi instanțiată cu numele și codul HTML al acesteia. Adăugați următoarele linii pentru a crea clasa:

class Color { constructor(name, code) { this.name = name; this.code = code; }}

Acum că aveți structura de date pentru Color, adăugați câteva instanțe în modulul dumneavoastră. Scrieți următoarea matrice evidențiată în fișierul dumneavoastră:

class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;

În cele din urmă, introduceți o funcție care selectează aleatoriu un element din matricea allColors pe care tocmai ați creat-o:

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

Cuvântul cheie exports face referire la un obiect global disponibil în fiecare modul Node.js. Toate funcțiile și obiectele stocate în obiectul exports al unui modul sunt expuse atunci când alte module Node.js îl importă. Funcția getRandomColor() a fost creată direct pe obiectul exports, de exemplu. Ați adăugat apoi o proprietate allColors la obiectul exports care face referire la matricea de constante locale allColors creată mai devreme în script.

Când alte module importă acest modul, atât allColors cât și getRandomColor() vor fi expuse și disponibile pentru utilizare.

Salvați și ieșiți din fișier.

Până acum, ați creat un modul care conține o matrice de culori și o funcție care returnează una în mod aleatoriu. De asemenea, ați exportat matricea și funcția, astfel încât programele externe să le poată utiliza. În etapa următoare, veți utiliza modulul dvs. în alte aplicații pentru a demonstra efectele export.

Etapa 2 – Testarea modulului dvs. cu REPL

Înainte de a construi o aplicație completă, luați un moment pentru a confirma că modulul dvs. funcționează. În acest pas, veți utiliza REPL pentru a încărca modulul colors. În timp ce vă aflați în REPL, veți apela funcția getRandomColor() pentru a vedea dacă aceasta se comportă așa cum vă așteptați.

Porniți REPL-ul Node.js în același dosar cu fișierul index.js:

node

Când REPL-ul a pornit, veți vedea promptul >. Acest lucru înseamnă că puteți introduce cod JavaScript care va fi evaluat imediat. Dacă doriți să citiți mai multe despre acest lucru, urmăriți ghidul nostru privind utilizarea REPL.

În primul rând, introduceți următoarele:

colors = require('./index');

În această comandă, require() încarcă modulul colors în punctul său de intrare. Când apăsați ENTER, veți obține:

Output
{ getRandomColor: , allColors: }

RePL ne arată valoarea lui colors, care sunt toate funcțiile și obiectele importate din fișierul index.js. Când folosiți cuvântul cheie require, Node.js returnează tot conținutul din interiorul obiectului exports al unui modul.

Amintiți-vă că ați adăugat getRandomColor() și allColors la exports în modulul colors. Din acest motiv, le vedeți pe amândouă în REPL atunci când sunt importate.

La prompt, testați funcția getRandomColor():

colors.getRandomColor();

Vă va fi solicitată o culoare aleatorie:

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

Cum indexul este aleatoriu, rezultatul poate varia. Acum că ați confirmat că modulul colors funcționează, ieșiți din REPL Node.js:

.exit

Aceasta vă va readuce la linia de comandă a terminalului dumneavoastră.

Tocmai ați confirmat că modulul dumneavoastră funcționează conform așteptărilor folosind REPL. În continuare, veți aplica aceleași concepte și veți încărca modulul dvs. într-o aplicație, așa cum ați face într-un proiect real.

Pasul 3 – Salvarea modulului dvs. local ca dependență

În timp ce testați modulul dvs. în REPL, l-ați importat cu o cale relativă. Aceasta înseamnă că ați folosit locația fișierului index.js în raport cu directorul de lucru pentru a obține conținutul acestuia. Deși acest lucru funcționează, este de obicei o experiență de programare mai bună să importați modulele după numele lor, astfel încât importul să nu fie întrerupt atunci când se schimbă contextul. În acest pas, veți instala modulul colors cu caracteristica install a modulului local de la npm.

Setați un nou modul Node.js în afara folderului colors. Mai întâi, mergeți în directorul anterior și creați un nou dosar:

 
cd ..
 
mkdir really-large-application
 

Acum treceți în noul dvs. proiect:

cd really-large-application

Ca și în cazul modulului colors, inițializați dosarul cu npm:

npm init -y 

Se va genera următorul 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"}

Acum, instalați modulul colors și folosiți stegulețul --save, astfel încât acesta să fie înregistrat în fișierul package.json:

npm install --save ../colors

Tocmai ați instalat modulul colors în noul proiect. Deschideți fișierul package.json pentru a vedea noua dependență locală:

nano package.json

Vă veți da seama că au fost adăugate următoarele linii evidențiate:

{ "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" }}

Ieșiți din fișier.

Modulul colors a fost copiat în directorul dumneavoastră node_modules. Verificați că este acolo cu următoarea comandă:

ls node_modules

Aceasta va da următoarea ieșire:

Output
colors

Utilizați modulul local instalat în acest nou program. Deschideți din nou editorul de text și creați un alt fișier JavaScript:

nano index.js

Programul dvs. va importa mai întâi modulul colors. Acesta va alege apoi o culoare la întâmplare folosind funcția getRandomColor() furnizată de modul. În cele din urmă, va imprima un mesaj în consolă care spune utilizatorului ce culoare să folosească.

Introduceți următorul cod în 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ți și ieșiți din acest fișier.

Aplicația dvs. îi va spune acum utilizatorului o opțiune de culoare aleatorie pentru o componentă a site-ului web.

Executați acest script cu:

node index.js

Lovitura dvs. va fi similară cu:

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

Acum ați instalat cu succes modulul colors și îl puteți gestiona ca orice alt pachet npm utilizat în proiectul dvs. Cu toate acestea, dacă ați adăugat mai multe culori și funcții la modulul colors local, va trebui să rulați npm update în aplicațiile dvs. pentru a putea utiliza noile opțiuni. În pasul următor, veți utiliza modulul local colors într-un alt mod și veți obține actualizări automate atunci când codul modulului se modifică.

Pasul 4 – Conectarea unui modul local

Dacă modulul dvs. local este în dezvoltare intensă, actualizarea continuă a pachetelor poate fi plictisitoare. O alternativă ar fi să legați modulele. Legarea unui modul asigură faptul că orice actualizare a modulului se reflectă imediat în aplicațiile care îl utilizează.

În acest pas, veți lega modulul colors de aplicația dumneavoastră. De asemenea, veți modifica modulul colors și veți confirma că cele mai recente modificări ale sale funcționează în aplicație fără a fi nevoie să reinstalați sau să actualizați.

În primul rând, dezinstalați modulul local:

npm un colors

npm leagă modulele folosind legături simbolice (sau legături simbolice), care sunt referințe care indică fișiere sau directoare din calculatorul dumneavoastră. Legătura unui modul se face în doi pași:

1. Crearea unei legături globale către modul. npm creează o legătură simbolică între directorul dvs. global node_modules și directorul modulului dvs. Directorul global node_modules este locația în care sunt instalate toate pachetele npm la nivel de sistem (orice pachet pe care îl instalați cu steagul -g).
2. Crearea unei legături locale. npm creează o legătură simbolică între proiectul dvs. local care utilizează modulul și legătura globală a acestuia.

În primul rând, creați legătura globală revenind la dosarul colors și folosind comanda link:

 
cd ../colors
 
sudo npm link
 

După ce este completă, shell-ul dvs. va afișa:

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

Tocmai ați creat o legătură simbolică în dosarul dvs. node_modules către directorul colors.

Întoarceți-vă în dosarul really-large-application și legați pachetul:

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

Vă veți primi o ieșire similară cu următoarea:

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

Nota: Dacă doriți să tastați un pic mai puțin, puteți folosi ln în loc de link. De exemplu, npm ln colors ar fi funcționat exact în același mod.

După cum arată ieșirea, tocmai ați creat o legătură simbolică din directorul local node_modules al really-large-application dvs. către legătura simbolică colors din directorul global node_modules, care indică directorul real cu modulul colors.

Procesul de creare a legăturii este finalizat. Rulați fișierul dvs. pentru a vă asigura că încă funcționează:

node index.js

Lovitura dvs. va fi similară cu:

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

Funcționalitatea programului dvs. este intactă. În continuare, testați dacă actualizările sunt aplicate imediat. În editorul de text, redeschideți fișierul index.js din modulul colors:

 
cd ../colors
 
nano index.js
 

Acum adăugați o funcție care să selecteze cea mai bună nuanță de albastru care există. Nu primește argumente și returnează întotdeauna al treilea element din matricea allColors. Adăugați aceste linii la sfârșitul fișierului:

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ți și ieșiți din fișier, apoi redeschideți fișierul index.js din folderul really-large-application:

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

Realizați un apel la funcția getBlue() nou creată și imprimați o propoziție cu proprietățile culorii. Adăugați aceste instrucțiuni la sfârșitul fișierului:

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`);

Salvați și ieșiți din fișier.

Codul folosește acum funcția getBlue() nou creată. Executați fișierul ca și înainte:

node index.js

Vă veți obține o ieșire de genul:

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

Scriptul dvs. a fost capabil să utilizeze cea mai recentă funcție din modulul colors, fără a fi nevoie să rulați npm update. Acest lucru va face mai ușor să faceți modificări la această aplicație în dezvoltare.

Atunci când scrieți aplicații mai mari și mai complexe, gândiți-vă la modul în care codul conex poate fi grupat în module și la modul în care doriți ca aceste module să fie configurate. Dacă modulul dvs. va fi utilizat doar de un singur program, acesta poate rămâne în cadrul aceluiași proiect și poate fi referit printr-o cale relativă. În cazul în care modulul dvs. va fi ulterior partajat separat sau există într-o locație foarte diferită de proiectul la care lucrați acum, instalarea sau legarea ar putea fi mai viabilă. Modulele aflate în dezvoltare activă beneficiază, de asemenea, de actualizările automate ale legăturii. Dacă modulul nu este în dezvoltare activă, utilizarea npm install poate fi opțiunea mai ușoară.

Concluzie

În acest tutorial, ați învățat că un modul Node.js este un fișier JavaScript cu funcții și obiecte care pot fi utilizate de alte programe. Ați creat apoi un modul și ați atașat funcțiile și obiectele dvs. la obiectul global exports pentru a le pune la dispoziția programelor externe. În cele din urmă, ați importat acel modul într-un program, demonstrând modul în care modulele se reunesc în aplicații mai mari.

Acum că știți cum să creați module, gândiți-vă la tipul de program pe care doriți să-l scrieți și descompuneți-l în diverse componente, păstrând fiecare set unic de activități și date în propriile module. Cu cât veți avea mai multă practică în scrierea modulelor, cu atât mai bună va fi capacitatea dvs. de a scrie programe Node.js de calitate pe parcursul călătoriei dvs. de învățare. Pentru a lucra cu un exemplu de aplicație Node.js care utilizează module, consultați tutorialul nostru How To Set Up a Node.js Application for Production on Ubuntu 18.04.

.