web-dev-qa-db-fra.com

Partager des variables entre des fichiers dans Node.js?

Voici 2 fichiers:

// main.js
require('./modules');
console.log(name); // prints "foobar"

// module.js
name = "foobar";

Quand je n'ai pas "var" ça marche. Mais quand j'ai:

// module.js
var name = "foobar";

nom sera indéfini dans main.js.

J'ai entendu dire que les variables globales sont mauvaises et qu'il vaut mieux utiliser "var" avant les références. Mais est-ce un cas où les variables globales sont bonnes?

javascriptnode.jsglobal-variables
102
never_had_a_name

Les variables globales sont presque jamais une bonne chose (peut-être une exception ou deux là-bas ...). Dans ce cas, il semble que vous souhaitiez simplement exporter votre variable "name". Par exemple.,

// module.js
var name = "foobar";
// export it
exports.name = name;

Ensuite, dans main.js ...

//main.js
// get a reference to your required module
var myModule = require('./module');

// name is a member of myModule due to the export above
var name = myModule.name;
154
jmar777

Je ne parviens pas à trouver un scénario où une variable var globale est la meilleure option. Vous pouvez bien sûr en avoir une, mais jetez un coup d'œil à ces exemples et vous pourrez trouver un meilleur moyen de réaliser la même chose:

Scénario 1: Mettez le contenu dans des fichiers de configuration

Vous avez besoin d'une valeur indiquant que c'est identique dans l'application, mais cela change en fonction de l'environnement (production, dev ou test), du type de mailer par exemple, il vous faut:

// File: config/environments/production.json
{
    "mailerType": "SMTP",
    "mailerConfig": {
      "service": "Gmail",
      ....
}

et

// File: config/environments/test.json
{
    "mailerType": "Stub",
    "mailerConfig": {
      "error": false
    }
}

(faire une config similaire pour dev aussi)

Pour décider quelle configuration sera chargée, créez un fichier de configuration principal (celui-ci sera utilisé dans toute l'application)

// File: config/config.js
var _ = require('underscore');

module.exports = _.extend(
    require(__dirname + '/../config/environments/' + process.env.NODE_ENV + '.json') || {});

Et maintenant vous pouvez obtenir les données comme ceci:

// File: server.js
...
var config = require('./config/config');
...
mailer.setTransport(nodemailer.createTransport(config.mailerType, config.mailerConfig));

Scénario 2: Utiliser un fichier de constantes 

// File: constants.js
module.exports = {
  appName: 'My neat app',
  currentAPIVersion: 3
};

Et l'utiliser de cette façon

// File: config/routes.js

var constants = require('../constants');

module.exports = function(app, passport, auth) {
  var apiroot = '/api/v' + constants.currentAPIVersion;
...
  app.post(apiroot + '/users', users.create);
...

Scénario 3: Utiliser une fonction d'assistance pour obtenir/définir les données

Ce n'est pas un grand fan de celui-ci, mais au moins vous pouvez suivre l'utilisation du 'nom' (en citant l'exemple du PO) et mettre en place des validations.

// File: helpers/nameHelper.js

var _name = 'I shall not be null'

exports.getName = function() {
  return _name;
};

exports.setName = function(name) {
  //validate the name...
  _name = name;
};

Et l'utiliser

// File: controllers/users.js

var nameHelper = require('../helpers/nameHelper.js');

exports.create = function(req, res, next) {
  var user = new User();
  user.name = req.body.name || nameHelper.getName();
  ...

Il peut y avoir un cas d'utilisation où il n'y a pas d'autre solution que d'avoir une var globale, mais vous pouvez généralement partager les données de votre application en utilisant l'un de ces scénarios, si vous commencez à utiliser node.js (comme je l'étais il y a quelque temps). essayez d’organiser la manière dont vous gérez les données là-bas, car elles risquent de devenir très rapidement compliquées.

19
Felipe Pereira

Si nous devons partager plusieurs variables, utilisez le format ci-dessous

//module.js
   let name='foobar';
   let city='xyz';
   let company='companyName';

   module.exports={
    name,
    city,
    company
  }

Usage

  // main.js
    require('./modules');
    console.log(name); // print 'foobar'
10
Vineeth Bhaskaran

Mettre à jour

Enregistrez toute variable qui veut être partagée en un seul objet. Puis transmettez-le au module chargé pour qu’il puisse accéder à la variable via la référence à un objet.

// myModule.js
var shared = null;

function init(obj){
    shared = obj;
}

module.exports = {
    init:init
}

.

// main.js
var myModule = require('./myModule.js');
var shares = {value:123};
myModule.init(shares);

Old Answer

Pour partager des variables entre modules, vous pouvez utiliser function pour obtenir la valeur de variable entre le module principal et les modules.

//myModule.js
var mainFunction = null; //You can also put function reference in a Object or Array

function functionProxy(func){
    mainFunction = func; //Save the function reference
}

// --- Usage ---
// setTimeout(function(){
//   console.log(mainFunction('myString'));
//   console.log(mainFunction('myNumber'));
// }, 3000);

module.exports = {
    functionProxy:functionProxy
}

.

//main.js
var myModule = require('./myModule.js');
var myString = "heyy";
var myNumber = 12345;

function internalVariable(select){
    if(select=='myString') return myString;
    else if(select=='myNumber') return myNumber;
    else return null;
}

myModule.functionProxy(internalVariable);


// --- If you like to be able to set the variable too ---
// function internalVariable(select, set){
//    if(select=='myString'){
//        if(set!=undefined) myString = set;
//        else return myString;
//    }
//    else if(select=='myNumber'){
//      if(set!=undefined) myNumber = set;
//      else return myNumber;
//    }
//    else return null;
// }

Vous pouvez toujours obtenir la valeur de main.js même si la valeur a été modifiée.

3
StefansArya

une variable déclarée avec ou sans le mot-clé var est attachée à l'objet global. C'est la base pour créer des variables globales dans Node en déclarant des variables sans le mot clé var. Tandis que les variables déclarées avec le mot-clé var restent locales à un module.

voir cet article pour plus de compréhension - https://www.hacksparrow.com/global-variables-in-node-js.html

0
criz

Avec un avis différent, je pense que les variables global pourraient être le meilleur choix si vous voulez publier votre code sur npm, car vous ne pouvez pas être sûr que tous les packages utilisent la même version de votre code. Donc, si vous utilisez un fichier pour exporter un objet singleton, cela posera des problèmes ici.

Vous pouvez choisir global, require.main ou tout autre objet partagé entre plusieurs fichiers.

S'il vous plaît dites-moi s'il existe de meilleures solutions.

0
LCB