Wie erstelle ich globale Variablen, auf die in allen Ansichten mit Express / Node.JS zugegriffen werden kann?

Ok, ich habe ein Blog mit Jekyll erstellt und Sie können Variablen in einer Datei definieren, auf _config.ymldie in allen Vorlagen / Layouts zugegriffen werden kann. Ich verwende derzeit Node.JS / Express mit EJS- Vorlagen und EJS-Locals (für Partials / Layouts. Ich möchte etwas Ähnliches tun wie die globalen Variablen site.title, die in enthalten sind, _config.ymlwenn jemand mit Jekyll vertraut ist. Ich habe Variablen wie die Titel der Site (anstelle des Seitentitels), Autor / Firmenname, die auf allen meinen Seiten gleich bleiben.

Hier ist ein Beispiel dafür, was ich gerade mache:

exports.index = function(req, res){
    res.render('index', { 
        siteTitle: 'My Website Title',
        pageTitle: 'The Root Splash Page',
        author: 'Cory Gross',
        description: 'My app description',
        indexSpecificData: someData
    });
};

exports.home = function (req, res) {
    res.render('home', {
        siteTitle: 'My Website Title',
        pageTitle: 'The Home Page',
        author: 'Cory Gross',
        description: 'My app description',
        homeSpecificData: someOtherData
    });
};

Ich möchte in der Lage sein, Variablen wie Titel, Beschreibung, Autor usw. meiner Site an einem Ort zu definieren und sie über EJS in meinen Layouts / Vorlagen zugänglich zu machen, ohne sie als Optionen an jeden Aufruf von übergeben zu müssen res.render. Gibt es eine Möglichkeit, dies zu tun und mir trotzdem zu erlauben, andere für jede Seite spezifische Variablen zu übergeben?

Nachdem ich die Express 3 API-Referenz etwas genauer studiert hatte, entdeckte ich, wonach ich suchte. Insbesondere die Einträge für app.localsund dann etwas weiter unten res.localsenthielten die Antworten, die ich brauchte.

Ich habe selbst festgestellt, dass die Funktion app.localsein Objekt verwendet und alle seine Eigenschaften als globale Variablen für die Anwendung speichert. Diese Globals werden als lokale Variablen an jede Ansicht übergeben. Die Funktion res.localsist jedoch auf die Anforderung beschränkt, und daher sind lokale Antwortvariablen nur für die Ansichten zugänglich, die während dieser bestimmten Anforderung / Antwort gerendert wurden.

Also für meinen Fall in meinem, app.jswas ich getan habe, war hinzuzufügen:

app.locals({
    site: {
        title: 'ExpressBootstrapEJS',
        description: 'A boilerplate for a simple web application with a Node.JS and Express backend, with an EJS template with using Twitter Bootstrap.'
    },
    author: {
        name: 'Cory Gross',
        contact: 'CoryG89@gmail.com'
    }
});

Dann alle diese Variablen sind zugänglich in meinen Ansichten wie site.title, site.description, author.name, author.contact.

Ich könnte auch lokale Variablen für jede Antwort auf eine Anfrage mit definieren res.localsoder einfach Variablen wie den Seitentitel als optionsParameter im renderAufruf übergeben.

EDIT: Diese Methode wird nicht ermöglichen es Ihnen , diese Einheimischen in Ihrer Middleware zu verwenden. Ich bin tatsächlich darauf gestoßen, wie Pickels im Kommentar unten vorschlägt. In diesem Fall müssen Sie in seiner alternativen (und geschätzten) Antwort eine Middleware-Funktion als solche erstellen. Ihre Middleware-Funktion muss sie res.localsfür jede Antwort hinzufügen und dann aufrufen next. Diese Middleware-Funktion muss über jeder anderen Middleware platziert werden, die diese Einheimischen verwenden muss.

BEARBEITEN: Ein weiterer Unterschied zwischen der Deklaration von Einheimischen über app.localsund res.localsbesteht darin, dass app.localsdie Variablen ein einziges Mal festgelegt werden und während der gesamten Lebensdauer der Anwendung bestehen bleiben. Wenn Sie Einheimische mit res.localsin Ihrer Middleware festlegen, werden diese jedes Mal festgelegt, wenn Sie eine Anfrage erhalten. Grundsätzlich sollten Sie das Setzen von Globals über bevorzugen, es sei app.localsdenn, der Wert hängt von der Anforderungsvariablen ab req, die an die Middleware übergeben wird. Wenn sich der Wert nicht ändert, ist es effizienter, ihn nur einmal einzustellen app.locals.

Sie können dies tun, indem Sie sie dem lokalen Objekt in einer allgemeinen Middleware hinzufügen.

app.use(function (req, res, next) {
   res.locals = {
     siteTitle: "My Website's Title",
     pageTitle: "The Home Page",
     author: "Cory Gross",
     description: "My app's description",
   };
   next();
});

Locals ist auch eine Funktion, die das lokale Objekt erweitert, anstatt es zu überschreiben. Das Folgende funktioniert also auch

res.locals({
  siteTitle: "My Website's Title",
  pageTitle: "The Home Page",
  author: "Cory Gross",
  description: "My app's description",
});

Vollständiges Beispiel

var app = express();

var middleware = {

    render: function (view) {
        return function (req, res, next) {
            res.render(view);
        }
    },

    globalLocals: function (req, res, next) {
        res.locals({ 
            siteTitle: "My Website's Title",
            pageTitle: "The Root Splash Page",
            author: "Cory Gross",
            description: "My app's description",
        });
        next();
    },

    index: function (req, res, next) {
        res.locals({
            indexSpecificData: someData
        });
        next();
    }

};


app.use(middleware.globalLocals);
app.get('/', middleware.index, middleware.render('home'));
app.get('/products', middleware.products, middleware.render('products'));

Ich habe auch eine generische Render-Middleware hinzugefügt. Auf diese Weise müssen Sie nicht jeder Route res.render hinzufügen, was bedeutet, dass Sie den Code besser wiederverwenden können. Sobald Sie die wiederverwendbare Middleware-Route eingeschlagen haben, werden Sie feststellen, dass Sie viele Bausteine ​​haben, die die Entwicklung enorm beschleunigen.

Für Express 4.0 stellte ich fest, dass die Verwendung von Variablen auf Anwendungsebene etwas anders funktioniert und Corys Antwort bei mir nicht funktioniert hat.

Aus den Dokumenten: http://expressjs.com/en/api.html#app.locals

Ich habe festgestellt, dass Sie eine globale Variable für die App in deklarieren können

app.locals

z.B

app.locals.baseUrl = "http://www.google.com"

Und dann können Sie in Ihrer Anwendung auf diese Variablen zugreifen und in Ihrer Express-Middleware können Sie im req-Objekt als auf sie zugreifen

req.app.locals.baseUrl

z.B

console.log(req.app.locals.baseUrl)
//prints out http://www.google.com

In Ihrer app.js müssen Sie so etwas hinzufügen

global.myvar = 100;

Jetzt können Sie in all Ihren Dateien, in denen Sie diese Variable verwenden möchten, einfach als darauf zugreifen myvar

Eine Möglichkeit, dies zu tun, besteht darin, die app.localsVariable für diese App in zu aktualisierenapp.js

Stellen Sie Folgendes ein

var app = express();
app.locals.appName = "DRC on FHIR";

Zugang erhalten

app.listen(3000, function () {
    console.log('[' + app.locals.appName + '] => app listening on port 3001!');
});

Ausarbeitung eines Screenshots aus dem @ RamRovi-Beispiel mit geringfügiger Verbesserung.

Sie können auch "global" verwenden

Beispiel:

deklarieren Sie wie folgt:

  app.use(function(req,res,next){
      global.site_url = req.headers.host;   // hostname = 'localhost:8080'
      next();
   });

Verwendung wie folgt: in beliebigen Ansichten oder EJS-Dateien <% console.log (site_url); %>

in js-Dateien console.log (site_url);

Mit den unterschiedlichen Antworten habe ich diesen Code implementiert, um eine externe Datei JSON zu verwenden, die in "app.locals" geladen ist.

Parameter

{
    "web": {
        "title" : "Le titre de ma Page",
        "cssFile" : "20200608_1018.css"
    }
}

Anwendung

var express     = require('express');
var appli       = express();
var serveur     = require('http').Server(appli);

var myParams    = require('./include/my_params.json');
var myFonctions = require('./include/my_fonctions.js');

appli.locals = myParams;

EJS Seite

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title><%= web.title %></title>
    <link rel="stylesheet" type="text/css" href="/css/<%= web.cssFile %>">
</head>

</body>
</html>

Ich hoffe, es wird helfen

Um einen verschmutzten globalen Bereich zu vermeiden, erstelle ich ein Skript, das ich überall einfügen kann.

// my-script.js
const ActionsOverTime = require('@bigteam/node-aot').ActionsOverTime;
const config = require('../../config/config').actionsOverTime;
let aotInstance;

(function () {
  if (!aotInstance) {
    console.log('Create new aot instance');
    aotInstance = ActionsOverTime.createActionOverTimeEmitter(config);
  }
})();

exports = aotInstance;

Dadurch wird nur einmal eine neue Instanz erstellt und diese überall dort freigegeben, wo die Datei enthalten ist. Ich bin nicht sicher, ob dies daran liegt, dass die Variable zwischengespeichert ist oder an einem internen Referenzmechanismus für die Anwendung (der möglicherweise das Zwischenspeichern umfasst). Alle Kommentare dazu, wie der Knoten dies löst, wären großartig.

Vielleicht lesen Sie auch dies, um zu erfahren, wie die Anforderungen funktionieren: http://fredkschott.com/post/2014/06/require-and-the-module-system/