Modulok
A Node.js minden egyes JavaScript fájlt külön modulként kezel.Például, ha van egy fájl, amely valamilyen kódot tartalmaz, és ezt a fájlt elnevezik xyz.js
, akkor ezt a fájlt modulként kezeljük a Node-ban, és mondhatjuk, hogy létrehoztunk egy nevű modult xyz
.

Vegyünk egy példát, hogy ezt jobban megértsük.
Van egy fájlja, circle.js
amely az adott sugarú kör területének és kerületének kiszámításához szükséges logikából áll, az alábbiak szerint:
kör.js
Hívhatja a circle.js
fájlt nevű modulnak circle
.
Kíváncsi lehet, miért van szükség több modulra? Csak beírhatta az összes kódot egyetlen modulba. Nos, nagyon fontos moduláris kódot írni. Moduláris alatt azt akarom mondani, hogy a kódjának függetlennek és lazán összekapcsoltnak kell lennie. Képzelje el, hogy van egy nagy alkalmazás, és az összes kódot csak egy helyre, csak egy fájlba írja. Túl rendetlen, igaz?
Hogyan fut a modulba írt kód?
Mielőtt végrehajtaná a modulba írt kódot, a Node átveszi a teljes kódot, és bezárja egy függvény burkolóba. Ennek a funkcióburkolónak a szintaxisa:

A circle
modul funkcióburkolója az alábbiak szerint fog kinézni:
Láthatja, hogy a gyökér szintjén van egy funkció burkoló, amely felöleli a circle
modulba írt összes kódot .
Ez a legjelentősebb előnye annak, ha a modulok a Node.js-ben vannak. Még akkor is, ha globális változót definiál egy modulban var
, let
vagy const
kulcsszavak használatával, a változók lokálisan a modulra terjednek ki, nem pedig globálisan. Ez azért történik, mert minden modulnak van egy saját funkcióburkolója, és az egyik függvénybe beírt kód lokális ennek a függvénynek, és nem érhető el ezen a függvényen kívül.

Képzeljük el, hogy van két modul - A és B . A kódot írt belsejében modul van zárva a funkciót wrapper megfelelő modul . Hasonló történik a B modulba írt kóddal . Mivel a mindkét modulhoz tartozó kód különféle funkciókba van foglalva, ezek a funkciók nem fogják tudni elérni egymás kódját. (Ne feledje, hogy a JavaScript minden egyes funkciójának megvan a maga helyi hatóköre?) Ez az oka annak, hogy az A modul nem tud hozzáférni a B modulba írt kódhoz, és fordítva.
Az öt paraméter - exports
, require
, module
, __filename
, __dirname
állnak belül minden modul csomópont. Bár ezek a paraméterek globálisak a modulban található kódhoz képest, mégis lokálisak a modulhoz (a függvény burkolójának a fentiekben leírtak miatt). Ezek a paraméterek értékes információkat nyújtanak a modullal kapcsolatban.
Nézzük át a circle
modult, amelyet korábban megnézett. Ebben a modulban három konstrukció van meghatározva - egy állandó változó PI
, egy megnevezett függvény calculateArea
és egy másik függvény megnevezve calculateCircumference
. Fontos szem előtt tartani, hogy ezek a konstrukciók circle
alapértelmezés szerint privátak a modulhoz. Ez azt jelenti, hogy ezeket a konstrukciókat csak kifejezetten megadva használhatja más modulokban.
Tehát a most felmerülő kérdés az, hogy hogyan adhat meg valamit egy modulban, amelyet más modul használhat? Ekkor hasznosak a függvénytörlő module
& require
paraméterei. Beszéljük meg ezt a két paramétert ebben a cikkben.
module
A module
paraméter (inkább egy kulcsszó a modulban a Node-ban) az aktuális modult képviselő objektumra vonatkozik . exports
az module
objektum kulcsa , amelynek megfelelő értéke egy objektum. Az module.exports
objektum alapértelmezett értéke {}
(üres objektum). Ezt úgy ellenőrizheti, hogy a module
kulcsszó értékét bármely modulban naplózza . Ellenőrizzük, hogy mekkora a module
paraméter értéke a circle
modulban.
kör.js
Figyelje meg, hogy a console.log(module);
fenti fájlban található egy kód a kód végén. Amikor látja a kimenetet, naplózza az module
objektumot, amelynek van egy neve megnevezett kulccsal, exports
és ennek a kulcsnak megfelelő értéke {}
(üres objektum).
Most mit csinál az module.exports
objektum? Nos, a modul által exportálható dolgok meghatározására szolgál. Bármi, amit egy modulból exportálnak, az más modulok számára elérhetővé válhat. Valamit exportálni meglehetősen egyszerű. Csak hozzá kell adnia az module.exports
objektumhoz. Háromféleképpen adhat hozzá valamit az module.exports
exportálandó objektumhoz. Beszéljük meg ezeket a módszereket egyenként.
1. módszer:
(Konstrukciók definiálása, majd több module.exports
utasítás használata tulajdonságok hozzáadásához)
Az első módszerben először definiálja a konstrukciókat, majd több modul.exports állítást használ, ahol az egyes utasításokat valamilyen modulból exportálják. Nézzük meg ezt a módszert működés közben, és nézzük meg, hogyan lehet exportálni a circle
modulban definiált két függvényt .
kör.js
Amint azt korábban elmondtam, module
egy olyan objektum, amelynek a kulcsa meg van nevezve, exports
és ez a kulcs ( module.exports
) viszont egy másik objektumból áll. Most, ha észreveszi a fent megadott kódot, csak annyit tesz, hogy új tulajdonságokat (kulcs-érték párokat) ad hozzá az module.exports
objektumhoz.
Az első tulajdonságban van a kulcs calculateArea
(a 19. soron definiálva)és a hozzárendelés operátor jobb oldalára írt érték a névvel meghatározott funkció calculateArea
(a 9. sorban).
A második tulajdonság (amelyet a 20. sor határoz meg) rendelkezik a kulccsal calculateCircumference
és az érték a névvel definiált függvény calculateCircumference
(a 16. sorban).
Így két tulajdonságot (kulcs-érték pár) rendelt az module.exports
objektumhoz.
Ne felejtsük el azt sem, hogy itt a pontjelölést használtad. Alternatív megoldásként használhatja a zárójel jelölést a tulajdonságok hozzárendeléséhez az module.exports
objektumhoz, és hozzáadhatja a függvényeket - calculateArea
és calculateCircumference
a zárójel jelölést követő kulcsok megadásával. Így a következő két sort megírhatja tulajdonságok hozzáadásához az module.exports
objektumhoz zárójeles jelölés használatával, miközben az előző két sort helyettesíti (pontjelöléssel) a fent megadott kódban:
// exporting stuff by adding to module.exports object using the bracket notation
module.exports['calculateArea'] = calculateArea;module.exports['calculateCircumference'] = calculateCircumference;
Most próbáljuk meg naplózni az module.exports
objektum értékét a tulajdonságok hozzáadása után. Vegye figyelembe, hogy az alábbi állítás a kód végén található az alábbi fájlban:
// logging the contents of module.exports object after adding properties to it
console.log(module.exports);
kör.js
Ellenőrizzük ennek a kódnak a kimenetét, és nézzük meg, hogy minden jól működik-e. Ehhez mentse el a kódot, és futtassa a következő parancsot a terminálon :
node circle
Kimenet:
{ calculateArea: [Function: calculateArea], calculateCircumference: [Function: calculateCircumference] }
A konstrukciókat - calculateArea
és calculateCircumference
az module.exports
objektumhoz hozzáadva - naplózza. Így sikeresen hozzáadta a két tulajdonságot az module.exports
objektumba, így a függvények - calculateArea
és calculateCircumference
exportálhatók a circle
modulból egy másik modulba.
Ebben a módszerben először definiálta az összes konstrukciót, majd több modul.export parancsot használt, ahol minden utasítással tulajdonságot adnak az module.exports
objektumhoz.
2. módszer:
(Konstrukciók meghatározása, majd egyetlen module.exports
utasítás használata tulajdonságok hozzáadásához)
Egy másik módszer az, hogy először definiáljuk az összes konstrukciót (ahogyan azt a korábbi módszerben tettük), de egyetlen module.exports
utasítással exportálhatjuk őket. Ez a módszer hasonlít az objektum szó szerinti jelölés szintaxisához, ahol az összes tulajdonságot egyszerre adja hozzá egy objektumhoz.
Itt az objektum szó szerinti jelölést használta, és mind a függvényeket - calculateArea
mind calculateCircumference
(egyszerre) hozzáadta az module.exports
objektumhoz egyetlen modul.exports utasítás megírásával .
Ha ellenőrzi ennek a kódnak a kimenetét, akkor ugyanazt az eredményt kapja, mint amit korábban kapott az 1. módszer használatakor.
3. módszer:
(Tulajdonságok hozzáadása az module.exports
objektumhoz a konstrukciók definiálása közben)
Ebben a módszerben hozzáadhatja a konstruktumokat az module.exports
objektumhoz, miközben meghatározza azokat. Lássuk, hogyan alkalmazható ez a módszer a circle
modulunkban.
A fent megadott kódban láthatja, hogy a modulban található függvények module.exports
definiáláskor hozzáadódnak az objektumhoz. Nézzük meg, hogyan működik ez. Kulcsot calculateArea
ad hozzá az module.exports
objektumhoz, és ennek a kulcsnak megfelelő érték a függvénydefiníció.
Vegye figyelembe, hogy a függvénynek már nincs neve, és névtelen függvény, amelyet csak egy objektum kulcsának értékeként kezelnek. Így erre a függvényre nem lehet hivatkozni a circle
modulban, és nem hívhatja meg ezt a függvényt a modulon belül a következő utasítás megírásával:
calculateArea(8);
Ha megpróbálja végrehajtani a fenti állítást, akkor kap egy ReferenceError
nyilatkozatot calculateArea is not defined
.
Most, hogy megtanulta, hogyan adhatja meg, hogy mit kell exportálni egy modulból, mit gondol, hogyan fogja tudni használni a másik modul az exportált anyagokat? Importálnia kell a modult valamilyen más modulba, hogy az előbbiből exportált anyagokat az utóbbiban tudja használni. Ekkor meg kell vitatnunk egy másik nevű paramétert require
.
megkövetelik
require
kulcsszó egy olyan függvényre utal, amely az module.exports
objektum segítségével exportált összes konstrukció importálására szolgál egy másik modulból. Ha van olyan x modulod , amelyben néhány konstrukciót exportálsz az module.exports
objektum segítségével, és ezeket az exportált konstrukciókat az y modulba akarod importálni , akkor a függvény használatával meg kell követelned az x modult az y modulban require
. Az yrequire
modulban a függvény által visszaadott érték megegyezik az x modulban levő objektummal .module.exports

Értsük meg ezt a korábban tárgyalt példán keresztül. Már megvan a circle
modul, amelyből exportálja a függvényeket calculateArea
és calculateCircumference
. Most nézzük meg, hogyan használhatja a require
függvényt az exportált dolgok importálásához egy másik modulba.
Először hozzunk létre egy új fájlt, amelyben a circle
modulból exportált kódot fogja használni . Nevezzük el ezt a fájlt, app.js
és hívhatjuk app
modulnak.
A cél a app
modulból exportált összes kód importálása a circle
modulba. Szóval, hogyan lehet az egyik modulba írt kódját beilleszteni egy másik modulba?
Vegye figyelembe az require
alább megadott szintaxist :
const variableToHoldExportedStuff = require('idOrPathOfModule');
A require
függvény olyan argumentumot vesz fel, amely lehet azonosító vagy elérési út. Az azonosító a szükséges modul azonosítójára (vagy nevére) utal. Meg kell adnia az azonosítót argumentumként, amikor a Node Package Manager által biztosított külső modulokat vagy alapvető modulokat használja. Másrészt, ha egyéni modulokat határoz meg, akkor meg kell adnia argumentumként a modul elérési útját. Erről a linkről többet tudhat meg a szükséges funkcióról.
Mivel már definiált egy nevű egyéni modult circle
, a require
függvény argumentumaként megadja az elérési utat .
app.js
Ha világosan észreveszi, a pont az útvonal elején azt jelenti, hogy ez egy relatív útvonal, és hogy a modulok app
és circle
ugyanazon az úton vannak tárolva.
Jelentkezzünk be a konzolba a circle
változóba, amely tartalmazza a require
függvény által visszaadott eredményt . Lássuk, mit tartalmaz ez a változó.
app.js
Ellenőrizze a kimenetet az összes kód elmentésével és a következő parancs futtatásával a terminálban (ez utóbbi nem szükséges, ha nodemon
telepítve van a csomag):
node app
Kimenet:
{ calculateArea: [Function: calculateArea],calculateCircumference: [Function: calculateCircumference] }
Amint láthatja, a require
függvény egy olyan objektumot ad vissza, amelynek kulcsai a szükséges modulból ( circle
) exportált változók / függvények nevei . Röviden: a require
függvény visszaadja az module.exports
objektumot.
Most nyissuk meg a circle
modulból importált függvényeket .
app.js
Kimenet:
Area = 200.96, Circumference = 50.24
Szerinted mi fog történni, ha megpróbálom elérni PI
a circle
modulban definiált változót a modul belsejében app
?
app.js
Kimenet:
Area = 200.96, Circumference = 50.24pi = undefined
Tud kitalálni, hogy miért pi
van undefined
? Nos, ez azért van, mert a változót PI
nem exportálják a circle
modulból. Emlékezzen arra a pontra, ahol azt mondtam, hogy nem férhet hozzá a modulba írt kódhoz egy másik modulban, mivel az összes kód, amelyet egy modulba írtak, csak akkor exportálható, ha exportálják? Itt olyasmihez próbál hozzáférni, amelyet nem exportáltak a circle
modulból, és amely privát hozzá tartozik.
Szóval, azon gondolkodhat, miért nem kapott a ReferenceError
. Ennek oka az, hogy megpróbál elérni egy kulcsot, amelyet a függvény által visszaadott objektumon PI
belül neveznek module.exports
el require
. Azt is tudja, hogy a megnevezett kulcs PI
nem létezik az module.exports
objektumban.
Vegye figyelembe, hogy amikor egy objektumban nem létező kulcshoz próbál hozzáférni, akkor az eredményt így kapja undefined
. Ez az oka annak, hogy kapsz, PI
mint undefined
ahelyett, hogy a ReferenceError
.
Most exportáljuk a változót PI
a circle
modulból, és nézzük meg, változik-e a válasz.
kör.js
Figyelje meg, hogy itt nem a változó nevét használja PI
az module.exports
objektumhoz hozzáadott tulajdonság kulcsaként . Ehelyett másik nevet használ, ami lifeOfPi
.
Érdekes megjegyezni ezt. Ha valamilyen kódoló konstrukciót exportál, az module.exports
objektumhoz hozzáadott tulajdonság hozzáadásakor bármilyen nevet adhat a kulcsnak . A konstrukció meghatározása során nem kötelező ugyanazt a nevet használni. Ez azért van, mert bármilyen érvényes azonosítót használhat kulcsként egy JavaScript-objektumban. Így a hozzárendelés operátor bal oldalán bármilyen érvényes azonosítót használhat, de a hozzárendelés operátor jobb oldalán meg kell adnia egy értéket, amelyet konstrukcióként definiálnak az aktuális modul hatókörében (ahogy Ön meghatároztuk a változókat és a függvényeket a „kör” modulban).
Fontos megjegyezni, hogy miközben importál valamit az aktuális modul másik moduljából, ugyanazt a kulcsot kell használnia, amelyet az exportálásakor használt.
app.js
Mivel a kulcsot használtad lifeOfPi
, ugyanazt a kulcsot kell használnod PI
a circle
modulban definiált változó eléréséhez , ahogyan azt a fent megadott kód is teszi.
Kimenet:
Area = 200.96, Circumference = 50.24pi = 3.14
Szerinted mi fog történni, ha az exportáláskor használt kulcs helyett a változó nevét használod? Röviden, próbáljuk meg elérni PI
(a változó neve) az lifeOfPi
(exportáláskor használt kulcs ) helyett PI
.
app.js
Kimenet:
Area = 200.96, Circumference = 50.24pi = undefined
Ez azért történik, mert az module.exports
objektum már nem ismeri a változót PI
. Csak tud a hozzá adott kulcsokról. Mivel a változó exportálásához használt kulcs PI
az lifeOfPi
, az utóbbi csak az előbbihez használható.
TL; DR
- A Node.js minden fájlját modulnak nevezzük .
- A modulba írt kód végrehajtása előtt a Node.js elveszi a modul belsejébe írt teljes kódot, és átalakítja azt egy funkció burkolóvá, amelynek a következő szintaxisa van:
(function(exports, require, module, __filename, __dirname) { // entire module code lives in here});
- A függvény burkolója biztosítja, hogy a modulon belül beírt összes kód privát legyen, hacsak kifejezetten másként nem exportálták (exportálták). A paraméterek
exports
,require
,module
,__filename
, és__dirname
úgy járnak, mint a változók globális az egész kódot egy modult. Mivel mindegyik modulnak van egy saját funkcióburkolója, az egyik funkcióburkolóba beírt kód lokálissá válik az adott funkcióburkolóhoz (olvasási modul), és nem érhető el egy másik függvényburkolóban (olvasási modul). module
kulcsszó az aktuális modult képviselő objektumra utal. Azmodule
objektumnak van egy neveexports
.module.exports
egy másik objektum, amely meghatározza, hogy mi exportálható egy modul által, és elérhetővé tehető más modulok számára. Röviden, ha egy modul exportálni akar valamit, akkor hozzá kell adni azmodule.exports
objektumhoz.- Az
module.exports
objektum alapértelmezett értéke{}
. - Három módszer létezik, amelyekkel exportálhat valamit egy modulból, vagy hozzáadhat valamit az
module.exports
objektumhoz:1. Először határozza meg az összes konstrukciót, majd használjon több
module.exports
utasítást, ahol az egyes utasításokat egy konstrukció exportálásához használják.2. Először definiálja az összes konstrukciót, majd egyetlen
module.exports
utasítással exportálja az összes konstrukciót egyszerre az objektum szó szerinti jelölés alapján.3. Adjon konstruktumokat az
module.exports
objektumhoz, miközben definiálja azokat. require
kulcsszó egy olyan függvényre utal, amely azmodule.exports
objektum használatával exportált összes változó és függvény importálására szolgál egy másik modulból. Röviden, ha egy fájl importálni akar valamit, akkor azt a következő szintaxissal kell deklarálnia:
require('idOrPathOfModule');
- Miközben exportál valamit egy modulból, bármilyen érvényes azonosítót használhat. Nem kötelező megadni a változó / függvény pontos nevét az
module.exports
objektumhoz hozzáadott tulajdonság kulcsaként . Csak győződjön meg arról, hogy ugyanazt a kulcsot használja valamilyen fájl eléréséhez, amelyet exportálásakor használt.