Alai

Författaren valde Open Internet/Free Speech Fund för att få en donation som en del av programmet Write for DOnations.

Introduktion

I Node.js är en modul en samling JavaScript-funktioner och -objekt som kan användas av externa program. Att beskriva en bit kod som en modul hänvisar mindre till vad koden är och mer till vad den gör – vilken Node.js-fil eller samling filer som helst kan betraktas som en modul om dess funktioner och data görs användbara för externa program.

Då moduler ger enheter av funktionalitet som kan återanvändas i många större program, gör de det möjligt för dig att skapa löst kopplade program som skalas med komplexiteten, och de öppnar upp dörren för dig att dela din kod med andra utvecklare. Om du kan skriva moduler som exporterar användbara funktioner och data kan du bidra till det bredare Node.js-samhället – faktum är att alla paket som du använder på npm paketerades och delades som moduler. Detta gör att skapandet av moduler är en viktig färdighet för en Node.js-utvecklare.

I den här handledningen kommer du att skapa en Node.js-modul som föreslår vilken färg webbutvecklare bör använda i sin design. Du kommer att utveckla modulen genom att lagra färgerna som en array och tillhandahålla en funktion för att hämta en slumpmässigt. Därefter kommer du att gå igenom olika sätt att importera en modul till ett Node.js-program.

Förutsättningar

• Du behöver Node.js och npm installerade i din utvecklingsmiljö. I den här handledningen används version 10.17.0. Om du vill installera detta på macOS eller Ubuntu 18.04 följer du stegen i Så här installerar du Node.js och skapar en lokal utvecklingsmiljö på macOS eller i avsnittet Installera med hjälp av en PPA i Så här installerar du Node.js på Ubuntu 18.04. Genom att ha Node.js installerat kommer du också att ha npm installerat; den här handledningen använder version 6.11.3.
• Du bör också vara bekant med package.json-filen, och erfarenhet av npm-kommandon skulle också vara användbart. För att få denna erfarenhet kan du följa How To Use Node.js Modules with npm and package.json, särskilt steg 1 – Creating a package.json File.
• Det är också bra att känna sig bekväm med Node.js REPL (Read-Evaluate-Print-Loop). Du kommer att använda detta för att testa din modul. Om du behöver mer information om detta kan du läsa vår guide om hur du använder Node.js REPL.

Steg 1 – Skapa en modul

Detta steg guidar dig genom att skapa din första Node.js-modul. Din modul kommer att innehålla en samling färger i en array och tillhandahålla en funktion för att ta fram en slumpmässig färg. Du kommer att använda den Node.js-inbyggda egenskapen exports för att göra funktionen och matrisen tillgänglig för externa program.

Först börjar du med att bestämma vilka data om färger du ska lagra i din modul. Varje färg kommer att vara ett objekt som innehåller en name-egenskap som människor lätt kan identifiera och en code-egenskap som är en sträng som innehåller en HTML-färgkod. HTML-färgkoder är sexsiffriga hexadecimala tal som gör det möjligt att ändra färgen på element på en webbsida. Du kan lära dig mer om HTML-färgkoder genom att läsa denna artikel om HTML-färgkoder och namn.

Du bestämmer sedan vilka färger du vill stödja i din modul. Din modul kommer att innehålla en array kallad allColors som kommer att innehålla sex färger. Din modul kommer också att innehålla en funktion som heter getRandomColor() som slumpmässigt väljer en färg från din array och returnerar den.

I din terminal gör du en ny mapp som heter colors och flyttar in i den:

 
mkdir colors
 
cd colors
 

Initialisera npm så att andra program kan importera den här modulen senare i handledningen:

npm init -y 

Du använde flaggan -y för att hoppa över de vanliga uppmaningarna att anpassa din package.json. Om det här var en modul som du ville publicera till npm skulle du besvara alla dessa uppmaningar med relevanta uppgifter, vilket förklaras i Hur man använder Node.js-moduler med npm och package.json.

I det här fallet kommer ditt utdata att vara:

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

Oppna nu en kommandorads-textredigerare som nano och skapa en ny fil som kommer att fungera som ingångspunkt för din modul:

nano index.js

Din modul kommer att göra ett par saker. För det första kommer du att definiera en Color klass. Din Color-klass kommer att instansieras med sitt namn och sin HTML-kod. Lägg till följande rader för att skapa klassen:

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

När du nu har din datastruktur för Color lägger du till några instanser i din modul. Skriv följande markerade array till din fil:

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

Slutligt skriver du in en funktion som slumpmässigt väljer ett objekt från allColors-arrayn som du just skapat:

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

Nyckelordordet exports refererar till ett globalt objekt som finns tillgängligt i varje Node.js-modul. Alla funktioner och objekt som lagras i en moduls exports-objekt exponeras när andra Node.js-moduler importerar den. Funktionen getRandomColor() skapades till exempel direkt på exports-objektet. Du lade sedan till en allColors-egenskap till exports-objektet som refererar till den lokala konstanten allColors-array som skapades tidigare i skriptet.

När andra moduler importerar den här modulen kommer både allColors och getRandomColor() att exponeras och vara tillgängliga för användning.

Spara och avsluta filen.

Sedan dess har du skapat en modul som innehåller en array med färger och en funktion som returnerar en slumpvis. Du har också exporterat matrisen och funktionen så att externa program kan använda dem. I nästa steg kommer du att använda din modul i andra program för att visa effekterna av export.

Steg 2 – Testa din modul med REPL

Innan du bygger ett komplett program tar du en stund för att bekräfta att din modul fungerar. I det här steget kommer du att använda REPL för att ladda modulen colors. Medan du är i REPL kommer du att anropa getRandomColor()-funktionen för att se om den beter sig som du förväntar dig.

Starta Node.js REPL i samma mapp som index.js-filen:

node

När REPL har startat kommer du att se >-prompten. Detta innebär att du kan skriva in JavaScript-kod som omedelbart kommer att utvärderas. Om du vill läsa mer om detta kan du följa vår guide om hur du använder REPL.

Först skriver du följande:

colors = require('./index');

I det här kommandot laddar require() colors-modulen vid dess ingångspunkt. När du trycker på ENTER får du:

Output
{ getRandomColor: , allColors: }

Replikatorn visar oss värdet på colors, vilket är alla funktioner och objekt som importerats från index.js-filen. När du använder nyckelordet require returnerar Node.js allt innehåll i exports-objektet i en modul.

Har du kommit ihåg att du lade till getRandomColor() och allColors till exports i colors-modulen. Av den anledningen ser du dem båda i REPL när de importeras.

Testa getRandomColor()-funktionen vid prompten:

colors.getRandomColor();

Du kommer att uppmanas att välja en slumpmässig färg:

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

Då indexet är slumpmässigt kan ditt resultat variera. Nu när du har bekräftat att colors-modulen fungerar, avslutar du Node.js REPL:

.exit

Detta återvänder till din terminalkommandorad.

Du har just bekräftat att din modul fungerar som förväntat med hjälp av REPL. Nu ska du tillämpa samma koncept och ladda din modul i ett program, som du skulle göra i ett riktigt projekt.

Steg 3 – Spara din lokala modul som ett beroende

När du testade din modul i REPL:en importerade du den med en relativ sökväg. Det betyder att du använde index.jsfilens placering i förhållande till arbetskatalogen för att hämta dess innehåll. Även om detta fungerar är det vanligtvis en bättre programmeringsupplevelse att importera moduler med deras namn så att importen inte bryts när kontexten ändras. I det här steget installerar du colors-modulen med npm:s lokala modul install-funktion.

Sätt upp en ny Node.js-modul utanför mappen colors. Gå först till den tidigare katalogen och skapa en ny mapp:

 
cd ..
 
mkdir really-large-application
 

Förflytta dig nu till ditt nya projekt:

cd really-large-application

Likt med colors-modulen initialiserar du din mapp med npm:

npm init -y 

Följande package.json kommer att genereras:

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

Installera nu din colors-modul och använd flaggan --save så att den registreras i din package.json-fil:

npm install --save ../colors

Du har just installerat din colors-modul i det nya projektet. Öppna package.json-filen för att se det nya lokala beroendet:

nano package.json

Du ser att följande markerade rader har lagts till:

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

Underför filen.

Modulen colors kopierades till din katalog node_modules. Kontrollera att den finns där med följande kommando:

ls node_modules

Detta ger följande utdata:

Output
colors

Använd din installerade lokala modul i det här nya programmet. Öppna din textredigerare igen och skapa en annan JavaScript-fil:

nano index.js

Ditt program kommer först att importera modulen colors. Det kommer sedan att välja en färg slumpmässigt med hjälp av getRandomColor()-funktionen som tillhandahålls av modulen. Slutligen kommer det att skriva ut ett meddelande till konsolen som talar om för användaren vilken färg som ska användas.

Inför följande kod i 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}`);

Spara och avsluta den här filen.

Ditt program kommer nu att tala om för användaren ett slumpmässigt färgalternativ för en webbplatskomponent.

Kör det här skriptet med:

node index.js

Ditt utdata kommer att likna:

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

Du har nu installerat colors-modulen med framgång och kan hantera den som vilket annat npm-paket som helst som används i ditt projekt. Om du lägger till fler färger och funktioner till din lokala colors-modul måste du dock köra npm update i dina program för att kunna använda de nya alternativen. I nästa steg kommer du att använda den lokala modulen colors på ett annat sätt och få automatiska uppdateringar när modulens kod ändras.

Steg 4 – Länka en lokal modul

Om din lokala modul är under stark utveckling kan det vara tråkigt att kontinuerligt uppdatera paket. Ett alternativ skulle vara att länka modulerna. Att länka en modul garanterar att alla uppdateringar av modulen omedelbart återspeglas i de program som använder den.

I det här steget kommer du att länka colors-modulen till ditt program. Du kommer också att ändra colors-modulen och bekräfta att dess senaste ändringar fungerar i programmet utan att du behöver installera om eller uppgradera.

Först avinstallerar du din lokala modul:

npm un colors

npm länkar moduler med hjälp av symboliska länkar (eller symlänkar), som är referenser som pekar på filer eller kataloger i din dator. Länkning av en modul sker i två steg:

1. Skapa en global länk till modulen. npm skapar en symbolisk länk mellan din globala katalog node_modules och katalogen för din modul. Den globala node_modules-katalogen är den plats där alla dina systemövergripande npm-paket installeras (alla paket som du installerar med flaggan -g).
2. Skapa en lokal länk. npm skapar en symlänk mellan ditt lokala projekt som använder modulen och den globala länken till modulen.

Skapa först den globala länken genom att återvända till mappen colors och använda kommandot link:

 
cd ../colors
 
sudo npm link
 

När du är klar kommer din skal att ge ut:

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

Du har just skapat en symlänk i din node_modules-mapp till din colors-katalog.

Turnera tillbaka till mappen really-large-application och länka paketet:

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

Du får ett utdata som liknar följande:

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

Anmärkning: Om du vill skriva lite mindre kan du använda ln istället för link. Till exempel skulle npm ln colors ha fungerat på exakt samma sätt.

Som utmatningen visar har du just skapat en symlänk från din really-large-applications lokala katalog node_modules till symlänken colors i din globala node_modules, som pekar på den faktiska katalogen med modulen colors.

Länkningsprocessen är klar. Kör din fil för att säkerställa att den fortfarande fungerar:

node index.js

Din utdata kommer att likna:

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

Din programfunktionalitet är intakt. Testa sedan att uppdateringar tillämpas omedelbart. Öppna återigen index.js-filen i colors-modulen i din textredigerare:

 
cd ../colors
 
nano index.js
 

Nu lägger du till en funktion som väljer den allra bästa nyansen av blått som finns. Den tar inga argument och returnerar alltid den tredje posten i arrayen allColors. Lägg till dessa rader i slutet av filen:

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

Spara och avsluta filen och öppna sedan index.js-filen i mappen really-large-application igen:

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

Företa ett anrop till den nyskapade getBlue()-funktionen och skriv ut en mening med färgens egenskaper. Lägg till dessa uttalanden i slutet av filen:

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

Spara och avsluta filen.

Koden använder nu den nyskapade getBlue()-funktionen. Exekvera filen som tidigare:

node index.js

Du får utdata som:

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

Ditt skript kunde använda den senaste funktionen i din colors-modul, utan att behöva köra npm update. Detta gör det lättare att göra ändringar i den här applikationen under utvecklingen.

När du skriver större och mer komplexa applikationer, tänk på hur relaterad kod kan grupperas i moduler och hur du vill att dessa moduler ska vara uppbyggda. Om din modul bara ska användas av ett program kan den stanna inom samma projekt och refereras av en relativ sökväg. Om din modul senare kommer att delas separat eller om den finns på en helt annan plats än det projekt du arbetar med nu, kan det vara mer praktiskt att installera eller länka den. Moduler under aktiv utveckling gynnas också av de automatiska uppdateringarna av länkning. Om modulen inte är under aktiv utveckling kan det vara enklare att använda npm install.

Slutsats

I den här handledningen har du lärt dig att en Node.js-modul är en JavaScript-fil med funktioner och objekt som kan användas av andra program. Du skapade sedan en modul och kopplade dina funktioner och objekt till det globala exports-objektet för att göra dem tillgängliga för externa program. Slutligen importerade du den modulen till ett program, vilket visar hur moduler sätts samman till större program.

Nu när du vet hur man skapar moduler kan du fundera på vilken typ av program du vill skriva och dela upp det i olika komponenter, där du behåller varje unik uppsättning aktiviteter och data i sina egna moduler. Ju mer övning du får i att skriva moduler, desto bättre blir din förmåga att skriva kvalitativa Node.js-program på din inlärningsresa. Om du vill arbeta igenom ett exempel på ett Node.js-program som använder moduler kan du se vår handledning Hur man konfigurerar ett Node.js-program för produktion på Ubuntu 18.04.

.