Comprendre module.exports et exports dans Node.js —

Dans la programmation Node.js, les modules sont des unités de fonctionnalités autonomes qui peuvent être partagées et réutilisées dans plusieurs 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, j’examinerai comment travailler avec des modules dans Node.js, en me concentrant sur la façon de les exporter et de les consommer.

Différents formats de modules Node.JS

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 Définition de module asynchrone (AMD) format est utilisé dans les navigateurs et utilise un define fonction pour définir des modules.
• Le CommonJS (CJS) format est utilisé dans Node.js et utilise require et module.exports pour définir les dépendances et les modules. L’écosystème npm est construit sur ce format.
• Le Module ES (ESM) format. Depuis ES6 (ES2015), JavaScript prend en charge un format de module natif. Il utilise un export mot-clé pour exporter l’API publique d’un module et un import mot-clé pour l’importer.
• Le System.register Le format a été conçu pour prendre en charge les modules ES6 dans ES5.
• Le Définition de module universel (UMD) 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 chargeurs de modules différents.

Veuillez noter que cet article traite uniquement de la Format CommonJS, la norme dans Node.js. Si vous souhaitez lire dans l’un des autres formats, je vous recommande Cet articlepar l’auteur de SitePoint Jurgen Van de Moere.

Exiger 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, nous devons exiger le module utilisant le require mot-clé et affectez le résultat à une variable. Cela peut ensuite être utilisé pour invoquer toutes les méthodes exposées par le module.

Par exemple, pour lister le contenu d’un répertoire, vous pouvez utiliser la 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(file);
  });
});

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éer et exporter 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 user.js fichier et en ajoutant ce qui suit :

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

exports.getName = getName;

Créez maintenant un index.js fichier 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 :

User: Jim

Alors que s’est-il passé ici ? Eh bien, si vous regardez le user.js fichier, vous remarquerez que nous définissons un getName fonction, puis en utilisant la exports mot-clé pour le rendre disponible pour l’importation ailleurs. Puis dans le index.js fichier, nous importons cette fonction et l’exécutons. Notez également que dans le require instruction, 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 :

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

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

const dateOfBirth = '12.01.1982';

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

Et en 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 :

Jim lives in Munich and was born on 12.01.1982.

Remarquez comment le nom que nous donnons à l’export dateOfBirth variable peut être tout ce que nous voulons (dob dans ce cas). Il n’est pas nécessaire qu’il soit identique au 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 à affectation déstructurantenous pouvons choisir ce que nous voulons importer :

const { getName, dob } = require('./user');
console.log(
  `${getName()} was born on ${dob}.`
);

Comme vous vous en doutez, ceci enregistre :

Jim was born on 12.01.1982.

Exportation d’une valeur par défaut

Dans l’exemple ci-dessus, nous exportons les fonctions et les valeurs individuellement. C’est pratique pour les fonctions d’assistance qui pourraient être nécessaires dans toute une application, mais lorsque vous avez un module qui n’exporte qu’une seule chose, il est plus courant d’utiliser module.exports:

class User {
  constructor(name, age, email) {
    this.name = name;
    this.age = age;
    this.email = email;
  }

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

module.exports = User;

Et en index.js:

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

console.log(jim.getUserStats());

Le code ci-dessus enregistre ceci :

Name: Jim
Age: 37
Email: jim@example.com

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

Au cours de vos voyages sur le Web, vous pourriez rencontrer 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é sur module – et bien sûr, cela fonctionne très bien:

const { getName, dob } = require('./user');
console.log(
  `${getName()} was born on ${dob}.`
);

Cela enregistre les éléments suivants :

Jim was born on 12.01.1982.

Et alors est la différence entre module.exports et exports? L’un n’est-il qu’un alias pratique pour l’autre ?

Enfin, 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);

Cela produit :

Module {
  id: '.',
  exports: {},
  parent: null,
  filename: '/home/jim/Desktop/index.js',
  loaded: false,
  children: [],
  paths:
   [ '/home/jim/Desktop/node_modules',
     '/home/jim/node_modules',
     '/home/node_modules',
     '/node_modules' ] }

Comme tu peux le voir, module a un exports propriété. Ajoutons-y quelque chose :

exports.foo = 'foo';
console.log(module);

Cela génère :

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

Attribuer des propriétés à exports les ajoute également à module.exports. C’est parce que (au début, du moins) exports est une référence à module.exports.

Alors, lequel dois-je utiliser ?

Comme module.exports et exports les deux pointent vers le même objet, peu importe normalement celui que vous utilisez. Par exemple:

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

Ce code se traduirait par l’objet exporté du module étant { foo: 'foo', bar: 'bar' }.

Cependant, il y a une mise en garde. Quoi que vous assigniez module.exports to est ce qui est exporté depuis votre module.

Alors, prenez ce qui suit :

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

Cela entraînerait uniquement l’exportation d’une fonction anonyme. Le foo variable serait ignorée.

Si vous souhaitez en savoir plus sur la différence, je vous 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 parties plus petites. J’espère que cet article vous a donné une bonne introduction à leur utilisation dans Node.js, ainsi qu’à démystifier leur syntaxe.

Si vous avez des questions ou des commentaires, n’hésitez pas à sauter sur le Forums SitePoint pour lancer une discussion.