web-dev-qa-db-fra.com

Variable globale dans app.js accessible dans les itinéraires?

Comment définir une variable dans app.js et la laisser être disponible dans toutes les routes, au moins dans le fichier index.js situé dans routes en utilisant le framework express et node.js

node.jsexpress
71
Technupe

Pour créer une variable globale, déclarez-la sans le mot clé var. (En règle générale, ce n'est pas la meilleure pratique, mais dans certains cas, cela peut être utile - soyez prudent, la variable sera disponible partout.)

Voici un exemple de visionmedia/screenshot-app

fichier app.js:

/**
 * Module dependencies.
 */

var express = require('express')
  , stylus = require('stylus')
  , redis = require('redis')
  , http = require('http');

app = express();

//... require() route files

fichier routes/main.js

//we can now access 'app' without redeclaring it or passing it in...

/*
 * GET home page.
 */

app.get('/', function(req, res, next){
  res.render('index');
});

//...
55
Jesse Fulton

Il est en fait très facile de faire cela en utilisant les méthodes "set" et "get" disponibles sur un objet express.

Par exemple, supposons que vous ayez une variable appelée config avec vos éléments liés à la configuration que vous souhaitez être disponible ailleurs:

Dans app.js:

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

app.configure(function() {
  ...
  app.set('config', config); 
  ...
}

Dans routes/index.js

exports.index = function(req, res){
  var config = req.app.get('config');
  // config is now available
  ...
}
74
Mandy

Une façon élégante de faire ceci est d'utiliser app.locals fourni par Express lui-même . Here est la documentation.

// In app.js:
app.locals.variable_you_need = 42;

// In index.js
exports.route = function(req, res){
    var variable_i_needed = req.app.locals.variable_you_need;
}
34
Ali

Pour déclarer une variable globale, vous devez utiliser global object. Comme global.votreNomVariable. Mais ce n'est pas une vraie façon. Pour partager des variables entre les modules, essayez d'utiliser le style d'injection comme

someModule.js:

module.exports = function(injectedVariable) {
    return {
        somePublicMethod: function() {
        },
        anotherPublicMethod: function() {
        },
    };
};

app.js

var someModule = require('./someModule')(someSharedVariable);

Ou vous pouvez utiliser un objet de substitution pour le faire. Comme hub .

someModule.js:

var hub = require('hub');

module.somePublicMethod = function() {
    // We can use hub.db here
};

module.anotherPublicMethod = function() {
};

app.js

var hub = require('hub');
hub.db = dbConnection;
var someModule = require('./someModule');
28
Vadim Baryshev

Voici bien expliquer, en bref:

http://www.hacksparrow.com/global-variables-in-node-js.html

Vous travaillez donc avec un ensemble de modules Node, peut-être un framework tel que Express.js, et vous sentez soudain le besoin de rendre certaines variables globales. Comment rendre les variables globales dans Node.js?

Le conseil le plus courant consiste à "déclarer la variable sans le mot clé var" ou à "ajouter la variable à l'objet global" ou "ajouter la variable à l'objet GLOBAL". Lequel utilisez-vous?

Tout d'abord, analysons l'objet global. Ouvrez un terminal, démarrez un nœud REPL (invite).

> global.name
undefined
> global.name = 'El Capitan'
> global.name
'El Capitan'
> GLOBAL.name
'El Capitan'
> delete global.name
true
> GLOBAL.name
undefined
> name = 'El Capitan'
'El Capitan'
> global.name
'El Capitan'
> GLOBAL.name
'El Capitan'
> var name = 'Sparrow'
undefined
> global.name
'Sparrow'
7
Victor Cruz

Cette question était utile, mais pourrait l'être davantage en donnant des exemples de code réels. Même l'article lié ne montre pas réellement une implémentation. Je soumets donc humblement:

Dans votre fichier app.js, le haut du fichier:

var express = require('express')
, http = require('http')
, path = require('path');

app = express(); //IMPORTANT!  define the global app variable prior to requiring routes!

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

app.js n'aura pas de aucune référence à la méthode app.get(). Laissez-les être définis dans les fichiers de routes individuelles.

routes/index.js:

require('./main');
require('./users');

et finalement, un fichier de routes réel, routes/main.js:

function index (request, response) {
    response.render('index', { title: 'Express' });
}

app.get('/',index); // <-- define the routes here now, thanks to the global app variable
4
John Gordon

Ma méthode préférée consiste à utiliser des dépendances circulaires *, que le noeud prend en charge

  • dans app.js, définissez var app = module.exports = express(); comme votre premier ordre du jour
  • Maintenant, tout module requis après le fait peut var app = require('./app') pour y accéder

app.js

var express   = require('express');
var app = module.exports = express(); //now app.js can be required to bring app into any file

//some app/middleware, config, setup, etc, including app.use(app.router)

require('./routes'); //module.exports must be defined before this line

routes/index.js

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

app.get('/', function(req, res, next) {
  res.render('index');
});

//require in some other route files...each of which requires app independently
require('./user');
require('./blog');
2
Will Stern

Comme d'autres l'ont déjà partagé, app.set('config', config) est idéal pour cela. Je voulais juste ajouter quelque chose d'assez important que je n'ai pas vu dans les réponses existantes. Une instance de Node.js est partagée entre toutes les demandes. Par conséquent, s'il peut s'avérer très pratique de partager un objet config ou router globalement, stockant globalement les données d'exécution sera disponible entre les demandes et les utilisateurs. Considérez cet exemple très simple:

var express = require('express');
var app = express();

app.get('/foo', function(req, res) {
    app.set('message', "Welcome to foo!");
    res.send(app.get('message'));
});

app.get('/bar', function(req, res) {
    app.set('message', "Welcome to bar!");

    // some long running async function
    var foo = function() {
        res.send(app.get('message'));
    };
    setTimeout(foo, 1000);
});

app.listen(3000);

Si vous visitez /bar et qu'une autre demande aboutit à /foo, votre message sera "Welcome to foo!". Ceci est un exemple stupide, mais il fait passer le message.

Il y a quelques points intéressants à ce sujet à Pourquoi différentes sessions node.js partagent-elles des variables? .

2
Charlie Schliesser

J'ai utilisé app.all

La méthode app.all () est utile pour mapper la logique «globale» pour des fichiers spécifiques préfixes de chemin ou correspondances arbitraires.

Dans mon cas, j'utilise confit pour la gestion de la configuration,

app.all('*', function (req, res, next) {
    confit(basedir).create(function (err, config) {
        if (err) {
            throw new Error('Failed to load configuration ', err);
        }
        app.set('config', config);
        next();
    });
});

Dans les itinéraires, il vous suffit de req.app.get('config').get('cookie');

0
nilesh

J'ai résolu le même problème, mais je devais écrire plus de code .J'ai créé un fichier server.js, qui utilise express pour enregistrer les itinéraires . Il expose une fonction, register, qui peut être utilisée par d'autres modules pour enregistrer leurs itinéraires. propres routes . Il expose également une fonction, startServer, pour commencer à écouter un port

server.js

const express = require('express');
const app = express();

const register = (path,method,callback) => methodCalled(path, method, callback)

const methodCalled = (path, method, cb) => {
  switch (method) {
    case 'get':
      app.get(path, (req, res) => cb(req, res))
      break;
    ...
    ...  
    default:
      console.log("there has been an error");
  }
}

const startServer = (port) => app.listen(port, () => {console.log(`successfully started at ${port}`)})

module.exports = {
  register,
  startServer
}

Dans un autre module, utilisez ce fichier pour créer un itinéraire.

help.js

const app = require('../server');

const registerHelp = () => {
  app.register('/help','get',(req, res) => {
    res.send("This is the help section")
  }),
  app.register('/help','post',(req, res) => {
    res.send("This is the help section")
  })}

module.exports = {
  registerHelp
}

Dans le fichier principal, amorcez les deux.

app.js

require('./server').startServer(7000)
require('./web/help').registerHelp()
0
Amar Dev

le plus simple est de déclarer une variable globale dans votre app.js dès le début:

global.mySpecialVariable = "something"

alors dans toutes les routes, vous pouvez l'obtenir:

console.log(mySpecialVariable)
0
Shaman

La réponse de John Gordon était la première d'une douzaine de réponses expliquées à demi/documentées que j'ai essayées, à partir de très nombreux sites, qui ont réellement fonctionné. Merci Monsieur Gordon. Désolé, je n'ai pas les points pour améliorer votre réponse.

J'aimerais ajouter, pour les autres débutants de la division de nœud-route-fichier, que l'utilisation de la fonction anonyme pour 'index' est ce que l'on verra plus souvent. Par conséquent, utilisez l'exemple de John pour le fichier main.js le code équivalent que l'on trouverait normalement est:

app.get('/',(req, res) {
    res.render('index', { title: 'Express' });
});
0
JosephK