Question Quel est le but de Node.js module.exports et comment l'utilisez-vous?


Quel est le but de Node.js module.exports et comment l'utilisez-vous?

Je ne peux pas trouver d'informations à ce sujet, mais il semble être une partie assez importante de Node.js comme je le vois souvent dans le code source.

Selon le Documentation Node.js:

module 

Une référence au courant    module. En particulier module.exports   est identique à l'objet exports. Voir    src/node.js pour plus d'informations.

Mais cela n'aide pas vraiment.

Que fait exactement module.exports faire, et quel serait un exemple simple?


1237
2018-03-15 11:56


origine


Réponses:


module.exports est l'objet qui est effectivement retourné à la suite d'un require appel.

le exports La variable est initialement définie sur le même objet (c'est-à-dire qu'il s'agit d'un raccourci "alias"), donc dans le code du module, vous écrivez habituellement quelque chose comme ceci:

var myFunc1 = function() { ... };
var myFunc2 = function() { ... };
exports.myFunc1 = myFunc1;
exports.myFunc2 = myFunc2;

exporter (ou "exposer") les fonctions à portée interne myFunc1 et myFunc2.

Et dans le code d'appel vous utiliseriez:

var m = require('./mymodule');
m.myFunc1();

où la dernière ligne montre comment le résultat de require est (habituellement) juste un objet simple dont les propriétés peuvent être accédées.

NB: si vous remplacez exports alors il ne se référera plus à module.exports. Donc, si vous souhaitez assigner un nouvel objet (ou une référence de fonction) à exports alors vous devriez aussi assigner ce nouvel objet à module.exports


Il est à noter que le nom ajouté à la exports L'objet n'a pas besoin d'être le même que le nom interne du module pour la valeur que vous ajoutez, ce qui vous permet d'avoir:

var myVeryLongInternalName = function() { ... };
exports.shortName = myVeryLongInternalName;
// add other objects, functions, as required

suivi par:

var m = require('./mymodule');
m.shortName(); // invokes module.myVeryLongInternalName

1452
2018-03-15 12:00



Cela a déjà été répondu, mais je voulais ajouter quelques précisions ...

Vous pouvez utiliser les deux exports et module.exports pour importer du code dans votre application comme ceci:

var mycode = require('./path/to/mycode');

Le cas d'utilisation de base que vous verrez (par exemple dans le code d'exemple ExpressJS) est que vous définissez les propriétés sur le exports objet dans un fichier .js que vous importez ensuite en utilisant require()

Ainsi, dans un exemple de comptage simple, vous pourriez avoir:

(counter.js):

var count = 1;

exports.increment = function() {
    count++;
};

exports.getCount = function() {
    return count;
};

... puis dans votre application (web.js, ou tout autre fichier .js):

var counting = require('./counter.js');

console.log(counting.getCount()); // 1
counting.increment();
console.log(counting.getCount()); // 2

En termes simples, vous pouvez considérer les fichiers requis comme des fonctions qui renvoient un seul objet, et vous pouvez ajouter des propriétés (chaînes, nombres, tableaux, fonctions, n'importe quoi) à l'objet renvoyé en les définissant exports.

Parfois, vous aurez besoin de l'objet retourné d'un require() appel à être une fonction que vous pouvez appeler, plutôt que juste un objet avec des propriétés. Dans ce cas, vous devez également définir module.exports, comme ça:

(sayhello.js):

module.exports = exports = function() {
    console.log("Hello World!");
};

(app.js):

var sayHello = require('./sayhello.js');
sayHello(); // "Hello World!"

La différence entre les exportations et module.exports est mieux expliquée dans cette réponse ici.


194
2017-10-16 05:03



Notez que le mécanisme du module NodeJS est basé sur CommonJS modules qui sont pris en charge dans de nombreuses autres implémentations comme ExigerJS, mais aussi SproutCore, CouchDB, Wakanda, OrientDB, ArangoDB, RingoJS, TeaJS, SilkJS, curl.js, ou même Adobe Photoshop (via PSLib). Vous pouvez trouver la liste complète des implémentations connues ici.

À moins que votre module n'utilise des fonctionnalités spécifiques à un nœud ou un module, je vous encourage fortement à utiliser exports au lieu de module.exports  qui ne fait pas partie de la norme CommonJS, et surtout pas pris en charge par d'autres implémentations.

Une autre fonctionnalité spécifique de NodeJS est lorsque vous affectez une référence à un nouvel objet à exports au lieu de simplement ajouter des propriétés et des méthodes comme dans le dernier exemple fourni par Jed Watson dans ce fil de discussion. Je déconseillerais personnellement cette pratique rompt le support de référence circulaire du mécanisme des modules CommonJS. Il n'est alors pas supporté par toutes les implémentations et l'exemple de Jed devrait alors être écrit de cette façon (ou similaire) pour fournir un module plus universel:

(sayhello.js):

exports.run = function() {
    console.log("Hello World!");
}

(app.js):

var sayHello = require('./sayhello');
sayHello.run(); // "Hello World!"

Ou en utilisant les fonctionnalités ES6

(sayhello.js):

Object.assign(exports, {
    // Put all your public API here
    sayhello() {
        console.log("Hello World!");
    }
});

(app.js):

const { sayHello } = require('./sayhello');
sayHello(); // "Hello World!"

PS: Il semble qu'Appcelerator implémente aussi des modules CommonJS, mais sans le support de référence circulaire (voir: Modules Appcelerator et CommonJS (mise en cache et références circulaires))


53
2018-01-20 12:35



Vous devez prendre quelques précautions si vous attribuez une référence à un nouvel objet exports et / ou modules.exports:

1. Toutes les propriétés / méthodes précédemment attachées à l'original exports ou module.exports sont bien sûr perdues parce que l'objet exporté référencera maintenant un autre nouveau

Celui-ci est évident, mais Si vous ajoutez une méthode exportée au début d'un module existant, assurez-vous que l'objet exporté natif ne référence pas un autre objet à la fin

exports.method1 = function () {}; // exposed to the original exported object
exports.method2 = function () {}; // exposed to the original exported object

module.exports.method3 = function () {}; // exposed with method1 & method2

var otherAPI = {
    // some properties and/or methods
}

exports = otherAPI; // replace the original API (works also with module.exports)

2. Dans le cas d'un exports ou module.exports référence une nouvelle valeur, ils ne font plus référence au même objet

exports = function AConstructor() {}; // override the original exported object
exports.method2 = function () {}; // exposed to the new exported object

// method added to the original exports object which not exposed any more
module.exports.method3 = function () {}; 

3. Conséquence trompeuse. Si vous changez la référence à la fois exports et module.exports, difficile de dire quelle API est exposée (on dirait module.exports gagne)

// override the original exported object
module.exports = function AConstructor() {};

// try to override the original exported object
// but module.exports will be exposed instead
exports = function AnotherConstructor() {}; 

31
2018-01-25 09:02



la propriété module.exports ou l'objet exports permet à un module de sélectionner ce qui doit être partagé avec l'application

enter image description here

J'ai une vidéo sur module_export disponible ici


23
2017-09-03 19:01



Lorsque vous divisez votre code de programme sur plusieurs fichiers, module.exports est utilisé pour publier des variables et des fonctions au consommateur d'un module. le require() appel dans votre fichier source est remplacé par correspondant module.exports chargé depuis le module.

N'oubliez pas lors de l'écriture de modules

  • Les modules de chargement sont mis en cache, seul l'appel initial évalue JavaScript.
  • Il est possible d'utiliser des variables et des fonctions locales dans un module, tout ne doit pas être exporté.
  • le module.exports objet est également disponible en tant que exports sténographie. Mais lorsque vous retournez une fonction unique, utilisez toujours module.exports.

module exports diagram

Selon: "Modules Partie 2 - Modules d'écriture".


17
2017-08-06 21:05



le lien de référence est comme ceci:

exports = module.exports = function(){
    //....
}

les propriétés de exports ou module.exports , comme les fonctions ou les variables, seront exposés à l'extérieur

il y a quelque chose que vous devez payer plus d'attention: ne pas override les exportations.

Pourquoi ?

car exporte uniquement la référence de module.exports, vous pouvez ajouter les propriétés aux exportations, mais si vous remplacez les exportations, le lien de référence sera rompu.

bon exemple :

exports.name = 'william';

exports.getName = function(){
   console.log(this.name);
}

mauvais exemple:

exports = 'william';

exports = function(){
     //...
}

Si vous voulez juste exposer une seule fonction ou variable, comme ceci:

// test.js
var name = 'william';

module.exports = function(){
    console.log(name);
}   

// index.js
var test = require('./test');
test();

ce module n'a exposé qu'une seule fonction et la propriété de nom est privée pour l'extérieur.


8
2018-04-18 00:53



Il existe des modules par défaut ou existants dans node.js lorsque vous téléchargez et installez node.js comme http, sys etc.

Comme ils sont déjà dans node.js, quand nous voulons utiliser ces modules, nous faisons essentiellement comme modules d'importation, mais pourquoi? parce qu'ils sont déjà présents dans le node.js. Importer, c'est comme les prendre à partir de node.js et les mettre dans votre programme. Et ensuite les utiliser.

Tandis que Exportations C'est exactement le contraire, vous créez le module que vous voulez, disons le module addition.js et en mettant ce module dans le node.js, vous le faites en l'exportant.

Avant d'écrire quelque chose ici, souvenez-vous, module.exports.additionTwo est le même que exports.additionTwo


4
2017-07-27 20:49



Un module encapsule le code associé dans une seule unité de code. Lors de la création d'un module, cela peut être interprété comme le déplacement de toutes les fonctions associées dans un fichier.

Supposons qu'il existe un fichier Hello.js qui inclut deux fonctions

sayHelloInEnglish = function() {
  return "Hello";
};
sayHelloInSpanish = function() {
  return "Hola";
};

Nous n'écrivons une fonction que lorsque l'utilité du code est plus d'un appel.

Supposons que nous voulons augmenter l'utilité de la fonction dans un fichier différent, par exemple World.js, dans ce cas l'exportation d'un fichier entre en image qui peut être obtenue par module.exports.

Vous pouvez simplement exporter la fonction par le code ci-dessous

var anyVariable={
 sayHelloInEnglish = function() {
      return "Hello";
    };
  sayHelloInSpanish = function() {
      return "Hola";
    }; 
}
module.export=anyVariable;

Maintenant vous avez juste besoin d'exiger le nom du fichier dans World.js pour pouvoir utiliser ces fonctions

var world= require("./hello.js");

1
2018-04-22 16:04