en programmation, les modules sont des unités autonomes de fonctionnalité qui peuvent être partagées et réutilisées entre les projets. Ils nous facilitent la vie en tant que développeurs, car nous pouvons les utiliser pour augmenter nos applications avec des fonctionnalités que nous n’avons pas eu à écrire nous-mêmes. Ils nous permettent également d’organiser et de découpler notre code, conduisant à des applications plus faciles à comprendre, à déboguer et à maintenir.
Dans cet article, je vais examiner comment travailler avec des modules en Nœud.js, en se concentrant sur la façon d’exporter et de les consommer.,
différents formats de modules
comme JavaScript n’avait à l’origine aucun concept de modules, une variété de formats concurrents ont émergé au fil du temps. Voici une liste des principaux à connaître:
- le format de définition de Module asynchrone (AMD) est utilisé dans les navigateurs et utilise une fonction
define
pour définir les modules. - Le format CommonJS (CJS) est utilisé dans Node.js et utilise
require
etmodule.exports
pour définir les dépendances et les modules. L’écosystème npm est construit sur ce format. - Le format du Module ES (ESM)., Depuis ES6 (ES2015), JavaScript prend en charge un format de module natif. Il utilise un mot-clé
export
pour exporter L’API publique d’un module et un mot-cléimport
pour l’importer. - Le Système.le format register a été conçu pour prendre en charge les modules ES6 dans ES5.
- Le format UMD (Universal Module Definition) peut être utilisé à la fois dans le navigateur et dans Node.js. C’est utile lorsqu’un module doit être importé par un certain nombre de différents module de chargeurs.
veuillez noter que cet article traite uniquement du format CommonJS, la norme dans Node.js., Si vous souhaitez lire dans l’un des autres formats, je recommande cet article, par SitePoint auteur Jurgen Van de Moere.
Nécessitant un Module
Nœud.js est livré avec un ensemble de modules intégrés que nous pouvons utiliser dans notre code sans avoir à les installer. Pour ce faire, nous devons exiger le module en utilisant le mot-clé require
et affecter le résultat à une variable. Cela peut ensuite être utilisé pour invoquer toutes les méthodes exposées par le module.,
Par exemple, pour répertorier le contenu d’un répertoire, vous pouvez utiliser le module système de fichiers et sa méthode readdir
:
notez que dans CommonJS, les modules sont chargés de manière synchrone et traités dans l’ordre où ils se produisent.
création et exportation d’un Module
voyons maintenant comment créer notre propre module et l’Exporter pour une utilisation ailleurs dans notre programme., Commençons par créer un user.js
fichier et ajouter le code suivant:
const getName = () => { return 'Jim';};exports.getName = getName;
Maintenant, créez un index.js
fichier dans le même dossier et d’ajouter ceci:
const user = require('./user');console.log(`User: ${user.getName()}`);
Exécuter le programme à l’aide de node index.js
et vous devriez voir la suite de la sortie vers le terminal:
User: Jim
Donc ce qui s’est passé ici?, Eh bien, si vous regardez le fichier user.js
, vous remarquerez que nous définissons une fonction getName
, puis en utilisant le mot-clé exports
pour le rendre disponible pour l’importation ailleurs. Ensuite, dans le fichier index.js
, nous importons cette fonction et l’exécutons. Notez également que dans l’instruction require
, le nom du module est préfixé par ./
, car il s’agit d’un fichier local. Notez également qu’il n’est pas nécessaire d’ajouter l’extension de fichier.,
exportation de plusieurs méthodes et valeurs
Nous pouvons exporter plusieurs méthodes et valeurs de la même manière:
et dans index.js
:
const user = require('./user');console.log( `${user.getName()} lives in ${user.getLocation()} and was born on ${user.dob}.`);
le code ci-dessus produit ceci:
remarquez comment le nom que nous donnons à la variable dateOfBirth
exportée peut être tout ce que nous voulons (dob
dans ce cas). Il ne doit pas nécessairement être le même que le nom de la variable d’origine.,
variations de syntaxe
je dois également mentionner qu’il est possible d’exporter des méthodes et des valeurs au fur et à mesure, pas seulement à la fin du fichier.
Par exemple:
exports.getName = () => { return 'Jim';};exports.getLocation = () => { return 'Munich';};exports.dob = '12.01.1982';
Et merci pour déstructuration mission, nous pouvons choisir ce que nous voulons importer:
const { getName, dob } = require('./user');console.log( `${getName()} was born on ${dob}.`);
Comme vous vous en doutez, cette logs:
Jim was born on 12.01.1982.
l’Exportation d’une Valeur par Défaut
Dans l’exemple ci-dessus, nous sommes des exportateurs de fonctions et de valeurs individuellement., C’est pratique pour les fonctions d’assistance qui pourraient être nécessaires sur une application, mais quand vous avez un module qui exporte seulement une chose, il est plus courant d’utiliser des module.exports
:
Et dans index.js
:
const User = require('./user');const jim = new User('Jim', 37, '[email protected]');console.log(jim.getUserStats());
Le code ci-dessus journaux ceci:
Name: JimAge: 37Email: [email protected]
Quelle est la Différence Entre le module.exportations et exportations?,
Dans votre voyage à travers le Web, vous pouvez venir à travers la syntaxe suivante:
module.exports = { getName: () => { return 'Jim'; }, getLocation: () => { return 'Munich'; }, dob: '12.01.1982',};
Ici, nous attribuons les fonctions et les valeurs que nous voulons exporter vers un exports
propriété module
— et bien sûr, cela fonctionne bien:
const { getName, dob } = require('./user');console.log( `${getName()} was born on ${dob}.`);
Cette des journaux suivants:
Jim was born on 12.01.1982.
Alors, quelle est la différence entre module.exports
et exports
? L’un est-il juste un alias pratique pour l’autre?,
un peu comme ça, mais pas tout à fait …
Pour illustrer ce que je veux dire, nous allons changer le code dans le index.js
pour vous connecter à la valeur de module
:
console.log(module);
Ce produit:
Comme vous pouvez le voir, module
est une exports
propriété. Nous allons ajouter quelque chose à cela:
// index.jsexports.foo = 'foo';console.log(module);
C’sorties:
Module { id: '.', exports: { foo: 'foo' }, ...
l’Attribution de propriétés à des exports
ajoute également à la balise module.exports
., C’est parce que (initialement, au moins) exports
est une référence à module.exports
.
alors lequel dois-je utiliser?
module.exports
et exports
pointent vers le même objet, il n’a normalement pas d’importance qui vous utilisez. Par exemple:
exports.foo = 'foo';module.exports.bar = 'bar';
ce code aurait pour conséquence que l’objet exporté du module soit { foo: 'foo', bar: 'bar' }
.
Cependant, il y a une mise en garde. Tout ce à quoi vous attribuez module.exports
est ce qui est exporté à partir de votre module.,
donc, prenez ce qui suit:
exports.foo = 'foo';module.exports = () => { console.log('bar'); };
cela n’entraînerait qu’une fonction anonyme exportée. La variablefoo
serait ignorée.
Si vous souhaitez en savoir plus sur la différence, je recommande cet article.
Conclusion
Les Modules sont devenus une partie intégrante de L’écosystème JavaScript, nous permettant de composer de grands programmes à partir de plus petites parties. J’espère que cet article vous a donné une bonne introduction à travailler avec eux dans Node.js, ainsi que d’aider à démystifier leur syntaxe.