By Leave a Comment on Sådan oprettes et Node.js-modul

Forfatteren har valgt Open Internet/Free Speech Fund til at modtage en donation som en del af Write for DOnations-programmet.

Indledning

I Node.js er et modul en samling af JavaScript-funktioner og -objekter, som kan bruges af eksterne programmer. At beskrive et stykke kode som et modul henviser mindre til, hvad koden er, og mere til, hvad den gør – enhver Node.js-fil eller samling af filer kan betragtes som et modul, hvis dens funktioner og data gøres anvendelige for eksterne programmer.

Da moduler giver enheder af funktionalitet, der kan genbruges i mange større programmer, giver de dig mulighed for at oprette løst koblede programmer, der skaleres med kompleksiteten, og de åbner døren for, at du kan dele din kode med andre udviklere. Hvis du er i stand til at skrive moduler, der eksporterer nyttige funktioner og data, kan du bidrage til det bredere Node.js-fællesskab – faktisk er alle pakker, du bruger på npm, blevet bundtet og delt som moduler. Dette gør det til en vigtig færdighed for en Node.js-udvikler at skabe moduler.

I denne vejledning skal du oprette et Node.js-modul, der foreslår, hvilken farve webudviklere bør bruge i deres design. Du vil udvikle modulet ved at lagre farverne som et array og levere en funktion til at hente en tilfældigt. Derefter gennemgår du forskellige måder at importere et modul i et Node.js-program på.

Forudsætninger

  • Du skal have Node.js og npm installeret på dit udviklingsmiljø. Denne vejledning bruger version 10.17.0. Hvis du vil installere dette på macOS eller Ubuntu 18.04, skal du følge trinene i Sådan installeres Node.js og oprettes et lokalt udviklingsmiljø på macOS eller i afsnittet Installering ved hjælp af en PPA i Sådan installeres Node.js på Ubuntu 18.04. Ved at have Node.js installeret vil du også have npm installeret; denne vejledning bruger version 6.11.3.
  • Du bør også være bekendt med package.json-filen, og erfaring med npm-kommandoer vil også være nyttig. For at få denne erfaring skal du følge How To Use Node.js Modules with npm and package.json, især trin 1 – Creating a package.json File.
  • Det vil også være en hjælp at være fortrolig med Node.js REPL (Read-Evaluate-Print-Loop). Du vil bruge dette til at teste dit modul. Hvis du har brug for flere oplysninger om dette, kan du læse vores vejledning om hvordan du bruger Node.js REPL.

Strin 1 – Oprettelse af et modul

Dette trin vil guide dig gennem oprettelsen af dit første Node.js-modul. Dit modul vil indeholde en samling af farver i et array og give en funktion til at hente en tilfældig farve. Du vil bruge den indbyggede exports-egenskab i Node.js til at gøre funktionen og arrayet tilgængelige for eksterne programmer.

Først skal du begynde med at beslutte, hvilke data om farver du vil gemme i dit modul. Hver farve vil være et objekt, der indeholder en name-egenskab, som mennesker let kan identificere, og en code-egenskab, der er en streng, som indeholder en HTML-farvekode. HTML-farvekoder er sekscifrede hexadecimale tal, som giver dig mulighed for at ændre farven på elementer på en webside. Du kan få mere at vide om HTML-farvekoder ved at læse denne artikel om HTML-farvekoder og -navne.

Derpå beslutter du, hvilke farver du vil understøtte i dit modul. Dit modul vil indeholde et array kaldet allColors, der vil indeholde seks farver. Dit modul vil også indeholde en funktion kaldet getRandomColor(), der tilfældigt vil vælge en farve fra dit array og returnere den.

I din terminal skal du lave en ny mappe kaldet colors og flytte ind i den:

     
  • mkdir colors
    •  
  • cd colors
    •

Initialiser npm, så andre programmer kan importere dette modul senere i tutorialen:

  • npm init -y

Du brugte -y-flaget til at springe de sædvanlige opfordringer til at tilpasse din package.json over. Hvis dette var et modul, du ønskede at udgive til npm, ville du besvare alle disse opfordringer med relevante data, som forklaret i Sådan bruger du Node.js-moduler med npm og package.json.

I dette tilfælde vil dit output være:

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

Åbn nu en kommandolinje-teksteditor som nano og opret en ny fil, der skal fungere som indgangspunkt for dit modul:

  • nano index.js

Dit modul vil gøre et par ting. For det første vil du definere en Color-klasse. Din Color-klasse vil blive instantieret med dens navn og HTML-kode. Tilføj følgende linjer for at oprette klassen:

~/colors/index.js
class Color { constructor(name, code) { this.name = name; this.code = code; }}

Nu, hvor du har din datastruktur for Color, skal du tilføje nogle instanser i dit modul. Skriv følgende fremhævede array til din fil:

~/colors/index.js
class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;

Til sidst skal du indtaste en funktion, der tilfældigt vælger et element fra det allColors array, du lige har oprettet:

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

Nøgleordet exports refererer til et globalt objekt, der er tilgængeligt i alle Node.js-moduler. Alle funktioner og objekter, der er gemt i et moduls exports-objekt, er eksponeret, når andre Node.js-moduler importerer det. Funktionen getRandomColor() blev f.eks. oprettet direkte på exports-objektet. Du tilføjede derefter en allColors-egenskab til exports-objektet, der refererer til det lokale konstante allColors-array, der blev oprettet tidligere i scriptet.

Når andre moduler importerer dette modul, vil både allColors og getRandomColor() blive eksponeret og være tilgængelige til brug.

Spar og afslut filen.

Så vidt har du oprettet et modul, der indeholder et array af farver og en funktion, der returnerer en tilfældig. Du har også eksporteret arrayet og funktionen, så eksterne programmer kan bruge dem. I det næste trin vil du bruge dit modul i andre programmer for at demonstrere virkningerne af export.

Strin 2 – Test af dit modul med REPL

Hvor du bygger et komplet program, skal du tage et øjeblik for at bekræfte, at dit modul fungerer. I dette trin skal du bruge REPL til at indlæse modulet colors. Mens du er i REPL, kalder du getRandomColor()-funktionen for at se, om den opfører sig, som du forventer det.

Start Node.js REPL i samme mappe som index.js-filen:

  • node

Når REPL’en er startet, vises >-prompten. Det betyder, at du kan indtaste JavaScript-kode, som vil blive evalueret med det samme. Hvis du vil læse mere om dette, kan du følge vores vejledning om brug af REPL.

Først skal du indtaste følgende:

  • colors = require('./index');

I denne kommando indlæser require() colors-modulet ved dets indgangspunkt. Når du trykker på ENTER, får du:

Output
{ getRandomColor: , allColors: }

REPL viser os værdien af colors, som er alle de funktioner og objekter, der er importeret fra index.js-filen. Når du bruger nøgleordet require, returnerer Node.js alt indholdet inden for exports-objektet i et modul.

Husk, at du tilføjede getRandomColor() og allColors til exports i colors-modulet. Derfor kan du se dem begge i REPL’en, når de er importeret.

Test getRandomColor()-funktionen ved prompten:

  • colors.getRandomColor();

Du vil blive bedt om at vælge en tilfældig farve:

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

Da indekset er tilfældigt, kan dit output variere. Nu hvor du har bekræftet, at colors-modulet fungerer, skal du afslutte Node.js REPL:

  • .exit

Dette returnerer dig til din terminalkommandolinje.

Du har netop bekræftet, at dit modul fungerer som forventet ved hjælp af REPL’en. Nu skal du anvende de samme koncepter og indlæse dit modul i et program, som du ville gøre i et rigtigt projekt.

Stræk 3 – Gem dit lokale modul som en afhængighed

Mens du testede dit modul i REPL’en, importerede du det med en relativ sti. Det betyder, at du brugte placeringen af index.js-filen i forhold til arbejdskataloget for at hente dens indhold. Selv om dette fungerer, er det normalt en bedre programmeringsoplevelse at importere moduler ved deres navne, så importen ikke afbrydes, når konteksten ændres. I dette trin installerer du colors-modulet med npm’s lokale modul install-funktion.

Sæt et nyt Node.js-modul op uden for colors-mappen. Gå først til den tidligere mappe, og opret en ny mappe:

     
  • cd ..
    •  
  • mkdir really-large-application
    •

Før nu ind i dit nye projekt:

  • cd really-large-application

Som med colors-modulet skal du initialisere din mappe med npm:

  • npm init -y

Der vil blive genereret følgende 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"}

Installer nu dit colors-modul og brug --save-flaget, så det bliver registreret i din package.json-fil:

  • npm install --save ../colors

Du har netop installeret dit colors-modul i det nye projekt. Åbn package.json-filen for at se den nye lokale afhængighed:

  • nano package.json

Du vil se, at følgende fremhævede linjer er blevet tilføjet:

~/really-large-application/package.json
{ "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" }}

Afslut filen.

Det colors modul blev kopieret til din node_modules mappe. Kontroller, at det er der med følgende kommando:

  • ls node_modules

Dette vil give følgende output:

Output
colors

Brug dit installerede lokale modul i dette nye program. Åbn din teksteditor igen, og opret en anden JavaScript-fil:

  • nano index.js

Dit program vil først importere colors-modulet. Det vil derefter vælge en tilfældig farve ved hjælp af getRandomColor()-funktionen, der leveres af modulet. Til sidst vil det udskrive en meddelelse til konsollen, der fortæller brugeren, hvilken farve der skal bruges.

Indtast følgende kode i index.js:

~/really-large-application/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}`);

Spar og afslut denne fil.

Din applikation fortæller nu brugeren en tilfældig farveindstilling for en webstedsdel.

Kør dette script med:

  • node index.js

Din output vil ligne:

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

Du har nu med succes installeret colors-modulet og kan håndtere det som enhver anden npm-pakke, der bruges i dit projekt. Hvis du imidlertid tilføjede flere farver og funktioner til dit lokale colors-modul, skal du køre npm update i dine programmer for at kunne bruge de nye muligheder. I næste trin vil du bruge det lokale modul colors på en anden måde og få automatiske opdateringer, når modulets kode ændres.

Strin 4 – Sammenkobling af et lokalt modul

Hvis dit lokale modul er under kraftig udvikling, kan det være kedeligt at opdatere pakker hele tiden. Et alternativ ville være at linke modulerne. Ved at linke et modul sikres det, at alle opdateringer til modulet straks afspejles i de programmer, der bruger det.

I dette trin skal du linke colorsmodulet til dit program. Du ændrer også colors-modulet og bekræfter, at dets seneste ændringer fungerer i programmet uden at skulle geninstallere eller opgradere.

Først skal du afinstallere dit lokale modul:

  • npm un colors

npm linker moduler ved hjælp af symbolske links (eller symlinks), som er henvisninger, der peger på filer eller mapper på din computer. Linkning af et modul sker i to trin:

  1. Skabelse af et globalt link til modulet. npm opretter et symbolsk link mellem din globale node_modules-mappe og mappen med dit modul. Den globale node_modules-mappe er den placering, hvor alle dine systemdækkende npm-pakker er installeret (alle pakker, du installerer med -g-flaget).
  2. Opret et lokalt link. npm opretter et symlink mellem dit lokale projekt, der bruger modulet, og modulets globale link.

Opret først det globale link ved at vende tilbage til mappen colors og bruge kommandoen link:

     
  • cd ../colors
    •  
  • sudo npm link
    •

Når du er færdig, vil din shell udsende:

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

Du har netop oprettet et symbolsk link i din node_modules-mappe til din colors-mappe.

Vend tilbage til mappen really-large-application og link pakken:

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

Du vil modtage output svarende til følgende:

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

Bemærk: Hvis du gerne vil skrive lidt mindre, kan du bruge ln i stedet for link. For eksempel ville npm ln colors have virket på nøjagtig samme måde.

Som det fremgår af outputtet, har du netop oprettet et symlink fra din really-large-applications lokale node_modules-mappe til colors-symlinket i din globale node_modules, som peger på den faktiske mappe med colors-modulet.

Linkningsprocessen er afsluttet. Kør din fil for at sikre, at den stadig fungerer:

  • node index.js

Din output vil ligne:

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

Din programfunktionalitet er intakt. Test dernæst, at opdateringer anvendes straks. Åbn igen index.js-filen i colors-modulet i din teksteditor:

     
  • cd ../colors
    •  
  • nano index.js
    •

Føj nu en funktion til, der vælger den allerbedste blå nuance, der findes. Den tager ingen argumenter og returnerer altid det tredje element i arrayet allColors. Tilføj disse linjer til slutningen af filen:

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

Spar og afslut filen, og åbn derefter filen index.js i mappen really-large-application igen:

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

Før et kald til den nyoprettede getBlue()-funktion, og udskriv en sætning med farvens egenskaber. Tilføj disse sætninger til slutningen af filen:

~/really-large-application/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}`);const favoriteColor = colors.getBlue();console.log(`My favorite color is ${favoriteColor.name}/${favoriteColor.code}, btw`);

Spar og afslut filen.

Koden bruger nu den nyoprettede getBlue()-funktion. Kør filen som før:

  • node index.js

Du får output som:

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

Dit script var i stand til at bruge den nyeste funktion i dit colors-modul uden at skulle køre npm update. Dette vil gøre det lettere at foretage ændringer i dette program under udviklingen.

Når du skriver større og mere komplekse programmer, skal du tænke over, hvordan relateret kode kan grupperes i moduler, og hvordan du ønsker, at disse moduler skal være opbygget. Hvis dit modul kun skal bruges af ét program, kan det forblive inden for det samme projekt og refereres af en relativ sti. Hvis dit modul senere skal deles separat eller findes på et helt andet sted end det projekt, du arbejder på nu, er det måske mere hensigtsmæssigt at installere eller linke det. Moduler under aktiv udvikling har også fordel af de automatiske opdateringer ved linking. Hvis modulet ikke er under aktiv udvikling, kan det være den nemmere løsning at bruge npm install.

Slutning

I denne vejledning har du lært, at et Node.js-modul er en JavaScript-fil med funktioner og objekter, der kan bruges af andre programmer. Du oprettede derefter et modul og knyttede dine funktioner og objekter til det globale exports objekt for at gøre dem tilgængelige for eksterne programmer. Endelig importerede du dette modul til et program og demonstrerede dermed, hvordan moduler samles i større programmer.

Nu, hvor du ved, hvordan man opretter moduler, skal du tænke på den type program, du vil skrive, og dele det op i forskellige komponenter, idet du beholder hvert unikt sæt af aktiviteter og data i deres egne moduler. Jo mere øvelse du får i at skrive moduler, jo bedre bliver din evne til at skrive Node.js programmer af høj kvalitet på din læringsrejse. Hvis du vil gennemgå et eksempel på et Node.js-program, der bruger moduler, kan du se vores vejledning Sådan konfigurerer du et Node.js-program til produktion på Ubuntu 18.04.

.

Skriv et svar

Din e-mailadresse vil ikke blive publiceret.