Node.js expose la variable au module?

J'ai lu beaucoup d'articles sur la façon de créer des modules dans node.js, et vous pouvez utiliser module.exports pour exposer les éléments internes du module au fichier qui l'inclut … génial!

Comment cela fonctionne-t-il à l'inverse? J'utiliserai les exemples suivants comme exemple 🙂

USER.JS function User() { this.property = 'value'; this.doSomething = function() { var getStuff = mainFileFunction(); // do something with getStuff } module.exports = User;

  MAIN.JS var myArray = []; myArray.push('something'); myArray.push('something else'); mainFileFunction() { for(thing in myArray) { return myArray[thing]; } } var u = new user(); log(u.property); <--- THIS IS EXPOSED, COOL! u.doSomething(); <--- This will throw an error because mainFileFunction is not defined in user.js :-(

Si je devais transférer mainFileFunction sur le fichier utilisateur, alors il ne fonctionnerait toujours pas parce que le tableau myArray ne serait pas défini … et si je devais aussi le déplacer, je ne pourrais pas l'utiliser dans D'autres fonctions principales (ce que je veux) 🙂

Je suis désolé si je manque quelque chose de vraiment évident ici … Ce que je veux, c'est d'exposer les parties de mon choix à partir des modules que j'inclue (module.export fonctionne pour cela) mais je veux aussi exposer tout à partir du fichier principal À toutes les incluses …

Ou tout simplement exposer tout à tout? Est-ce vraiment désordonné et horrible?

Juste pour expliquer ce que j'essaie de faire ici … Je veux que les classes soient définies dans des fichiers distincts, mais j'aimerais en inventer un tas d'objets dans le fichier principal et les stocker dans des tableaux .. Je veux que les objets Contiennent des méthodes qui peuvent accéder aux tableaux des autres types d'objets.

Merci les gars! 🙂

Vous pouvez utiliser des globals, ou avoir une dépendance circulaire appropriée ( require les deux fichiers), mais c'est généralement une mauvaise habitude qui peut entraîner des problèmes de maintenance dans le futur.

Au lieu de cela, vous pouvez utiliser l'injection de dépendance et injecter doSomething dans votre module. Ceci vous donne gratuitement les informations suivantes:

Vous pouvez tester l' User avec une simple implémentation simulée de doSomething plus tard et vérifier l'exactitude de votre code
Les dépendances d'un utilisateur sont explicites et non implicites, ce qui rend évident ce qu'un utilisateur a besoin.

Je fournirai deux implémentations, l'une utilisant l'injection de dépendance du constructeur et une avec un paramètre large de module.

  USER.JS function User(dependentFunction) { this.property = 'value'; this.doSomething = function() { var getStuff = dependentFunction(); // do something with getStuff } } module.exports = User; MAIN.JS ... var u = new User(mainFileFunction); u.doSomething(); // this will now work, using mainFileFunction

Ce qui se passe ici est assez simple, et nous savons ce qui se passe.

Cela peut également être un paramètre large de module

 USER.JS function User(depFunc) { this.property = 'value'; this.doSomething = function() { var getStuff = depFunc(); // do something with getStuff } } function UserFactory(depFunc){ return function(){ return new User(depFunc); } } module.exports = UserFactory; MAIN.JS var getUser = UserFactory(mainFileFunction); var u = getUser(); // will return a new user with the right function

+1 à Benjamin répondent à l'injection de dépendance. J'aimerais ajouter une autre façon d'injecter des objets dans vos modules en passant la dépendance dans la requête requise ('./ module.js') (dependentFunction);

 //MAIN.js var db = function() { this.rows = []; this.insert = function(name) { this.rows.push(name); console.log('Db: Inserting user with name ' + name); } this.getAll = function(){ return this.rows; } } var fakeDb = new db(); var user = require('./user.js')(fakeDb); user.add('Jhon'); user.add('Rose'); user.list();

 //users.js module.exports = function(db) { return { add: function(name) { db.insert(name); }, list: function() { var users = db.getAll(); var i = users.length; console.log('listing users\n-------'); while(i--) { console.log(users[i]); } } } }

Vous devez passer mainFileFunction comme paramètre pour le constructeur de l'utilisateur.

 USER.JS function User(mainFileFunction) { this.property = 'value'; this.doSomething = function() { var getStuff = mainFileFunction(); // do something with getStuff } module.exports = User;

Dans votre main.js, utilisez ce qui suit

var u = new user(mainFileFunction);

Que diriez-vous de déplacer mainFileFunction sur user.js, et que la fonction accepte un tableau comme argument:

 mainFileFunction(array) { for(thing in array) { return array[thing]; } }

Et puis, lorsque vous l'appelez depuis main.js, passez la fonction de votre tableau:

 u.doSomething(myArray);