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

Le nom ne sera pas défini dans main.js.

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

Les variables globales ne 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 "nom". 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;

Je ne parviens pas à trouver un scénario où un global varest la meilleure option, bien sûr vous pouvez en avoir un, mais jetez un œil à ces exemples et vous trouverez peut-être un meilleur moyen d'accomplir la même chose:

Scénario 1: mettre les choses dans les fichiers de configuration

Vous avez besoin d'une valeur identique dans toute l'application, mais cela change en fonction de l'environnement (production, développement ou test), le type de courrier par exemple, dont vous auriez besoin:

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

et

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

(faire une configuration similaire pour les développeurs aussi)

Pour décider quelle configuration sera chargée, créez un fichier de configuration principal (il 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 utilisez-le 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

Pas un grand fan de celui-ci, mais au moins vous pouvez suivre l'utilisation du 'nom' (en citant l'exemple de l'OP) 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 utilisez-le

// 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 pourrait y avoir un cas d'utilisation où il n'y a pas d'autre solution que d'avoir un global var, mais généralement vous pouvez partager les données dans 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 pour organiser la façon dont vous gérez les données là-bas, car cela peut devenir très rapidement compliqué.

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'

Enregistrez toute variable à partager comme un seul objet. Puis passez-le au module chargé pour qu'il puisse accéder à la variable via la référence d'objet.

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

// Initialize module and pass the shareable object
myModule.init(shares);

// The value was changed from init2 on the other file
console.log(shares.value); // 789

Sur l'autre dossier ..

// module.js
var shared = null;

function init2(){
    console.log(shared.value); // 123
    shared.value = 789;
}

module.exports = {
    init:function(obj){
        // Save the shared object on current module
        shared = obj;

        // Call something outside
        init2();
    }
}

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. Alors 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

Avec un avis différent, je pense que les globalvariables pourraient être le meilleur choix si vous allez publier votre code 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 singletonobjet, cela causera des problèmes ici.

Vous pouvez choisir global, require.mainou tout autre objet qui est partagé entre les fichiers.

Veuillez me dire s'il existe de meilleures solutions.