Alai

A szerző a Write for DOnations program keretében a Nyílt Internet/Free Speech Fund-ot választotta adományozásra.

Bevezetés

A Node.js-ben a modul olyan JavaScript funkciók és objektumok gyűjteménye, amelyeket külső alkalmazások használhatnak. Egy kódrészlet modulként való leírása kevésbé arra utal, hogy mi a kód, és inkább arra, hogy mit csinál – bármely Node.js fájl vagy fájlok gyűjteménye modulnak tekinthető, ha függvényei és adatai külső programok számára is használhatóvá válnak.

Mivel a modulok olyan funkcionalitási egységeket biztosítanak, amelyek sok nagyobb programban újrafelhasználhatók, lehetővé teszik, hogy lazán kapcsolt alkalmazásokat hozzunk létre, amelyek a komplexitással együtt skálázódnak, és megnyitják az utat, hogy megosszuk a kódunkat más fejlesztőkkel. Azzal, hogy képes vagy olyan modulokat írni, amelyek hasznos funkciókat és adatokat exportálnak, hozzájárulhatsz a szélesebb Node.js közösséghez – valójában az npm-en használt összes csomagot modulokként csomagolták és osztották meg. Ez teszi a modulok létrehozását alapvető készséggé egy Node.js fejlesztő számára.

Ebben a bemutatóban egy olyan Node.js modult fog létrehozni, amely javaslatot tesz arra, hogy a webfejlesztők milyen színt használjanak a terveikben. A modult úgy fogod fejleszteni, hogy a színeket egy tömbben tárolod, és egy olyan függvényt biztosítasz, amely véletlenszerűen lekérdez egyet. Ezt követően végigfuttatod a modul Node.js alkalmazásba történő importálásának különböző módjait.

Előfeltételek

• Szükséged lesz a Node.js és az npm telepítésére a fejlesztőkörnyezetedben. Ez a bemutató a 10.17.0-s verziót használja. Ha ezt macOS-re vagy Ubuntu 18.04-re szeretné telepíteni, kövesse a Hogyan telepítsük a Node.js-t és hozzunk létre helyi fejlesztőkörnyezetet macOS-en, illetve a Hogyan telepítsük a Node.js-t Ubuntu 18.04-re című fejezet PPA használatával történő telepítés című részét. A Node.js telepítésével az npm is telepítve lesz; ez a bemutató a 6.11.3.
• verzióját használja.A package.json fájlt is ismernie kell, és az npm parancsokkal kapcsolatos tapasztalat is hasznos lenne. E tapasztalat megszerzéséhez kövesse a Hogyan használjunk Node.js modulokat az npm és a package.json segítségével, különösen az 1. lépés – A package.json fájl létrehozása.
• A Node.js REPL (Read-Evaluate-Print-Loop) használatának ismerete is segít. Ezt fogod használni a modulod tesztelésére. Ha további információra van szükséged erről, olvasd el a Hogyan használd a Node.js REPL-t című útmutatónkat.

1. lépés – Modul létrehozása

Ez a lépés végigvezet az első Node.js modulod létrehozásán. A modulod tartalmazni fog egy színgyűjteményt egy tömbben, és egy olyan függvényt, amellyel véletlenszerűen kaphatsz egyet. A Node.js beépített exports tulajdonságát fogod használni, hogy a függvényt és a tömböt külső programok számára is elérhetővé tedd.

Először is azzal kezded, hogy eldöntöd, milyen adatokat fogsz tárolni a színekről a modulodban. Minden szín egy objektum lesz, amely tartalmaz egy name tulajdonságot, amelyet az emberek könnyen azonosíthatnak, és egy code tulajdonságot, amely egy HTML színkódot tartalmazó karakterlánc. A HTML színkódok hatjegyű hexadecimális számok, amelyek lehetővé teszik a weblap elemeinek színének megváltoztatását. A HTML színkódokról többet megtudhat a HTML színkódok és nevek című cikkből.

Ezután eldöntheti, hogy milyen színeket szeretne támogatni a moduljában. A modulod tartalmazni fog egy allColors nevű tömböt, amely hat színt fog tartalmazni. A modulod tartalmazni fog egy getRandomColor() nevű függvényt is, amely véletlenszerűen kiválaszt egy színt a tömbödből, és visszaadja azt.

A terminálodban készíts egy új mappát colors néven, és költözz bele:

 
mkdir colors
 
cd colors
 

Inicializáld az npm-et, hogy más programok később a bemutató során importálni tudják ezt a modult:

npm init -y 

A -y flag segítségével kihagyhatod a szokásos kéréseket a package.json testre szabásához. Ha ez egy olyan modul lenne, amelyet közzé szeretnél tenni az npm-ben, akkor az összes ilyen kérésre válaszolnál a megfelelő adatokkal, ahogyan azt a Hogyan használjuk a Node.js modulokat az npm és a package.json segítségével című fejezetben elmagyaráztuk.

Ez esetben a kimeneted a következő lesz:

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

Most nyiss meg egy parancssori szövegszerkesztőt, például a nano-t, és hozz létre egy új fájlt, amely a modulod belépési pontjaként fog szolgálni:

nano index.js

A modulod néhány dolgot fog csinálni. Először is definiálni fogsz egy Color osztályt. A Color osztályodat a nevével és a HTML-kódjával fogod példányosítani. Az osztály létrehozásához add hozzá a következő sorokat:

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

Most, hogy megvan az Color adatszerkezete, adj hozzá néhány példányt a modulodhoz. Írd be a következő kiemelt tömböt a fájlodba:

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

Végül írj be egy függvényt, amely véletlenszerűen kiválaszt egy elemet az imént létrehozott allColors tömbből:

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

A exports kulcsszó egy minden Node.js modulban elérhető globális objektumra hivatkozik. Egy modul exports objektumában tárolt összes függvény és objektum láthatóvá válik, amikor más Node.js modulok importálják azt. A getRandomColor() függvény például közvetlenül a exports objektumon jött létre. Ezután hozzáadtál egy allColors tulajdonságot a exports objektumhoz, amely a szkriptben korábban létrehozott helyi konstans allColors tömbre hivatkozik.

Amikor más modulok importálják ezt a modult, a allColors és a getRandomColor() is láthatóvá és használhatóvá válik.

Mentés és kilépés a fájlból.

Elkészítettél egy modult, amely egy színtömböt és egy olyan függvényt tartalmaz, amely véletlenszerűen visszaad egyet. A tömböt és a függvényt exportáltad is, hogy külső programok is használhassák őket. A következő lépésben a modulodat más alkalmazásokban fogod használni, hogy demonstráld a export hatását.

2. lépés – A modul tesztelése a REPL segítségével

A teljes alkalmazás elkészítése előtt szánjon egy percet arra, hogy meggyőződjön arról, hogy a modulja működik. Ebben a lépésben a REPL segítségével fogja betölteni a colors modult. A REPL-ben meg fogja hívni a getRandomColor() függvényt, hogy megnézze, az úgy viselkedik-e, ahogyan azt elvárja.

Elindítja a Node.js REPL-t ugyanabban a mappában, mint a index.js fájlt:

node

Amikor a REPL elindult, megjelenik a > prompt. Ez azt jelenti, hogy JavaScript kódot írhat be, amely azonnal kiértékelésre kerül. Ha többet szeretne erről olvasni, kövesse a REPL használatáról szóló útmutatónkat.

Először írja be a következőt:

colors = require('./index');

Ezzel a paranccsal a require() betáplálja a colors modult a belépési pontján. Ha megnyomjuk a ENTER gombot, akkor:

Output
{ getRandomColor: , allColors: }

A REPL megmutatja nekünk a colors értékét, amely a index.js fájlból importált összes függvényt és objektumot tartalmazza. Ha a require kulcsszót használjuk, a Node.js a modul exports objektumán belüli összes tartalmat visszaadja.

Emlékezzünk vissza, hogy a colors modulban a exports-hoz getRandomColor() és allColors-t adtunk hozzá. Emiatt mindkettőt látod a REPL-ben, amikor importálod őket.

A promptban teszteld a getRandomColor() függvényt:

colors.getRandomColor();

Véletlenszerű színnel fogod kérdezni:

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

Mivel az index véletlenszerű, a kimeneted változhat. Most, hogy megerősítette, hogy a colors modul működik, lépjen ki a Node.js REPL-ből:

.exit

Ezzel visszatér a terminál parancssorába.

A REPL segítségével most megerősítette, hogy a modulja a várt módon működik. Ezután ugyanezeket a fogalmakat fogja alkalmazni, és betölti a modulját egy alkalmazásba, ahogyan azt egy valódi projektben tenné.

3. lépés – A helyi modul függőségként történő mentése

A moduljának a REPL-ben történő tesztelése során relatív elérési úttal importálta azt. Ez azt jelenti, hogy a index.js fájlnak a munkakönyvtárhoz viszonyított helyét használtad a tartalmának megszerzéséhez. Bár ez működik, általában jobb programozási élményt jelent, ha a modulokat a nevükkel importáljuk, így az importálás nem szakad meg, amikor a kontextus megváltozik. Ebben a lépésben a colors modult az npm helyi modul install funkciójával telepítjük.

Elhelyezzünk egy új Node.js modult a colors mappán kívül. Először menj az előző könyvtárba, és hozz létre egy új mappát:

 
cd ..
 
mkdir really-large-application
 

Most lépj az új projektedbe:

cd really-large-application

Az colors modulhoz hasonlóan inicializáld a mappádat az npm segítségével:

npm init -y 

A következő package.json fog generálódni:

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

Most telepítsd a colors modulodat, és használd a --save flaget, hogy rögzítve legyen a package.json fájlodban:

npm install --save ../colors

Az új projektbe most telepítetted a colors modulodat. Nyissa meg a package.json fájlt, hogy lássa az új helyi függőséget:

nano package.json

Az alábbi kiemelt sorokat fogja látni:

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

Lépjen ki a fájlból.

A colors modul átmásolódott a node_modules könyvtárába. Ellenőrizze, hogy ott van-e a következő paranccsal:

ls node_modules

Ez a következő kimenetet adja:

Output
colors

A telepített helyi modulját használja ebben az új programban. Nyisd meg újra a szövegszerkesztődet, és hozz létre egy másik JavaScript fájlt:

nano index.js

A programod először a colors modult fogja importálni. Ezután véletlenszerűen kiválaszt egy színt a modul által biztosított getRandomColor() függvény segítségével. Végül kiír egy üzenetet a konzolra, amely megmondja a felhasználónak, hogy milyen színt használ.

Az alábbi kódot írja be a index.js-be:

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

Mentés és kilépés ebből a fájlból.

Az alkalmazásod mostantól megmondja a felhasználónak egy véletlenszerű színválasztékot a webhelykomponenshez.

Futtasd ezt a szkriptet:

node index.js

A kimeneted hasonló lesz:

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

Az colors modult most már sikeresen telepítetted, és úgy tudod kezelni, mint bármely más, a projektedben használt npm csomagot. Ha azonban több színt és funkciót adnál hozzá a helyi colors modulodhoz, akkor a npm update futtatását kellene elvégezned az alkalmazásaidban, hogy használni tudd az új opciókat. A következő lépésben a helyi colors modult más módon fogja használni, és automatikus frissítéseket kap, amikor a modul kódja változik.

4. lépés – A helyi modul összekapcsolása

Ha a helyi modulja intenzív fejlesztés alatt áll, a csomagok folyamatos frissítése fárasztó lehet. Alternatív megoldás lehet a modulok összekapcsolása. A modul összekapcsolása biztosítja, hogy a modul minden frissítése azonnal megjelenjen a modult használó alkalmazásokban.

Ezzel a lépéssel összekapcsolja a colors modult az alkalmazásával. Emellett módosítja a colors modult, és megerősíti, hogy a legújabb módosításai működnek az alkalmazásban anélkül, hogy újra kellene telepíteni vagy frissíteni.

Először is távolítsa el a helyi modult:

npm un colors

a npm a modulokat szimbolikus linkek (vagy szimlinkek) segítségével linkeli, amelyek olyan hivatkozások, amelyek a számítógépen lévő fájlokra vagy könyvtárakra mutatnak. Egy modul linkelése két lépésben történik:

1. Globális link létrehozása a modulhoz. npm létrehoz egy szimbolikus linket a globális node_modules könyvtár és a modul könyvtára között. A globális node_modules könyvtár az a hely, ahová az összes rendszerszintű npm csomagja telepítve van (minden olyan csomag, amelyet a -g flaggel telepít).
2. Lokális link létrehozása. npm létrehoz egy symlinket a modult használó helyi projektje és a modul globális linkje között.

Először is hozza létre a globális linket úgy, hogy visszatér a colors mappába, és a link parancsot használja:

 
cd ../colors
 
sudo npm link
 

Ha elkészült, a héja kimeneti:

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

Most létrehozott egy symlinket a node_modules mappában a colors könyvtárba.

Visszatérsz a really-large-application mappába, és összekapcsolod a csomagot:

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

A következőhöz hasonló kimenetet fogsz kapni:

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

Megjegyzés: Ha egy kicsit kevesebbet szeretnél gépelni, akkor a link helyett használhatod a ln-et. Például a npm ln colors pontosan ugyanígy működött volna.

Amint a kimenet mutatja, épp most hoztál létre egy szimlinket a really-large-application helyi node_modules könyvtáradból a colors szimlinkre a globális node_modules-ban, amely a colors modult tartalmazó tényleges könyvtárra mutat.

A linkelési folyamat befejeződött. Futtasd le a fájlodat, hogy megbizonyosodj arról, hogy még mindig működik:

node index.js

A kimeneted hasonló lesz, mint:

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

A programod funkcionalitása sértetlen. Ezután tesztelje, hogy a frissítések azonnal alkalmazásra kerülnek-e. A szövegszerkesztőben nyissa meg újra a index.js fájlt a colors modulban:

 
cd ../colors
 
nano index.js
 

Most adjon hozzá egy olyan függvényt, amely kiválasztja a kék létező legjobb árnyalatát. Nem fogad el argumentumokat, és mindig a allColors tömb harmadik elemét adja vissza. Adjuk hozzá ezeket a sorokat a fájl végéhez:

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

Mentsük el és lépjünk ki a fájlból, majd nyissuk meg újra a index.js fájlt a really-large-application mappában:

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

Hívjuk meg az újonnan létrehozott getBlue() függvényt, és írjunk ki egy mondatot a szín tulajdonságaival. Adja hozzá ezeket az utasításokat a fájl végéhez:

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

Mentés és kilépés a fájlból.

A kód most már az újonnan létrehozott getBlue() függvényt használja. Végezze el a fájlt a korábbiak szerint:

node index.js

Az alábbi kimenetet fogja kapni:

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

A szkriptje képes volt használni a colors modul legújabb függvényét, anélkül, hogy a npm update futtatására lett volna szükség. Ez megkönnyíti az alkalmazás módosítását a fejlesztés során.

Amint nagyobb és összetettebb alkalmazásokat ír, gondolja át, hogy a kapcsolódó kódot hogyan lehet modulokba csoportosítani, és hogyan szeretné ezeket a modulokat beállítani. Ha a modulját csak egy program fogja használni, akkor maradhat ugyanazon a projekten belül, és relatív elérési útvonallal hivatkozhat rá. Ha a modulját később külön fogja megosztani, vagy a mostani projekttől nagyon eltérő helyen létezik, a telepítés vagy a linkelés lehet, hogy életképesebb. Az aktív fejlesztés alatt álló modulok is profitálnak a linkelés automatikus frissítéseiből. Ha a modul nem aktív fejlesztés alatt áll, a npm install használata lehet a könnyebb megoldás.

Következtetés

Ebben a bemutatóban megtanulta, hogy a Node.js modul egy olyan JavaScript fájl, amely más programok által használható funkciókat és objektumokat tartalmaz. Ezután létrehoztál egy modult, és a függvényeidet és objektumaidat a globális exports objektumhoz csatoltad, hogy külső programok számára is elérhetővé tedd őket. Végül ezt a modult importálta egy programba, bemutatva, hogyan állnak össze a modulok nagyobb alkalmazásokká.

Most, hogy tudja, hogyan kell modulokat létrehozni, gondolja át, milyen típusú programot szeretne írni, és bontsa azt különböző összetevőkre, minden egyes egyedi tevékenység- és adatkészletet saját moduljában tartva. Minél több gyakorlatot szerez a modulok írásában, annál jobb lesz a képessége, hogy minőségi Node.js programokat írjon a tanulási útja során. Ha egy modulokat használó Node.js alkalmazás példáján szeretne végigmenni, tekintse meg a Hogyan állítsunk be egy Node.js alkalmazást gyártásra Ubuntu 18.04 rendszeren című oktatóanyagunkat.