javascript - nodejs - require node module in js




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

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 la documentation de Node.js :

module

Une référence au module actuel. 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 , et que serait un exemple simple?


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

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

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

Le cas d'utilisation basique que vous verrez (par exemple dans l'exemple de code ExpressJS) est que vous définissez les propriétés de l'objet exports 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 à l' exports .

Parfois, vous voulez que l'objet renvoyé à partir d'un appel require() soit une fonction que vous pouvez appeler, plutôt qu'un simple objet avec des propriétés. Dans ce cas, vous devez également définir module.exports , comme ceci:

(sayhello.js):

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

(app.js):

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

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


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 des modules d'import , 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.

Alors que Exports 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 quoi que ce soit ici, rappelez-vous, module.exports.additionTwo est la même chose que exports.additionTwo

Huh, c'est la raison, nous aimons

exports.additionTwo = function(x)
{return x+2;};

Soyez prudent avec le chemin

Disons que vous avez créé un module addition.js,

exports.additionTwo = function(x){
return x + 2;
};

Lorsque vous exécutez ceci sur votre invite de commande NODE.JS:

node
var run = require('addition.js');

Cela va dire

Erreur: Impossible de trouver le module addition.js

C'est parce que le processus node.js est incapable d'ajouter.js puisque nous n'avons pas mentionné le chemin. Nous pouvons donc définir le chemin en utilisant NODE_PATH

set NODE_PATH = path/to/your/additon.js

Maintenant, cela devrait fonctionner avec succès sans aucune erreur !!

Une dernière chose, vous pouvez également exécuter le fichier addition.js en ne définissant pas le NODE_PATH, retour à votre invite de commande nodejs:

node
var run = require('./addition.js');

Puisque nous fournissons le chemin ici en disant qu'il se trouve dans le répertoire courant ./ ceci devrait aussi fonctionner avec succès.


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

À moins que votre module n'utilise des fonctionnalités ou des modules spécifiques aux nœuds, je vous encourage fortement à utiliser les exports au lieu de module.exports qui ne fait pas partie du standard CommonJS , et qui n'est généralement pas supporté par d'autres implémentations.

Une autre caractéristique 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 thread. Je déconseillerais personnellement cette pratique car cela 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) )


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");

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

J'ai une vidéo sur module_export disponible here


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

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

les propriétés des exports ou module.exports , telles que les fonctions ou les variables, seront exposées à l'extérieur

il y a quelque chose que vous devez accorder plus d'attention: ne pas override 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.







node.js