By Leave a Comment on Hoe maak je een Node.js-module

De auteur heeft het Open Internet/Free Speech Fund geselecteerd om een donatie te ontvangen als onderdeel van het Write for DOnations-programma.

Inleiding

In Node.js is een module een verzameling JavaScript-functies en -objecten die kunnen worden gebruikt door externe toepassingen. Een stuk code omschrijven als een module verwijst minder naar wat de code is en meer naar wat het doet-elk Node.js-bestand of verzameling bestanden kan worden beschouwd als een module als de functies en gegevens ervan bruikbaar worden gemaakt voor externe programma’s.

Omdat modules eenheden van functionaliteit bieden die kunnen worden hergebruikt in veel grotere programma’s, stellen ze u in staat om losjes gekoppelde toepassingen te maken die schalen met complexiteit, en openen ze de deur voor u om uw code te delen met andere ontwikkelaars. In staat zijn om modules te schrijven die nuttige functies en gegevens exporteren, stelt je in staat om bij te dragen aan de bredere Node.js gemeenschap – in feite zijn alle pakketten die je gebruikt op npm gebundeld en gedeeld als modules. Dit maakt het maken van modules een essentiële vaardigheid voor een Node.js-ontwikkelaar.

In deze tutorial maak je een Node.js-module die suggereert welke kleur webontwikkelaars in hun ontwerpen zouden moeten gebruiken. U zult de module ontwikkelen door het opslaan van de kleuren als een array, en het verstrekken van een functie om willekeurig een op te halen. Daarna doorloopt u verschillende manieren om een module in een Node.js applicatie te importeren.

Voorwaarden

  • U heeft Node.js en npm nodig op uw ontwikkelomgeving. Deze tutorial gebruikt versie 10.17.0. Om dit op macOS of Ubuntu 18.04 te installeren, volg de stappen in Hoe Node.js te installeren en een lokale ontwikkelomgeving te maken op macOS of de Installatie met behulp van een PPA sectie van Hoe Node.js te installeren op Ubuntu 18.04. Door Node.js geïnstalleerd te hebben zul je ook npm geïnstalleerd hebben; deze tutorial gebruikt versie 6.11.3.
  • Je zou ook vertrouwd moeten zijn met het package.json bestand, en ervaring met npm commando’s zou ook nuttig zijn. Om deze ervaring op te doen, volg je How To Use Node.js Modules with npm and package.json, in het bijzonder de Stap 1 – Het creëren van een package.json File.
  • Het zal ook helpen om vertrouwd te zijn met de Node.js REPL (Read-Evaluate-Print-Loop). Je zult dit gebruiken om je module te testen. Als je hier meer informatie over nodig hebt, lees dan onze gids over Hoe de Node.js REPL te gebruiken.

Stap 1 – Het maken van een module

Deze stap leidt je door het maken van je eerste Node.js module. Uw module zal een verzameling van kleuren in een array bevatten en een functie om willekeurig een kleur te krijgen. Je gebruikt de ingebouwde exports eigenschap van Node.js om de functie en de array beschikbaar te maken voor externe programma’s.

Je begint met het bepalen van de gegevens over kleuren die je in je module gaat opslaan. Elke kleur wordt een object dat een name eigenschap bevat die mensen gemakkelijk kunnen identificeren, en een code eigenschap die een string is met een HTML-kleurcode. HTML-kleurcodes zijn zescijferige hexadecimale getallen waarmee u de kleur van elementen op een webpagina kunt wijzigen. U kunt meer te weten komen over HTML-kleurcodes door dit artikel over HTML-kleurcodes en -namen te lezen.

U beslist vervolgens welke kleuren u in uw module wilt ondersteunen. Uw module zal een array genaamd allColors bevatten die zes kleuren zal bevatten. Uw module zal ook een functie genaamd getRandomColor() bevatten die willekeurig een kleur zal selecteren uit uw array en deze zal retourneren.

In uw terminal, maak een nieuwe map genaamd colors en verplaats deze:

     
  • mkdir colors
    •  
  • cd colors
    •

Initialiseer npm zodat andere programma’s deze module later in de tutorial kunnen importeren:

  • npm init -y

U gebruikte de -y vlag om de gebruikelijke prompts over te slaan om uw package.json aan te passen. Als dit een module was die je wilde publiceren naar npm, zou je al deze prompts beantwoorden met relevante gegevens, zoals uitgelegd in How To Use Node.js Modules with npm and package.json.

In dit geval zal je uitvoer zijn:

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

Nu, open een command-line teksteditor zoals nano en maak een nieuw bestand dat als ingang voor je module dient:

  • nano index.js

Jouw module zal een paar dingen doen. Ten eerste zult u een Color klasse definiëren. Uw Color klasse zal worden geïnstantieerd met zijn naam en HTML code. Voeg de volgende regels toe om de klasse te maken:

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

Nu je je datastructuur voor Color hebt, voeg je een aantal instanties toe aan je module. Schrijf de volgende gemarkeerde array in je bestand:

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

Tot slot, voer een functie in die willekeurig een item selecteert uit de allColors array die je zojuist hebt gemaakt:

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

Het exports sleutelwoord verwijst naar een globaal object dat beschikbaar is in elke Node.js module. Alle functies en objecten die zijn opgeslagen in het exports-object van een module worden blootgesteld wanneer andere Node.js-modules deze importeren. De getRandomColor() functie is bijvoorbeeld direct op het exports object gemaakt. U voegde vervolgens een allColors eigenschap toe aan het exports object dat verwijst naar de lokale constante allColors array eerder in het script gemaakt.

Wanneer andere modules deze module importeren, zullen zowel allColors als getRandomColor() worden blootgesteld en beschikbaar zijn voor gebruik.

Bewaar en sluit het bestand af.

Dusver hebt u een module gemaakt die een array van kleuren bevat en een functie die er willekeurig een retourneert. Je hebt ook de array en de functie geëxporteerd, zodat externe programma’s ze kunnen gebruiken. In de volgende stap gaat u uw module in andere toepassingen gebruiken om de effecten van export te demonstreren.

Stap 2 – Testen van uw module met de REPL

Voordat u een complete applicatie bouwt, neemt u even de tijd om te bevestigen dat uw module werkt. In deze stap zult u de REPL gebruiken om de colors module te laden. In de REPL roept u de getRandomColor() functie op om te zien of deze zich gedraagt zoals u verwacht.

Start de Node.js REPL in dezelfde map als het index.js bestand:

  • node

Wanneer de REPL is gestart, zult u de > prompt zien. Dit betekent dat u JavaScript code kunt invoeren die onmiddellijk geëvalueerd zal worden. Wilt u hier meer over lezen, volg dan onze handleiding over het gebruik van de REPL.

Voer eerst het volgende in:

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

In dit commando laadt require() de colors module op zijn startpunt. Wanneer u op ENTER drukt, krijgt u:

Output
{ getRandomColor: , allColors: }

De REPL toont ons de waarde van colors, dat zijn alle functies en objecten die zijn geïmporteerd uit het index.js bestand. Wanneer u het require sleutelwoord gebruikt, retourneert Node.js alle inhoud binnen het exports object van een module.

Vertel dat u getRandomColor() en allColors hebt toegevoegd aan exports in de colors module. Daarom ziet u ze beide in de REPL als ze worden geïmporteerd.

Test op de prompt de getRandomColor() functie:

  • colors.getRandomColor();

U wordt gevraagd met een willekeurige kleur:

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

Omdat de index willekeurig is, kan uw uitvoer variëren. Nu je hebt bevestigd dat de colors module werkt, verlaat je de Node.js REPL:

  • .exit

Dit brengt je terug naar je terminal command line.

Je hebt zojuist bevestigd dat je module werkt zoals verwacht met behulp van de REPL. Nu gaat u dezelfde concepten toepassen en uw module in een toepassing laden, zoals u in een echt project zou doen.

Stap 3 – Uw lokale module als afhankelijkheid opslaan

Tijdens het testen van uw module in de REPL, hebt u deze geïmporteerd met een relatief pad. Dit betekent dat u de locatie van het index.js bestand gebruikte in relatie tot de werkdirectory om de inhoud te krijgen. Hoewel dit werkt, is het meestal een betere programmeer ervaring om modules te importeren met hun naam zodat de import niet verbroken wordt wanneer de context veranderd wordt. In deze stap installeert u de colors module met npm’s lokale module install functie.

Opzetten van een nieuwe Node.js module buiten de colors map. Ga eerst naar de vorige map en maak een nieuwe map:

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

Stap nu in uw nieuwe project:

  • cd really-large-application

Net als met de colors module, initialiseer uw map met npm:

  • npm init -y

De volgende package.json zal worden gegenereerd:

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

Nu, installeer uw colors module en gebruik de --save vlag zodat het zal worden opgenomen in uw package.json bestand:

  • npm install --save ../colors

U heeft zojuist uw colors module geïnstalleerd in het nieuwe project. Open het package.json bestand om de nieuwe lokale afhankelijkheid te zien:

  • nano package.json

U zult zien dat de volgende gemarkeerde regels zijn toegevoegd:

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

Verlaat het bestand.

De colors module is gekopieerd naar uw node_modules directory. Controleer of hij daar staat met het volgende commando:

  • ls node_modules

Dit zal de volgende uitvoer geven:

Output
colors

Gebruik uw geïnstalleerde lokale module in dit nieuwe programma. Open uw tekst editor opnieuw en maak een ander JavaScript bestand:

  • nano index.js

Uw programma zal eerst de colors module importeren. Vervolgens kiest het een willekeurige kleur met behulp van de functie getRandomColor() die door de module wordt geleverd. Tenslotte zal het een bericht naar de console sturen dat de gebruiker vertelt welke kleur hij moet gebruiken.

Voer de volgende code in 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}`);

Bewaar en sluit dit bestand af.

Uw applicatie vertelt de gebruiker nu een willekeurige kleuroptie voor een website component.

Run dit script met:

  • node index.js

Uw uitvoer zal vergelijkbaar zijn met:

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

U hebt nu met succes de colors module geïnstalleerd en kunt het beheren zoals elk ander npm pakket dat in uw project wordt gebruikt. Als u echter meer kleuren en functies aan uw lokale colors module zou toevoegen, zou u npm update in uw toepassingen moeten uitvoeren om de nieuwe opties te kunnen gebruiken. In de volgende stap zult u de lokale module colors op een andere manier gebruiken en automatische updates krijgen wanneer de module code verandert.

Stap 4 – Een lokale module koppelen

Als uw lokale module in zware ontwikkeling is, kan het voortdurend bijwerken van packages vervelend zijn. Een alternatief zou zijn om de modules te linken. Het koppelen van een module zorgt ervoor dat alle updates van de module onmiddellijk worden weergegeven in de toepassingen die de module gebruiken.

In deze stap koppelt u de colors module aan uw applicatie. U zult ook de colors module wijzigen en bevestigen dat de meest recente wijzigingen werken in de toepassing zonder opnieuw te installeren of te upgraden.

Installeer eerst uw lokale module:

  • npm un colors

npm koppelt modules door gebruik te maken van symbolische links (of symlinks), dat zijn verwijzingen die verwijzen naar bestanden of mappen in uw computer. Het linken van een module gebeurt in twee stappen:

  1. Het maken van een globale link naar de module. npm maakt een symlink tussen uw globale node_modules directory en de directory van uw module. De globale node_modules directory is de locatie waar al uw systeembrede npm pakketten zijn geïnstalleerd (elk pakket dat u installeert met de -g vlag).
  2. Maak een lokale link. npm maakt een symlink tussen uw lokale project dat de module gebruikt en de globale link van de module.

Maak eerst de globale link door terug te keren naar de colors map en gebruik het link commando:

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

Als het klaar is, zal uw shell output geven:

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

U heeft zojuist een symlink gemaakt in uw node_modules map naar uw colors map.

Keer terug naar de really-large-application map en koppel het pakket:

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

U krijgt uitvoer vergelijkbaar met de volgende:

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

Note: Als u wat minder wilt typen, kunt u ln gebruiken in plaats van link. npm ln colors zou bijvoorbeeld precies hetzelfde hebben gewerkt.

Zoals de uitvoer laat zien, hebt u zojuist een symlink gemaakt van uw really-large-application’s lokale node_modules directory naar de colors symlink in uw globale node_modules, die wijst naar de daadwerkelijke directory met de colors module.

Het linking proces is voltooid. Voer uw bestand uit om er zeker van te zijn dat het nog werkt:

  • node index.js

Uw uitvoer zal vergelijkbaar zijn met:

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

Uw programma functionaliteit is intact. Test vervolgens of updates onmiddellijk worden toegepast. Open in uw tekstverwerker opnieuw het index.js bestand in de colors module:

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

Nu voegt u een functie toe die de allerbeste kleur blauw selecteert die er bestaat. De functie neemt geen argumenten, en geeft altijd het derde item van de allColors array terug. Voeg deze regels toe aan het eind van het bestand:

~/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;}

Bewaar en verlaat het bestand, open dan het index.js bestand in de really-large-application map opnieuw:

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

Roep de nieuw aangemaakte getBlue() functie aan, en print een zin met de eigenschappen van de kleur. Voeg deze statements toe aan het eind van het bestand:

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

Bewaar en sluit het bestand af.

De code gebruikt nu de nieuw aangemaakte getBlue() functie. Voer het bestand uit zoals voorheen:

  • node index.js

U krijgt uitvoer zoals:

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

Uw script was in staat om de nieuwste functie in uw colors module te gebruiken, zonder npm update te hoeven uitvoeren. Dit maakt het gemakkelijker om wijzigingen aan te brengen in deze toepassing tijdens de ontwikkeling.

Als u grotere en meer complexe toepassingen schrijft, denk dan na over hoe gerelateerde code kan worden gegroepeerd in modules, en hoe u wilt dat deze modules worden opgezet. Als uw module slechts door één programma zal worden gebruikt, kan deze binnen hetzelfde project blijven en door een relatief pad worden verwezen. Als uw module later apart gedeeld zal worden of op een heel andere plaats staat dan het project waar u nu aan werkt, dan is installeren of linken misschien meer haalbaar. Modules in actieve ontwikkeling profiteren ook van de automatische updates van het linken. Als de module niet in actieve ontwikkeling is, kan het gebruik van npm install de eenvoudigere optie zijn.

Conclusie

In deze tutorial heb je geleerd dat een Node.js module een JavaScript bestand is met functies en objecten die door andere programma’s gebruikt kunnen worden. Vervolgens hebt u een module gemaakt en uw functies en objecten aan het globale exports-object gekoppeld om ze beschikbaar te maken voor externe programma’s. Tenslotte heb je die module in een programma geïmporteerd, waarmee je hebt laten zien hoe modules samen grotere toepassingen vormen.

Nu je weet hoe je modules maakt, denk je na over het type programma dat je wilt schrijven en splits je het op in verschillende onderdelen, waarbij je elke unieke set van activiteiten en gegevens in hun eigen modules bewaart. Hoe meer oefening je krijgt in het schrijven van modules, hoe beter je in staat bent om kwalitatieve Node.js programma’s te schrijven tijdens je leerreis. Om door een voorbeeld van een Node.js applicatie te werken die modules gebruikt, zie onze Hoe een Node.js applicatie opzetten voor productie op Ubuntu 18.04 tutorial.

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd.