Node.js
Exportation et consommation de modules
Recherche…
Remarques
Alors que tout dans Node.js est généralement effectué de manière asynchrone, require() ne fait pas partie de ces choses. Dans la pratique, les modules ne doivent être chargés qu'une seule fois, il s'agit d'une opération de blocage qui doit être utilisée correctement.
Les modules sont mis en cache après la première fois qu'ils sont chargés. Si vous modifiez un module en développement, vous devrez supprimer son entrée dans le cache du module pour pouvoir utiliser les nouvelles modifications. Cela étant dit, même si un module est effacé du cache du module, le module lui-même n'est pas récupéré, il convient donc de veiller à son utilisation dans les environnements de production.
Chargement et utilisation d'un module
Un module peut être "importé" ou "requis" par la fonction require() . Par exemple, pour charger le module http fourni avec Node.js, vous pouvez utiliser les éléments suivants:
const http = require('http');
Outre les modules fournis avec le runtime, vous pouvez également exiger des modules installés à partir de npm, tels qu'express. Si vous avez déjà installé express sur votre système via npm install express , vous pouvez simplement écrire:
const express = require('express');
Vous pouvez également inclure des modules que vous avez écrits vous-même dans le cadre de votre application. Dans ce cas, pour inclure un fichier nommé lib.js dans le même répertoire que le fichier actuel:
const mylib = require('./lib');
Notez que vous pouvez omettre l'extension et que .js sera .js . Une fois que vous avez chargé un module, la variable est remplie avec un objet qui contient les méthodes et les propriétés publiées à partir du fichier requis. Un exemple complet:
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);
Créer un module hello-world.js
Node fournit l'interface module.exports pour exposer les fonctions et les variables à d'autres fichiers. La manière la plus simple de le faire est d'exporter un seul objet (fonction ou variable), comme indiqué dans le premier exemple.
bonjour-world.js
module.exports = function(subject) {
console.log('Hello ' + subject);
};
Si nous ne voulons pas que l'exportation entière soit un objet unique, nous pouvons exporter des fonctions et des variables en tant que propriétés de l'objet d' exports . Les trois exemples suivants le démontrent tous de manière légèrement différente:
- hello-venus.js: la définition de la fonction est faite séparément puis ajoutée en tant que propriété de
module.exports - hello-jupiter.js: les définitions de fonctions sont directement définies comme la valeur des propriétés de
module.exports - hello-mars.js: la définition de la fonction est directement déclarée comme une propriété des
exportsqui est une version courte demodule.exports
hello-venus.js
function hello(subject) {
console.log('Venus says Hello ' + subject);
}
module.exports = {
hello: hello
};
bonjour-jupiter.js
module.exports = {
hello: function(subject) {
console.log('Jupiter says hello ' + subject);
},
bye: function(subject) {
console.log('Jupiter says goodbye ' + subject);
}
};
bonjour-mars.js
exports.hello = function(subject) {
console.log('Mars says Hello ' + subject);
};
Module de chargement avec nom de répertoire
Nous avons un répertoire nommé hello qui inclut les fichiers suivants:
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'
Invalider le cache du module
En développement, vous pouvez constater que l'utilisation de require() sur le même module plusieurs fois renvoie toujours le même module, même si vous avez apporté des modifications à ce fichier. Cela est dû au fait que les modules sont mis en cache la première fois qu'ils sont chargés et que tous les chargements ultérieurs de module sont chargés à partir du cache.
Pour contourner ce problème, vous devrez delete l'entrée dans le cache. Par exemple, si vous avez chargé un module:
var a = require('./a');
Vous pouvez ensuite supprimer l'entrée de cache:
var rpath = require.resolve('./a.js');
delete require.cache[rpath];
Et puis demandez à nouveau le module:
var a = require('./a');
Notez que cela n'est pas recommandé en production car la delete uniquement la référence au module chargé, pas les données chargées elles-mêmes. Le module n'étant pas récupéré, une mauvaise utilisation de cette fonctionnalité peut entraîner une fuite de mémoire.
Construire vos propres modules
Vous pouvez également référencer un objet pour l'exporter publiquement et ajouter en continu des méthodes à cet objet:
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
}
Pour utiliser l'un de ces éléments, il vous suffit de demander le module comme vous le feriez normalement:
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()
})
}
Chaque module injecté une seule fois
NodeJS exécute le module uniquement la première fois que vous en avez besoin. Toute autre fonction requise réutilisera le même objet, donc n'exécutera pas le code dans le module une autre fois. Aussi Node met en cache les modules la première fois qu'ils sont chargés en utilisant require. Cela réduit le nombre de lectures de fichiers et accélère l'application.
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
Module de chargement depuis node_modules
Les modules peuvent être require sans utiliser de chemins relatifs en les plaçant dans un répertoire spécial appelé node_modules .
Par exemple, pour require un module appelé foo depuis un fichier index.js , vous pouvez utiliser la structure de répertoires suivante:
index.js
\- node_modules
\- foo
|- foo.js
\- package.json
Les modules doivent être placés dans un répertoire, avec un fichier package.json . Le champ main du fichier package.json doit pointer vers le point d'entrée de votre module - c'est le fichier qui est importé lorsque les utilisateurs ont require('your-module') . main défaut à index.js si non fourni. Sinon, vous pouvez vous référer à des fichiers par rapport à votre module simplement en ajoutant le chemin par rapport au require appel: require('your-module/path/to/file') .
Les modules peuvent également être require depuis les répertoires node_modules dans la hiérarchie du système de fichiers. Si nous avons la structure de répertoires suivante:
my-project
\- node_modules
|- foo // the foo module
\- ...
\- baz // the baz module
\- node_modules
\- bar // the bar module
Nous pourrons require le module foo de tout fichier dans la bar utilisant require('foo') .
Notez que ce nœud ne correspondra qu'au module le plus proche du fichier dans la hiérarchie du système de fichiers, à partir de (répertoire courant du fichier / modules_noeud). Le noeud correspond aux répertoires de la racine du système de fichiers.
Vous pouvez installer de nouveaux modules à partir du registre npm ou d'autres registres npm, ou créer le vôtre.
Dossier en tant que module
Les modules peuvent être divisés en plusieurs fichiers .js dans le même dossier. Un exemple dans un dossier my_module :
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');
Un module comme celui-ci est utilisé en s'y référant par le nom du dossier:
var split_module = require('./my_module');
Notez que si vous en aviez besoin en omettant ./ ou toute indication d'un chemin vers un dossier depuis l'argument de la fonction require, Node essaiera de charger un module à partir du dossier node_modules .
Sinon, vous pouvez créer dans le même dossier un fichier package.json avec ces contenus:
{
"name": "my_module",
"main": "./your_main_entry_point.js"
}
De cette façon, vous n'êtes pas obligé de nommer le fichier principal du module "index".