Modulele sunt una dintre caracteristicile fundamentale ale Node.js.
Când creați o aplicație, pe măsură ce codul devine din ce în ce mai complex, nu puteți pune întregul cod într-un singur fișier.
Deoarece acest lucru devine imposibil de gestionat, puteți utiliza modelul modulului Node pentru a scrie diferite fișiere și a le exporta (inclusiv funcții, obiecte și metode) în fișierul principal.
Acum ați putea întreba – ce este exact un module?
În termeni simpli, a module nu este altceva decât un fișier JavaScript. Asta e.
Cu funcționalitatea modulară a nodului, putem importa propriile noastre fișiere externe, module de nod de bază (native) și module NPM. În acest articol, vom discuta fiecare dintre acestea în detaliu.
Cum să importați propriile fișiere
În acest articol, vom discuta despre cum putem exporta și importa propriile noastre fișiere.
Practic, există două fișiere: calculate.js, de unde vom exporta și main.js unde vom importa acel fișier.
Avem ambele fișiere în același folder pentru a fi simplă.
Cum să importați o funcție
//---- Exported file [calculate.js] ----
const add = (a,b)=>{
return a + b
}
module.exports = add
Aici exportăm o funcție numită add folosind module.exports. Apoi, această funcție este importată într-un fișier diferit folosind require metodă.
În nod, fiecare fișier este denumit a module, și exports este o proprietate a modulului Object.
Acum putem invoca funcția în fișierul diferit, adică main.js, prin trecerea argumentelor așa cum se arată mai jos.
//------ Main File[main.js] ----
const add = require('./calculate') //name of the desired file
const result = add(2,4)
console.log(result); //Output : 6
Cum să importați un obiect
De asemenea, putem exporta un întreg obiect și putem accesa diferitele metode din acesta.
//---- Exported file [calculate.js] ----
const add = {
result : (a,b)=>{
return a + b
}
}
module.exports = add
Am exportat obiectul add și l-am importat în fișierul nostru principal folosind require metodă.
Acum putem accesa fișierul result metoda add obiect folosind . operator punct:
//---- Main file[main.js] ----
const add = require('./calculate')
const result = add.result(5,8)
console.log(result) //Output : 13
Un alt mod în care putem exporta obiectul de mai sus este exportând doar metoda de care avem nevoie, mai degrabă decât întregul obiect.
//---- Exported file [calculate.js] ----
const add = {
result : (a,b)=>{
return a + b
}
}
module.exports = add.result
După cum puteți vedea, importăm fișierul result metoda în add obiect. Deci, această metodă poate fi invocată direct în fișierul principal.
Aceasta este o bună practică dacă nu aveți nevoie de întregul obiect, ci aveți nevoie doar de câteva metode / funcții ale acestuia. De asemenea, face codul nostru mai sigur.
//---- Main file[main.js] ----
const add = require('./calculate')
const result = add(5,8)
console.log(result) //Output : 13
Cum să importați un constructor de funcții:
Un constructor de funcții este utilizat în principiu pentru a crea o nouă instanță a unui obiect care posedă aceleași proprietăți ca cea a obiectului / funcției principale.
În cazul de mai jos, creăm o nouă instanță a obiectului „Adăugați” folosind new cuvânt cheie. Acest proces în care creăm o instanță a unui obiect se numește „instanțiere”.
Apoi exportăm această instanță folosind module.exports:
//---- Exported file [calculate.js] ----
function Add (){
this.result = (a,b)=>{
return a + b
}
}
module.exports = new Add()
Acum îl putem importa în fișierul nostru principal și accesa metoda „rezultat” din interior, pentru a obține valoarea noastră calculată.
//---- Main file[main.js] ----
const add = require('./calculate2')
const result = add.result(1,3)
console.log(result); //Output : 4
Astfel putem exporta și importa un constructor de funcții.
Există un alt mod în care putem face acest lucru, prin crearea noii noastre instanțe în fișierul principal, mai degrabă decât în fișierul exportat, așa cum se arată mai sus module.exports = new Add().
Vom vedea cum funcționează acest lucru atunci când exportăm clase ES6 care funcționează similar cu constructorii de funcții.
Cum se importă clase ES6
class este un tip special de funcție în care class cuvântul cheie ajută la inițializarea acestuia. Se folosește de constructor metoda de stocare a proprietăților.
Acum vom exporta întregul class folosind module.exports:
//---- Exported file [calculate.js] ----
const Add = class{
constructor(a,b){
this.a = a;
this.b = b;
}
result(){
return this.a + this.b
}
}
module.exports = Add;
Acum, în fișierul nostru principal, creăm o nouă instanță folosind new cuvânt cheie și accesați fișierul result metoda de a obține valoarea noastră calculată.
//---- Main file[main.js] ----
const add = require('./calculate')
const result = new add(2,5)
console.log(result.result()); //Output : 7
Cum să importați module de bază nod (native)
În loc să creeze propriile module personalizate de fiecare dată, Node oferă un set de module pentru a ne face viața mai ușoară.
Vom discuta unele dintre module, dar puteți găsi întreaga listă în documentul API oficial al nodului aici.
Importul modulelor Node este similar cu modul în care vă importați propriile module. Folosești la fel require() funcție pentru a-l accesa în propriul fișier.
Dar există unele module pe care este posibil să le fi folosit fără să știți, care nu trebuie importate. De exemplu console.log() – am folosit console modul de multe ori fără a-l prelua în propriul nostru fișier local, deoarece aceste metode sunt disponibile la nivel global.
Să ne uităm la unul dintre modulele native native care este Sistemul de fișiere (fs).
Există un număr de operații pe care le putem efectua cu modulul de sistem de fișiere, cum ar fi citirea unui fișier, scrierea unui fișier și actualizarea acestuia, pentru a numi câteva.
Vom folosi fs modul pentru a citi un fișier. Chiar și în această metodă, există două moduri în care putem efectua această acțiune: una prin utilizarea funcției sincrone fs.readFileSync(), iar cealaltă prin funcție asincronă fs.readFile().
Vom discuta funcțiile nodului sincron-asincron în postările viitoare.
Astăzi vom folosi versiunea asincronă, adică fs.readFile().
Pentru acest exemplu, am creat două fișiere: main.js, unde vom efectua operația de citire a fișierelor și file.txt care este fișierul pe care urmează să îl citim.
file.txt conține un text în el.
Hello World!Acum, folosim fs modul pentru a citi fișierul, fără a-l importa, așa cum se arată mai jos:
fs.readFile('./file.txt','utf-8',(err,data)=>{
if (err) throw err
console.log(data);
})Va arunca o eroare ca fs nu este definit. Asta pentru că sistemul de fișiere fs modulul nu este disponibil la nivel global ca console modulul este.
ReferenceError: fs is not defined
at Object.<anonymous> (C:UsersSarvesh KadamDesktopTrainingblogcode snippetsNode Modular Patternmain.js:3:1)
at Module._compile (internal/modules/cjs/loader.js:1256:30)
at Object.Module._extensions..js (internal/modules/cjs/loader.js:1277:10)
at Module.load (internal/modules/cjs/loader.js:1105:32)
at Function.Module._load (internal/modules/cjs/loader.js:967:14)
at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:60:12)
at internal/main/run_main_module.js:17:47
Prin urmare, trebuie să importăm toate datele din modulul de sistem de fișiere folosind require() funcționează și stochează toate acele date într-o variabilă fs.
const fs = require('fs')
fs.readFile('./file.txt','utf-8',(err,data)=>{
if (err) throw err
console.log(data);
})Acum puteți numi orice variabilă. L-am numit fs pentru lizibilitate și este standardul pe care îl urmează majoritatea dezvoltatorilor.
Folosind fs variabilă pe care o putem accesa readFile() metoda în care am trecut trei argumente Aceste argumente sunt calea fișierului, codificarea caracterelor utf-8, și funcția de apel invers pentru a da o ieșire.
S-ar putea să ne întrebați de ce trecem utf-8 ca argument al nostru în readFile()?
Deoarece codifică valoarea și oferă textul ca o ieșire, mai degrabă decât să ofere un buffer, așa cum se arată mai jos:
<Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64 21 21>
Funcția de apel invers, la rândul său, are două argumente: o eroare (err) și conținutul real din fișier (data). Apoi imprimăm asta data în consolă.
//Output:
Hello World!
Cum să importați module NPM
Deci, ce este exact Node Package Manager?
Pachetul este o bucată de cod gestionată de Managerul de pachete. Nu este altceva decât software care gestionează instalarea și actualizarea pachetelor.
NPM conform oficialului documentație:
NPM este cel mai mare registru de software din lume. Dezvoltatorii open-source din fiecare continent folosesc npm pentru a partaja și împrumuta pachete, iar multe organizații folosesc npm pentru a gestiona și dezvoltarea privată.
Deci, în NPM folosim codul open source al altcuiva administrat de NPM, importându-l în proiectul nostru.
NPM vine de obicei cu Node JS când îl descărcați. Puteți verifica dacă NPM este instalat pe computerul dvs. pur și simplu executând comanda npm -v pe promptul de comandă. Dacă returnează un anumit număr de versiune, înseamnă că NPM este instalat cu succes.
NPM are registrul său la npmjs.com unde puteți descoperi pachete pe care le puteți folosi.
Să ne uităm la unul dintre pachetele numite cretă care este practic folosit pentru stilul terminal.
În figura de mai sus, putem vedea descărcările săptămânale ale pachetului, ceea ce sugerează cât de popular este.
De asemenea, puteți vedea că acest pachet are dependențe în el. Deci, acest modul care va servi ca dependență de proiectul nostru este în sine dependent de alte module.
Acest întreg proces de gestionare este asigurat de Managerul de pachete.
Chiar și codul sursă este cel care este prezent pe GitHub ne este dat. Putem naviga la acesta și putem verifica dacă există probleme deschise.
Încă ceva înainte de a merge mai departe: pachetele NPM vin în versiuni diferite. Modelul urmat de versiune este versiunea semantică.
După cum puteți vedea, cea mai recentă versiune a cretă modul în care am scris acest articol este 4.1.0.
Urmează versiunea semantică Major_changes.Minor_changes.Patch model.
Major_changes, așa cum se numește, sunt modificările semnificative efectuate pe modul care ar putea afecta codul dvs. existent.
Minor_changes sunt îmbunătățiri sau caracteristici noi, împreună cu remedieri de defecte care au fost adăugate, care nu ar trebui să afecteze codul dvs. existent.
Patch este micile remedieri de erori care nu vă vor bloca codul existent.
Puteți afla mai multe despre versiunile semantice pe semver.org.
Cum se instalează NPM
Acum, pentru a importa orice pachet din NPM, trebuie mai întâi să inițializați NPM în folderul local de proiect executând comanda pe promptul de comandă:
npm init
După ce executați comanda de mai sus, aceasta vă va solicita anumite date, așa cum se arată mai jos, cum ar fi numele pachetului, versiunea și așa mai departe.
O mare parte din aceste date pot fi păstrate ca implicite, așa cum se menționează în parantezele rotunde ().
De asemenea, câmpurile precum author și license sunt pentru cei care au creat acele pachete NPM.
Pe de altă parte, doar le importăm și le folosim pentru a crea propria noastră aplicație.
package name: (code_npm) code_npm
version: (1.0.0) 1.0.0
description: npm demo
entry point: (index.js) index.js
test command: test
git repository:
keywords: npm test
author: Sarvesh
license: (ISC)
Odată ce ați introdus toate câmpurile, acesta va crea un fișier JSON cu valori care au proprietățile de mai sus și vă va cere o confirmare astfel:
Is this OK? (yes) yes
Odată ce ați confirmat yes va crea un package.json fișier cu toate datele pe care le-ați introdus așa cum este ilustrat mai jos:
{
"name": "code_npm",
"version": "1.0.0",
"description": "npm demo",
"main": "index.js",
"scripts": {
"test": "echo "Error: no test specified" && exit 1"
},
"keywords": [
"npm",
"test"
],
"author": "Sarvesh",
"license": "ISC"
}
De asemenea, puteți vedea un script obiect care are o test proprietate adăugată. Puteți să-l rulați folosind npm test comandă și va reda rezultatul dorit astfel:
"Error: no test specified"
Acum, în loc să faceți această metodă alungită de inițializare a NPM și introducerea valorilor proprietăților personalizate, puteți rula pur și simplu comanda:
npm init -y
După ce executați această comandă, aceasta va crea direct un package.json fișier cu valorile implicite.
Acum, pentru a instala cea mai recentă versiune a cretă în proiectul dvs., trebuie să executați comanda:
npm install chalk
De asemenea, puteți instala orice versiune specifică de care aveți nevoie de cretă doar prin adăugare @version number așa cum se arată mai jos. De asemenea, în loc de install puteți pune pur și simplu mâna scurtă i pavilion care înseamnă instalare:
npm i [email protected]
Aceasta va instala două lucruri, a node_modules folder și a package-lock.json fişier.
De asemenea, va adăuga o nouă proprietate numită dependencies la noi package.json fișier care conține numele pachetului instalat și versiunea acestuia.
"dependencies": {
"chalk": "^4.0.0"
}
node_module folderul conține folderul pachetelor și folderele dependenței sale. Se modifică pe măsură ce se instalează pachetul npm.
package-lock.json conține codul care face NPM mai rapid și mai sigur.
"chalk": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/chalk/-/chalk-4.0.0.tgz",
"integrity": "sha512-N9oWFcegS0sFr9oh1oz2d7Npos6vNoWW9HvtCg5N1KRFpUhaAhvTv5Y58g880fZaEYSNm3qDz8SU1UrGvp+n7A==",
"requires": {
"ansi-styles": "^4.1.0",
"supports-color": "^7.1.0"
}
Conține în principal proprietăți precum version, care este numărul versiunii semantice.
resolved property este directorul sau locația din care a fost preluat pachetul. În acest caz a fost preluat de la cretă.
integrity proprietatea este să ne asigurăm că obținem același cod dacă instalăm din nou dependența.
requires proprietatea obiect reprezintă dependența de chalk pachet.
Notă: Nu efectuați modificări la aceste două fișiere node_modules și package-lock.json
Cum se folosește NPM
Acum, după ce am instalat creta în proiectul nostru, îl putem importa în fișierul nostru de proiect rădăcină folosind require() metodă. Apoi putem stoca acel modul într-o variabilă numită chalk.
const chalk = require('chalk')
console.log(chalk.red("Hello World"))Folosind red() metoda chalk pachet, am stilizat culoarea textului „Hello World” în roșu.
La executarea comenzii node index.js obținem următoarea ieșire:
Acum există mai multe moduri în care puteți stiliza ieșirea din linia de comandă folosind pachetul de cretă. Pentru mai multe informații, puteți consulta articolul Document oficial cu cretă pe NPM.
De asemenea, puteți instala pachetele NPM la nivel global (adică pe sistemul nostru de operare), mai degrabă decât să le instalați în proiectul dvs. local, adăugând -g pavilion pe linia de comandă (care înseamnă global, așa cum se menționează mai jos):
npm i nodemon -g
Acest pachet global nu ne va afecta package.json în nici un fel, deoarece nu este instalat local.
Am instalat nodemon pachet global care este utilizat pentru repornirea automată a unei aplicații Node atunci când se observă modificări de fișiere în director.
Vă puteți referi la nodemon pentru mai multe informatii.
Putem folosi pachetul nodemon executând aplicația folosind această comandă:
nodemon index.js
Funcționează similar cu node index.js, cu excepția faptului că urmărește modificările fișierului și repornește aplicația odată detectate modificările.
[nodemon] 2.0.6
[nodemon] to restart at any time, enter `rs`
[nodemon] watching path(s): *.*
[nodemon] watching extensions: js,mjs,json
[nodemon] starting `node index.js`
Hello World
Notă: chalk stilul probabil nu va funcționa atunci când ați folosit nodemon.
În cele din urmă, vom trece prin dev dependencies. Există câteva pachete sau module NPM de care nu vom avea nevoie în mediul de producție al proiectului nostru, ci doar pentru cerințele noastre de dezvoltare.
Putem instala aceste module în proiectul nostru folosind dev pavilion așa cum se arată mai jos:
npm i nodemon --save-dev
Apoi creează o nouă proprietate în package.json numit devDependencies:
"devDependencies": {
"nodemon": "^2.0.6"
}
Concluzie
Folosind modelul modulului Node, putem importa din propriile noastre fișiere exportându-le sub formă de funcții, obiecte, constructori de funcții și clase ES6.
Și Node are propriul său set de module Core (native) pe care le putem folosi. Unele dintre ele sunt disponibile la nivel global, în timp ce unele dintre ele trebuie să fie importate local în proiectul / folderul dvs.
NPM este un manager de pachete care gestionează codul sursă deschisă de la terți pe care îl putem folosi în proiectul nostru. Înainte de a utiliza module NPM, trebuie să inițializați NPM local folosind npm init pe linia de comandă din rădăcina folderului de proiect.
Puteți instala orice pachet NPM utilizând comanda npm i <package name>. Și puteți instala pachetul NPM la nivel global utilizând -g steag. De asemenea, pachetul poate fi făcut dependent de dezvoltare folosind --save-dev steag.
Mulțumesc că ai citit! Dacă îți place acest articol, contactează-mă Stare de nervozitate pe măsură ce îmi continui documentarea învățării.
