Comprendre module.exports et les exportations dans Node.js

En programmation, les modules sont des unités de fonctionnalité autonomes pouvant être partagées et réutilisées entre projets. Ils facilitent la vie de nos développeurs, car nous pouvons les utiliser pour enrichir nos applications de fonctionnalités que nous n’avons pas eu à écrire nous-mêmes. Ils nous permettent également d'organiser et de découpler notre code, ce qui conduit à des applications plus faciles à comprendre, à déboguer et à gérer.

Dans cet article, nous allons examiner comment utiliser les modules dans Node.js, en mettant l'accent sur l'exportation. et les consommer.

Différents formats de modules

Comme JavaScript n’avait à l’origine aucun concept de modules, de nombreux formats concurrents se sont développés au fil du temps. Voici une liste des principaux à connaître:

• Le format Définition du module asynchrone (AMD) est utilisé dans les navigateurs et utilise une fonction define pour définir des modules. [19659006] Le format CommonJS (CJS) est utilisé dans Node.js et les utilisations nécessitent et module.exports pour définir les dépendances et les modules. L'écosystème npm repose sur ce format.
• Le format ES Module (ESM) . À partir de 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 format System.register a été conçu pour prendre en charge ES6. modules dans ES5.
• Le format Définition du module universel (UMD) peut être utilisé à la fois dans le navigateur et dans Node.js. C’est utile quand un module doit être importé par un certain nombre de chargeurs de modules différents.

Notez que cet article traite uniquement du format CommonJS la norme dans Node.js. Si vous souhaitez lire l'un des autres formats, je vous recommande cet article de 1945, auteur de SitePoint Jurgen Van de Moere.

Requiert un module

Node.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, il faut que le module utilise le mot-clé require et affecte le résultat à une variable. Cela peut ensuite être utilisé pour invoquer n'importe quelle méthode exposée par le module.

Par exemple, pour lister le contenu d'un répertoire, vous pouvez utiliser le module de système de fichiers et son readdir . méthode:

 const fs = require ('fs');
const folderPath = '/ home / jim / Desktop /';

fs.readdir (folderPath, (err, files) => {
  files.forEach (file => {
    console.log (fichier);
  });
});

Notez que dans CommonJS, les modules sont chargés de manière synchrone et traités dans l'ordre dans lequel ils se produisent.

Création et exportation d'un module

Voyons maintenant comment créer notre propre module et l'exporter pour l'utiliser ailleurs dans notre programme. . Commencez par créer un fichier user.js et ajoutez ce qui suit:

 const getName = () => {
  retournez 'Jim';
};

exports.getName = getName;

Créez maintenant un fichier index.js dans le même dossier et ajoutez ceci:

 const user = require ('./ user');
console.log (`User: $ {user.getName ()}`);

Exécutez le programme en utilisant node index.js et vous devriez voir la sortie suivante sur le terminal:

 Utilisateur: Jim

Alors, que s'est-il passé ici? Eh bien, si vous regardez le fichier user.js vous remarquerez que nous définissons une fonction getName puis que nous utilisons le mot clé exports pour créer il est disponible pour 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 est inutile 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:

 const getName = () => {
  retournez 'Jim';
};

const getLocation = () => {
  retour 'Munich';
};

const dateOfBirth = '12 .01.1982 ';

exports.getName = getName;
exports.getLocation = getLocation;
exports.dob = dateOfBirth;

Et dans index.js :

 const user = require ('./ user');
console.log (
  `$ {user.getName ()} réside dans $ {user.getLocation ()} et est né le $ {user.dob} .`
)

Le code ci-dessus produit ceci:

 Jim vit à Munich et est né le 12.01.1982.

Remarquez comment le nom que nous donnons à la variable exportée dateOfBirth peut être tout ce que nous voulons ( dob dans ce cas). Il ne doit pas nécessairement être identique au nom de la variable d'origine.

Variations dans la syntaxe

Je dois également mentionner qu'il est possible d'exporter des méthodes et des valeurs au fur et à mesure, et pas seulement à la fin du fichier. 19659013] Par exemple:

 exports.getName = () => {
  retournez 'Jim';
};

exports.getLocation = () => {
  retour 'Munich';
};

exports.dob = '12 .01.1982 ';

Et grâce à la tâche de déstructuration nous pouvons sélectionner ce que nous voulons importer:

 const {getName, dob} = require ('./ user');
console.log (
  `$ {getName ()} est né le $ {dob} .`
)

Comme on peut s’y attendre, ceci enregistre:

 Jim est né le 12.01.1982.

Exportation d’une valeur par défaut

Dans l’exemple ci-dessus, nous exportons des fonctions et des valeurs individuellement. C’est pratique pour les fonctions d’aide pouvant être utilisées dans une application, mais lorsque vous avez un module qui exporte une seule chose, il est plus courant d’utiliser module.exports :

utilisateur de classe {
  constructeur (nom, âge, email) {
    this.name = name;
    this.age = age;
    this.email = email;
  }

  getUserStats () {
    retour `
      Nom: $ {this.name}
      Age: $ {this.age}
      Email: $ {this.email}
    `;
  }
}

module.exports = Utilisateur;

Et dans index.js :

 const User = require ('./ user');
const jim = nouvel utilisateur ('Jim', 37, 'jim@example.com');

console.log (jim.getUserStats ());

Le code ci-dessus enregistre ceci:

 Nom: Jim
Âge: 37 ans
Email: jim@example.com

Quelle est la différence entre module.exports et exportations ?

Lors de vos voyages sur le Web, vous pouvez rencontrer la syntaxe suivante:

 module.exports = {
  getName: () => {
    retournez 'Jim';
  },

  getLocation: () => {
    retour 'Munich';
  },

  dob: '12 .01.1982 ',
};

Nous attribuons ici les fonctions et les valeurs que nous voulons exporter à une propriété exports sur le module – et bien sûr, cela fonctionne parfaitement:

 const {getName , dob} = require ('./ user');
console.log (
  `$ {getName ()} est né le $ {dob} .`
)

Cela enregistre ce qui suit:

 Jim est né le 12.01.1982.

Alors quelle est la différence entre les exportations module.exports et ?

Eh bien, un peu, mais pas tout à fait…

Pour illustrer ce que je veux dire, changeons le code dans index.js pour enregistrer la valeur de module :

 console.log (module);

Ceci produit:

 Module {
  id: '.',
  exportations: {},
  parent: null,
  filename: '/home/jim/Desktop/index.js',
  chargé: faux,
  enfants: []
  chemins:
   [ '/home/jim/Desktop/node_modules',
     '/home/jim/node_modules',
     '/home/node_modules',
     '/node_modules' ]}

Comme vous pouvez le constater, le module possède une propriété exports . Ajoutons quelque chose:

 // index.js
exports.foo = 'foo';
console.log (module);

Cette sortie:

 Module {
  id: '.',
  exportations: {foo: 'foo'},
  ...

L'attribution de propriétés à les exportations les ajoute également à module.exports . En effet, au départ, exportations est une référence à module.exports .

Alors, que dois-je utiliser?

As module.exports et les exportations pointent toutes deux vers le même objet, peu importe ce que vous utilisez. Par exemple:

 exports.foo = 'foo';
module.exports.bar = 'bar';

Ce code aurait pour résultat que l’objet exporté du module soit {foo: 'foo', bar: 'bar'} .

Cependant, une mise en garde est nécessaire. Tout ce que vous affectez module.exports est ce qui est exporté de votre module.

Prenez donc ce qui suit:

 exports.foo = 'foo';
module.exports = () => {console.log ('bar'); };

Cela ne ferait qu'exporter une fonction anonyme. La variable foo serait ignorée.

Si vous souhaitez lire davantage sur la différence, je recommande cet article .

Conclusion

partie intégrante de l'écosystème JavaScript, nous permettant de composer de gros programmes à partir de petites parties. J'espère que cet article vous a fourni une bonne introduction à travailler avec eux dans Node.js, ainsi qu'à la démystification de leur syntaxe.

Si vous avez des questions ou des commentaires, n'hésitez pas à passer à la page . ] Les forums SitePoint pour lancer une discussion