Variable global en app.js accesible en rutas?

¿Cómo configuro una variable app.jsy la tengo disponible en todas las rutas, al menos en el index.jsarchivo ubicado en las rutas? utilizando el marco express ynode.js

Para hacer una variable global, simplemente declare sin la varpalabra clave. (En términos generales, esta no es la mejor práctica, pero en algunos casos puede ser útil; solo tenga cuidado, ya que hará que la variable esté disponible en todas partes).

Aquí hay un ejemplo de visionmedia / screenshot-app

archivo app.js :

/**
 * Module dependencies.
 */

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

app = express();

//... require() route files

rutas de archivo / 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');
});

//...

En realidad, es muy fácil hacer esto usando los métodos "set" y "get" disponibles en un objeto express.

Ejemplo de la siguiente manera, digamos que tiene una variable llamada config con las cosas relacionadas con su configuración que desea que estén disponibles en otros lugares:

En app.js:

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

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

En rutas / index.js

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

Una forma ordenada de hacer esto es utilizando el app.localspropio Express. Aquí está la documentación.

// 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;
}

Para declarar una variable global, debe utilizar un objeto global . Como global.yourVariableName. Pero no es una verdadera forma. Para compartir variables entre módulos, intente usar un estilo de inyección como

someModule.js:

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

app.js

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

O puede usar un objeto sustituto para hacer eso. Como 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');

A continuación se explican bien, en resumen:

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

Entonces, está trabajando con un conjunto de módulos de nodo, tal vez un marco como Express.js, y de repente siente la necesidad de hacer que algunas variables sean globales. ¿Cómo se hacen las variables globales en Node.js?

El consejo más común para este es "declarar la variable sin la palabra clave var" o "agregar la variable al objeto global" o "agregar la variable al objeto GLOBAL". Cual usas?

En primer lugar, analicemos el objeto global. Abra una terminal, inicie un REPL de nodo (indicador).

> 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'

la forma más fácil es declarar una variable global en su app.js, desde el principio:

global.mySpecialVariable = "something"

entonces en cualquier ruta puedes conseguirlo:

console.log(mySpecialVariable)

Esta fue una pregunta útil, pero podría ser más importante si proporciona ejemplos de código reales. Incluso el artículo vinculado no muestra realmente una implementación. Por tanto, humildemente me someto:

En su app.jsarchivo, la parte superior del archivo:

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 no tendrá ninguna referencia al app.get()método. Deje que se definan en los archivos de rutas individuales.

routes/index.js:

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

y, por último, un archivo de rutas reales, 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

Mi forma preferida es usar dependencias circulares *, que el nodo admite

• en app.js define var app = module.exports = express();como su primera orden del día
• Ahora cualquier módulo requerido después del hecho puede var app = require('./app')acceder a él.

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

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

Como otros ya han compartido, app.set('config', config)es genial para esto. Solo quería agregar algo que no vi en las respuestas existentes que es bastante importante. Una instancia de Node.js se comparte en todas las solicitudes, por lo que, si bien puede ser muy práctico compartir algunos configu routerobjetos de forma global, el almacenamiento de datos en tiempo de ejecución de forma global estará disponible para todas las solicitudes y usuarios . Considere este ejemplo muy 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 visita /bary recibe otra solicitud /foo, su mensaje será "¡Bienvenido a foo!". Este es un ejemplo tonto, pero transmite el mensaje.

Hay algunos puntos interesantes sobre esto en ¿Por qué las diferentes sesiones de node.js comparten variables? .

Resolví el mismo problema, pero tuve que escribir más código. Creé un server.jsarchivo, que usa express para registrar rutas. Expone una función, registerque puede ser utilizada por otros módulos para registrar sus propias rutas. También expone una función startServer, para empezar a escuchar un puerto

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
}

En otro módulo, use este archivo para crear una ruta.

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
}

En el archivo principal, arranque ambos.

app.js

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

La respuesta de John Gordon fue la primera de docenas de respuestas a medio explicar / documentadas que probé, en muchos, muchos sitios, que realmente funcionaron. Gracias, señor Gordon. Lo siento, no tengo los puntos para mejorar tu respuesta.

Me gustaría agregar, para otros novatos en node-route-file-splitting, que el uso de la función anónima para 'índice' es lo que uno verá más a menudo, por lo que usando el ejemplo de John para main.js, el funcionalmente- el código equivalente que uno encontraría normalmente es:

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

Solía app.all

El método app.all () es útil para mapear la lógica "global" para prefijos de ruta específicos o coincidencias arbitrarias.

En mi caso, estoy usando confit para la gestión de la configuración,

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();
    });
});

En rutas, simplemente haces req.app.get('config').get('cookie');

esto es bastante fácil, pero las respuestas de las personas son confusas y complejas al mismo tiempo.

déjame mostrarte cómo puedes establecer una variable global en tu expressaplicación. Para que pueda acceder a él desde cualquier ruta según sea necesario.

Digamos que desea establecer una variable global de su /ruta principal

router.get('/', (req, res, next) => {

  req.app.locals.somethingNew = "Hi setting new global var";
});

Entonces obtendrás req.app de todas las rutas. y luego tendrá que usar localspara establecer datos globales en. como arriba muestra que estás listo. ahora te mostraré cómo usar esos datos

router.get('/register', (req, res, next) => {

  console.log(req.app.locals.somethingNew);
});

Como arriba, desde la registerruta a la que está accediendo, los datos se establecieron anteriormente.

¡Así es como puedes hacer que esto funcione!