Node.js
Exportera och konsumera moduler
Sök…
Anmärkningar
Medan allt i Node.js vanligtvis görs asynkront, require() inte en av dessa saker. Eftersom moduler i praktiken bara behöver laddas en gång är det en blockeringsoperation och bör användas korrekt.
Modulerna cachelagras efter första gången de laddas. Om du redigerar en modul under utveckling måste du ta bort dess post i modulen cache för att använda nya ändringar. Med det sagt, även om en modul rensas ur modulcachen, är själva modulen inte skräp som samlas in, så man bör se till att den används i produktionsmiljöer.
Laddar och använder en modul
En modul kan "importeras" eller på annat sätt "krävs" med funktionen require() . För att till exempel ladda http modulen som skickas med Node.js kan följande användas:
const http = require('http');
Förutom moduler som levereras med körtiden kan du också kräva moduler som du har installerat från npm, till exempel express. Om du redan hade installerat express på ditt system via npm install express , kan du helt enkelt skriva:
const express = require('express');
Du kan också inkludera moduler som du själv har skrivit som en del av din ansökan. I det här fallet för att inkludera en fil med namnet lib.js i samma katalog som den aktuella filen:
const mylib = require('./lib');
Observera att du kan utelämna tillägget och .js antas. När du laddar en modul fylls variabeln med ett objekt som innehåller metoder och egenskaper publicerade från den önskade filen. Ett fullständigt exempel:
const http = require('http');
// The `http` module has the property `STATUS_CODES`
console.log(http.STATUS_CODES[404]); // outputs 'Not Found'
// Also contains `createServer()`
http.createServer(function(req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write('<html><body>Module Test</body></html>');
res.end();
}).listen(80);
Skapa en hello-world.js-modul
Noden tillhandahåller gränssnittet module.exports för att exponera funktioner och variabler för andra filer. Det enklaste sättet att göra det är att exportera endast ett objekt (funktion eller variabel), som visas i det första exemplet.
hello-world.js
module.exports = function(subject) {
console.log('Hello ' + subject);
};
Om vi inte vill att hela exporten ska vara ett enda objekt kan vi exportera funktioner och variabler som egenskaper för exports . De tre följande exemplen visar alla på något olika sätt:
- hallo-venus.js: funktionsdefinitionen görs separat och läggs sedan till som en egenskap för
module.exports - hallo-jupiter.js: funktionsdefinitionerna sätts direkt som värdet på egenskaperna för
module.exports - hello-mars.js: funktionsdefinitionen förklaras direkt som en egenskap av
exportsvilket är en kortversion avmodule.exports
hello-venus.js
function hello(subject) {
console.log('Venus says Hello ' + subject);
}
module.exports = {
hello: hello
};
hello-jupiter.js
module.exports = {
hello: function(subject) {
console.log('Jupiter says hello ' + subject);
},
bye: function(subject) {
console.log('Jupiter says goodbye ' + subject);
}
};
hello-mars.js
exports.hello = function(subject) {
console.log('Mars says Hello ' + subject);
};
Laddar modul med katalognamn
Vi har en katalog som heter hello som innehåller följande filer:
index.js
// hello/index.js
module.exports = function(){
console.log('Hej');
};
main.js
// hello/main.js
// We can include the other files we've defined by using the `require()` method
var hw = require('./hello-world.js'),
hm = require('./hello-mars.js'),
hv = require('./hello-venus.js'),
hj = require('./hello-jupiter.js'),
hu = require('./index.js');
// Because we assigned our function to the entire `module.exports` object, we
// can use it directly
hw('World!'); // outputs "Hello World!"
// In this case, we assigned our function to the `hello` property of exports, so we must
// use that here too
hm.hello('Solar System!'); // outputs "Mars says Hello Solar System!"
// The result of assigning module.exports at once is the same as in hello-world.js
hv.hello('Milky Way!'); // outputs "Venus says Hello Milky Way!"
hj.hello('Universe!'); // outputs "Jupiter says hello Universe!"
hj.bye('Universe!'); // outputs "Jupiter says goodbye Universe!"
hu(); //output 'hej'
Invaliderar modulcachen
Under utveckling kan du upptäcka att användning av require() på samma modul flera gånger alltid returnerar samma modul, även om du har gjort ändringar i den filen. Detta beror på att moduler cachas första gången de laddas och eventuella efterföljande modulbelastningar laddas från cachen.
För att komma runt det här problemet måste du ta delete posten i cachen. Om du till exempel laddat en modul:
var a = require('./a');
Du kan sedan ta bort cacheposten:
var rpath = require.resolve('./a.js');
delete require.cache[rpath];
Och kräva sedan modulen igen:
var a = require('./a');
Observera att detta inte rekommenderas vid produktion eftersom delete bara tar bort referensen till den laddade modulen, inte själva laddade data. Modulen samlas inte in skräp, så felaktig användning av denna funktion kan leda till läckande minne.
Bygg dina egna moduler
Du kan också referera till ett objekt för att exportera offentligt och kontinuerligt lägga till metoder till det objektet:
const auth = module.exports = {}
const config = require('../config')
const request = require('request')
auth.email = function (data, callback) {
// Authenticate with an email address
}
auth.facebook = function (data, callback) {
// Authenticate with a Facebook account
}
auth.twitter = function (data, callback) {
// Authenticate with a Twitter account
}
auth.slack = function (data, callback) {
// Authenticate with a Slack account
}
auth.stack_overflow = function (data, callback) {
// Authenticate with a Stack Overflow account
}
För att använda något av dessa kräver du bara modulen som du normalt skulle göra:
const auth = require('./auth')
module.exports = function (req, res, next) {
auth.facebook(req.body, function (err, user) {
if (err) return next(err)
req.user = user
next()
})
}
Varje modul injiceras endast en gång
NodeJS kör modulen bara första gången du behöver den. Eventuella ytterligare funktioner som krävs kommer att använda samma objekt igen, så att koden inte körs i modulen en annan gång. Node cachar också modulerna första gången de laddas med hjälp av kräver. Detta minskar antalet filläsningar och hjälper till att påskynda applikationen.
myModule.js
console.log(123) ;
exports.var1 = 4 ;
index.js
var a=require('./myModule') ; // Output 123
var b=require('./myModule') ; // No output
console.log(a.var1) ; // Output 4
console.log(b.var1) ; // Output 4
a.var2 = 5 ;
console.log(b.var2) ; // Output 5
Laddning av modulen från node_moduler
Moduler kan require d utan att använda relativa vägar genom att lägga dem i en speciell katalog som heter node_modules .
Till exempel, för att require en modul som heter foo från en index.js , kan du använda följande katalogstruktur:
index.js
\- node_modules
\- foo
|- foo.js
\- package.json
Moduler ska placeras i en katalog, tillsammans med en package.json fil. Den main området för package.json filen ska peka på startpunkt för din modul - är detta den fil som importeras när användarna require('your-module') . main standardvärdena för index.js om de inte tillhandahålls. Alternativt kan du hänvisa till filer i förhållande till din modul genom att bara lägga till den relativa sökvägen till det require samtalet: require('your-module/path/to/file') .
Moduler kan också require d från node_modules kataloger upp filsystemhierarkin. Om vi har följande katalogstruktur:
my-project
\- node_modules
|- foo // the foo module
\- ...
\- baz // the baz module
\- node_modules
\- bar // the bar module
vi kommer att kunna require modulen foo från alla filer inom bar med require('foo') .
Observera att noden bara matchar den modul som är närmast filen i filsystemhierarkin, från och med (filens aktuella katalog / node_moduler). Noden matchar kataloger på detta sätt upp till filsystemroten.
Du kan antingen installera nya moduler från npm-registret eller andra npm-register, eller göra dina egna.
Mapp som modul
Moduler kan delas över många .js-filer i samma mapp. Ett exempel i en my_module- mapp:
function_one.js
module.exports = function() {
return 1;
}
function_two.js
module.exports = function() {
return 2;
}
index.js
exports.f_one = require('./function_one.js');
exports.f_two = require('./function_two.js');
En modul som denna används genom att hänvisa till den med mappnamnet:
var split_module = require('./my_module');
Observera att om du krävde det genom att utelämna ./ eller någon indikation på en sökväg till en mapp från argumentfunktionen kräver, kommer Node att försöka ladda en modul från mappen node_modules .
Alternativt kan du skapa i samma mapp en package.json fil med följande innehåll:
{
"name": "my_module",
"main": "./your_main_entry_point.js"
}
På det här sättet behöver du inte namnge huvudmodulfilen "index".