Articles

.exportations et exportations dans le nœud.js

Posted by admin

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 et module.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.

Leave A Comment