1. Installation
$ npm install express
oder Verwenden Sie es überall. Ausführbare Express(1)-Installation:
# Übersetzungshinweis: Diese Methode wird dringend empfohlen
$ npm install - g express
2. Schnell loslegen
Der schnellste Weg, mit Express zu beginnen, besteht darin, die ausführbare Datei express(1) zu verwenden, um eine Anwendung zu generieren, wie unten gezeigt:
Erstellen Sie eine App:
$ npm install -g express
$ express /tmp/foo && cd /tmp/foo
Abhängigkeitspakete installieren:
$ npm install -d
Starten Sie den Server:
$ node app.js
3. Erstellen Sie einen Server
Um eine express.HTTPServer-Instanz zu erstellen, rufen Sie einfach die Methode createServer() auf. Gemeinsam mit diesem Anwendungsbeispiel können wir Routing basierend auf HTTP-Aktionen (HTTP-Verben) definieren, wobei wir app.get() als Beispiel nehmen:
var app = require('express').createServer();
app.get('/', function(req, res){
res.send('hello world');
});
app.listen(3000);
4. Erstellen Sie einen HTTPS-Server
Initialisieren Sie eine express.HTTPSServer-Instanz wie oben. Dann übergeben wir ihm ein Konfigurationsobjekt, das Schlüssel, Zertifikat und andere (Eigenschaften/Methoden) akzeptiert, die in der https-Dokumentation erwähnt werden.
var app = require('express') .createServer( { key: ... });
5. Konfiguration
Express unterstützt jede Umgebung, wie Produktion und Entwicklung. Entwickler können die Methode configure() verwenden, um die aktuell erforderliche Umgebung festzulegen. Wenn der Aufruf von configure() keine Umgebungsnamen enthält, werden die angegebenen Rückrufe in allen Umgebungen ausgeführt.
Anmerkung: Aliase wie Produktion/Entwicklung/Stufe können von Ihnen selbst ausgewählt werden, wie in app.configure in application.js gezeigt. Sehen Sie sich das Beispiel unten für die tatsächliche Verwendung an.
Das folgende Beispiel löst während der Entwicklungsphase nur dumpExceptions aus (löst einen Fehler aus) und gibt eine Stack-Ausnahme zurück. Aber in beiden Umgebungen verwenden wir methodOverride und bodyParser. Achten Sie auf die Verwendung von app.router. Es kann (optional) zum Laden (Mounten) der Route des Programms verwendet werden. Darüber hinaus wird der erste Aufruf von app.get(), app.post() usw. durchgeführt Laden Sie auch die Route.
app.configure(function(){
app .use(express.methodOverride());
app.use(express.bodyParser());
app.use(app.router);
});
app.configure('development', function(){
app.use(express.static(__dirname '/public'));
app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
});
app.configure('produktion', function(){
var oneYear = 31557600000;
app.use(express.static(__dirname '/public', { maxAge: oneYear }));
app.use(express.errorHandler());
});
Für ähnliche Umgebungen können Sie mehrere Umgebungszeichenfolgen übergeben:
app.configure('stage', 'prod', function(){
// config
});
Für jede interne Einstellung (#) bietet Express die Methoden set(key[, val]), enable(key) und Disable(key):
Anmerkung: Einzelheiten zu den Einstellungen finden Sie unter: app.set in application.js.
app.configure(function(){
app .set('views', __dirname '/views');
app.set('views');
// => "/absolute/path/to/views"
app.enable('some feature');
// Äquivalent zu: app.set('some feature', true);
app.disable('some feature');
// Entspricht: app.set('some feature', false);
app.enabled('some feature')
// => false
});
Um die Umgebung zu ändern, können wir die Umgebungsvariable NODE_ENV festlegen, wie zum Beispiel:
$ NODE_ENV=Produktionsknoten app.js
Das ist sehr wichtig, da die meisten Caching-Mechanismen nur während der Produktionsphase aktiviert werden.
6. Einstellungen
Express unterstützt die folgenden Standardeinstellungen:
1.basepath Der Basispfad der Anwendung, die für res.redirect() verwendet wird und gemountete Apps explizit verarbeitet.
2.view Das Standardstammverzeichnis von View Für CWD/views
3.view engine Der Standard Für die View-Engine-Verarbeitung (Dateien anzeigen) muss nicht das Suffix
4.view-Cache verwendet werden. View-Cache aktivieren (in der Produktionsphase aktiviert)
5.charet Codierung ändern. Der Standardwert ist utf-8
6 .Case-sensitive Routen berücksichtigen beim Routing die Groß- und Kleinschreibung
7.strit-Routing Nach der Aktivierung (im Routing) wird das nachfolgende / nicht ignoriert (Anmerkung: app.get('/sofish ') und app.get('/sofish/ ') wird unterschiedlich sein)
8.json-Callback aktiviert res.send() / res.json() explizite JSONP-Unterstützung (transparente JSONP-Unterstützung)
7. Routing
Express bietet eine Reihe informativer und ausdrucksstarker Routing-APIs mithilfe von HTTP-Aktionen. Wenn wir beispielsweise einen Account mit dem Pfad /user/12 bearbeiten möchten, können wir die Route wie folgt definieren. Auf mit benannten Platzhaltern verknüpfte Werte kann über req.params zugegriffen werden.
app.get('/user/: id', function(req, res){
res.send('user ' req.params.id);
});
Die Route ist eine Zeichenfolge, die intern in a kompiliert wird normale Zeichenfolge. Wenn beispielsweise /user/:id kompiliert wird, sieht eine vereinfachte Version des regulären Ausdrucks so aus:
// Ändern Sie die offizielle Zeichenfolge
//user/([^/] )/?/
Reguläre Ausdrücke können an übergeben werden Auf komplexe Szenen anwenden. Da über literale reguläre Ausdrücke erfasste Inhaltsgruppen anonym sind, können wir über req.params direkt auf sie zugreifen. Daher wird der erste Satz von Inhalten, den wir erfassen, req.params[0] sein, während der zweite Satz direkt auf req.params[1] folgt.
app.get(/^/users? (?: /(d )(?:..(d ))?)?/, function(req, res){
res.send(req.params);
});
Curl Für die Anfrage der oben definierten Route:
$ curl http://dev:3000/user
[null,null]
$ curl http://dev:3000/users
[null,null]
$ curl http://dev:3000/users /1
["1",null]
$ curl http://dev:3000/users/1..15
["1",15 "]
unten Es handelt sich um Beispiele einiger Routen, die mit den Pfaden verknüpft sind, die sie möglicherweise verwenden:
"/user/:id"
/user/12
"/users/:id?"
/users/5
/users
"/files/*"
/files/jquery.js
/files/javascripts/jquery.js
"/file/*.*"
/files/jquery.js
/files/javascripts/jquery.js
"/user/:id/:operation?"
/user/1
/user/1/edit
"/products.:format"
/products.json
/products.xml
"/products.:format?"
/products.json
/products.xml
/products
"/user/:id.:format?"
/user/12
/user/12.json
Zum Beispiel können wir POST verwenden, um JSON-Daten über bodyParser This zu senden Middleware kann JSON-Anforderungsinhalte (oder andere Inhalte) analysieren, um Daten zurückzugeben und das Rückgabeergebnis in req.body zu speichern:
var express = require('express')
, app = express.createServer();
app.use(express.bodyParser());
app.post('/', function(req, res){
res.send(req.body);
});
app.listen(3000);
Normalerweise können wir einen „dummen“ Platzhalter wie user/:id verwenden, der keine (Benennungs-)Einschränkungen hat. Wenn wir jedoch beispielsweise die Benutzer-ID nur auf Zahlen beschränken möchten, können wir /user/:id([0-9]) verwenden, was nur dann wirksam wird, wenn der Platzhalter mindestens eine Ziffer enthält (Anpassung, übereinstimmen).
8. Passieren der Routenkontrolle
Wir können die nächste angepasste Route steuern, indem wir den dritten Parameter, die Funktion next(), aufrufen. Wenn kein Adapter gefunden wird, wird die Steuerung an Connect zurückgegeben und die Middleware wird in der in use() hinzugefügten Reihenfolge aufgerufen. Das gleiche Prinzip gilt für mehrere Routen, die für denselben Pfad definiert sind. Sie werden nacheinander aufgerufen, bis eine von ihnen beschließt, auf die Anfrage zu antworten, ohne next() aufzurufen.
app.get('/users/: id?' , function(req, res, next){
var id = req.params.id;
if (id) {
// etwas tun
} else {
next ();
}
});
app.get('/users', function(req, res){
// etwas anderes machen
});
app.all()-Methode muss nur aufgerufen werden Einmal Wenden Sie bequem dieselbe Logik auf alle HTTP-Aktionen an. Im Folgenden verwenden wir dies, um einen Benutzer aus den Dummy-Daten zu extrahieren und ihn req.user zuzuweisen.
var express = require('express')
, app = express.createServer();
var user = [{ name: 'tj' }];
app.all('/user/:id/:op?', function(req, res, next){
req.user = users[req.params.id];
if (req .user) {
next();
} else {
next(new Error('cannot find user ' req.params.id));
}
});
app.get('/user/:id', function(req, res){
res.send('viewing ' req.user.name);
});
app.get('/user/:id/edit', function(req, res){
res.send('editing ' req.user.name);
});
app.put('/user/:id', function(req, res){
res.send('updating ' req.user.name);
});
app.get('*', function(req, res){
res.send(404, 'what???');
});
app.listen(3000);
9. Middleware
Die verwendete Connect-Middleware (Eigenschaften) gehört normalerweise zu einem Ihrer regulären Connect-Server und wird an express.createServer() übergeben. Zum Beispiel:
var express = require(' Express');
var app = express.createServer(
express.logger()
, express.bodyParser()
);
Außerdem innerhalb des configure()-Blocks – dieser progressive In progressiver Weise können wir auch ganz einfach use() verwenden, um Middleware hinzuzufügen.
app.use(express.logger({ Format: ' :method :url' }));
Normalerweise können Sie bei der Verwendung von Connect-Middleware require('connect') wie folgt verwenden:
var connect = require('connect');
app.use(connect.logger());
app.use(connect.bodyParser()) ;
Das ist etwas ärgerlich, daher exportiert Express diese Middleware-Eigenschaften erneut, obwohl sie gleich sind:
app.use(express.logger());
app.use(express.bodyParser());
Die Reihenfolge der Middleware ist sehr wichtig. Wenn Connect eine Anfrage erhält, wird die erste Middleware, die wir zur Ausführung übergeben, drei Parameter enthalten: Anfrage, Antwort und eine Rückruffunktion (normalerweise als nächstes). Wenn next() aufgerufen wird, ist die zweite Middleware an der Reihe und so weiter. Dies ist bemerkenswert, da viele Middlewares voneinander abhängig sind. Beispielsweise fragt methodOverride() die Methode req.body ab, um HTTP-Methodenüberladungen zu erkennen, während bodyParser() den Anforderungsinhalt analysiert und im req.body speichert. Ein weiteres Beispiel ist das Parsen von Cookies und die Sitzungsunterstützung. Wir müssen zuerst () cookieParser() und dann session() verwenden.
Viele Express-Anwendungen enthalten eine Zeile wie app.use(app.router). Das mag etwas seltsam erscheinen, aber in Wirklichkeit handelt es sich lediglich um eine Zeile, die alle definierten Routing-Regeln enthält und eine Routensuche basierend auf den vorhandenen durchführt URL-Anfrage und HTTP-Methode. Mit Express können Sie die Position bestimmen, standardmäßig wird sie jedoch unten platziert. Durch Ändern des Speicherorts der Route können wir die Priorität der Middleware ändern. Beispielsweise möchten wir, dass die letzte Middleware Fehler meldet, damit alle an next() übergebenen Ausnahmen verarbeitet werden können Die Dienstpriorität ist niedriger, damit unser Router auf die Anzahl der Downloads einer einzelnen statischen Dateianforderung usw. warten kann. Das sieht ungefähr so aus:
app.use( express.logger(...));
app.use(express.bodyParser(...));
app.use(express.cookieParser(...));
app.use (express.session(...));
app.use(app.router);
app.use(express.static(...));
app.use (express.errorHandler (...));
Zuerst fügen wir logger() hinzu, das die req.end()-Methode des Knotens enthalten kann, um uns Antwortzeitdaten bereitzustellen. Der Inhalt der nächsten Anfrage wird analysiert (sofern Daten vorhanden sind), gefolgt von der Cookie-Analyse und der Sitzungsunterstützung. Gleichzeitig wird req.session definiert, wenn die Route in app.router aufgerufen wird zu diesem Zeitpunkt. next(), sodass die static()-Middleware diese Anfrage nicht kennt. Wenn die folgende Route definiert wurde, können wir verschiedene Status aufzeichnen, Downloads ablehnen, Download-Punkte verbrauchen usw.
var downloads = {};
app.use(app.router);
app.use(express.static(__dirname '/public'));
app.get('/*', function(req, res, next){
var file = req.params[0];
downloads[file] = downloads[file] || 0;
lädt[Datei] herunter ;
next();
});
10. Routing-Middleware
Routing kann Router-Middleware verwenden, um mehr als eine Rückruffunktion (oder ein Array) an seine Methode zu übergeben. Diese Funktion eignet sich hervorragend zum Einschränken des Zugriffs, zum Herunterladen von Daten über Routing usw.
Normalerweise sieht der asynchrone Datenabruf wie im folgenden Beispiel aus, in dem wir den Parameter :id verwenden und versuchen, einen Benutzer zu laden:
app.get('/user/:id', function(req, res, next){
loadUser(req.params.id , function(err, user ){
if (err) return next(err);
res.send('Viewing user ' user.name);
});
});
ist Um das DRY-Prinzip sicherzustellen und die Lesbarkeit zu verbessern, können wir diese Logik innerhalb einer Middleware anwenden. Wie unten gezeigt, ermöglicht Ihnen die Abstraktion dieser Logik in Middleware, sie wiederzuverwenden und gleichzeitig unser Routing einfach zu halten.
function loadUser(req, res, next) {
// Sie würden Ihren Benutzer aus der Datenbank abrufen
var user = users[req.params.id];
if (user ) {
req.user = user;
next();
} else {
next(new Error('Failed to load user ' req.params.id));
}
}
app.get('/user/:id', loadUser, function(req, res){
res.send('Viewing user ' req.user.name);
});
Mehrere Routen können nacheinander auf eine tiefere Logik angewendet werden, beispielsweise um den Zugriff auf ein Benutzerkonto einzuschränken. Im folgenden Beispiel können nur authentifizierte Benutzer ihr Konto bearbeiten.
function andRestrictToSelf(req, res, next) {
req.authenticatedUser.id == req.user.id
? next()
: next(new Error('Unauthorized'));
}
app.get('/user/:id/edit', loadUser, andRestrictToSelf, function(req, res){
res.send('Editing user ' req.user.name);
} );
Denken Sie immer daran, dass Routen nur einfache Funktionen sind. Wie unten gezeigt, können wir Funktionen definieren, die Middleware zurückgeben, um eine ausdrucksstärkere und flexiblere Lösung zu erstellen.
Funktion und RestrictTo(role) {
return function( req, res, next) {
req.authenticatedUser.role == Role
? next()
: next(new Error('Unauthorized'));
}
}
app.del('/user/:id', loadUser, andRestrictTo('admin'), function(req, res){
res.send('Deleted user ' req.user.name);
});
Häufig verwendete Middleware-„Stacks“ können durch ein Array geleitet werden (werden rekursiv angewendet), das auf jeder Ebene gemischt und angepasst werden kann (die in jedem Grad gemischt und angepasst werden kann) .
var a = [middleware1, middleware2]
, b = [middleware3, middleware4]
, all = [a, b];
app.get('/foo', a, function(){});
app.get('/bar', a, function(){});
app.get('/', a, middleware3, middleware4, function(){});
app.get('/', a, b, function(){});
app .get('/', all, function(){});
Den vollständigen Code dieses Beispiels finden Sie im Routen-Middleware-Beispiel-Repository.
Möglicherweise möchten wir die verbleibende Routing-Middleware viele Male „überspringen“ und weiterhin nachfolgende Routen abgleichen. Dazu rufen wir einfach next() mit der Zeichenfolge „route“ auf – next(‘route’). Wenn keine verbleibenden Routen mit der angeforderten URL übereinstimmen, gibt Express 404 Not Found zurück.
11. HTTP-Methode
Ich bin bisher mehrmals auf app.get() gestoßen. Darüber hinaus bietet Express auch andere gängige HTTP-Aktionen wie app.post(), app.del() usw.
Ein häufiges Beispiel für die Verwendung von POST ist das Absenden eines Formulars. Als nächstes setzen wir einfach das Methodenattribut des Formulars auf „Post in HTML“, und die Steuerung wird der unten definierten Route zugewiesen.
Standardmäßig weiß Express nicht, wie es mit dem Inhalt dieser Anfrage umgehen soll, daher haben wir Sie müssen die BodyParser-Middleware hinzufügen. Sie analysiert den von application/x-www-form-urlencoded und application/json angeforderten Inhalt und speichert die Variablen in req.body. Wir können diese Middleware wie im folgenden Beispiel verwenden:
app.use(express.bodyParser());
Wie unten gezeigt, hat unsere Route Zugriff auf das req.body.user-Objekt, das bei der Definition Name und E-Mail enthält (Anmerkung: Wenn der vom Formular gesendete Inhalt nicht leer ist).
app.post('/', function (req, res){
console.log(req.body.user);
res.redirect('back');
});
Wenn Sie etwas verwenden möchten wie PUT in einem Formular Auf diese Weise können wir eine versteckte Eingabe namens _method verwenden, mit der die HTTP-Methode geändert werden kann. Dazu benötigen wir zunächst die Middleware methodOverride, die nach dem bodyParser erscheinen muss, um die in seinem req.body enthaltenen Formularwerte zu verwenden.
app.use(express.bodyParser() );
app.use(express.methodOverride());
Warum diese Methoden nicht standardmäßig verfügbar sind, einfach weil sie nicht für die vollständige Funktionalität erforderlich sind, die Express erfordert. Die Verwendung von Methoden hängt von Ihrer Anwendung ab. Möglicherweise benötigen Sie sie nicht. Der Client kann weiterhin Methoden wie PUT und DELETE verwenden. Sie können sie direkt verwenden, da methodOverride eine sehr gute Lösung für Formulare darstellt. Im Folgenden wird die Verwendung der PUT-Methode demonstriert, die wie folgt aussehen kann:
app.put('/', function(){
console.log(req.body.user);
res.redirect('back');
});
12. Fehlerbehandlung
Express stellt die Methode app.error() bereit, damit die empfangene Ausnahme in eine Route geworfen oder an next(err) übergeben werden kann. Das folgende Beispiel behandelt verschiedene Seiten basierend auf einer bestimmten NotFound-Ausnahme:
function NotFound(msg){
this.name = 'NotFound';
Error.call(this, msg);
Error.captureStackTrace(this, arguments.callee);
}
NotFound.prototype.__proto__ = Error.prototype;
app.get('/404', function(req, res){
throw new NotFound;
});
app.get('/500', function(req, res){
throw new Error('keyboard cat!');
});
Wie folgt können wir App.error() mehrmals aufrufen. Hier erkennen wir Instanzen von NotFound und zeigen entweder eine 404-Seite an oder übergeben sie an den nächsten Fehlerhandler. Es ist erwähnenswert, dass diese Handler überall definiert werden können, da sie während listen() unter dem Routenhandler platziert werden. Es ermöglicht Definitionen innerhalb des configure()-Blocks, sodass wir je nach Umgebung unterschiedliche Ausnahmebehandlungsmethoden verwenden können.
app.error(function(err, req , res, next){
if (err Instanz von NotFound) {
res.render('404.jade');
} else {
next(err);
}
}) ;
Der Einfachheit halber gehen wir hier davon aus, dass alle Fehler in dieser Demo 500 sind. Natürlich können Sie den Fehler auswählen, der Ihnen gefällt. Wenn der Knoten einen Systemaufruf im Dateisystem ausführt, erhalten Sie möglicherweise einen Fehlercode mit ENOENT, was bedeutet, dass „keine solche Datei oder kein solches Verzeichnis vorhanden“ ist. Wir können ihn im Fehlerhandler verwenden, oder wenn eine bestimmte Seite vorhanden ist bei Bedarf angezeigt werden.
app.error(function(err, req , res) {
res.render('500.jade', {
error: err
});
});
Unsere App kann auch die errorHandler-Middleware von Connect verwenden, um Ausnahmen zu melden. Wenn wir beispielsweise stderr-Ausnahmen in der „Entwicklungs“-Umgebung ausgeben möchten, können wir Folgendes verwenden:
app.use(express.errorHandler({ dumpExceptions: true }));
Gleichzeitig während der Entwicklungsphase müssen wir möglicherweise die Ausnahmen anzeigen Wir übergeben und werfen ausgefallene HTML-Seiten. Dazu können wir showStack auf true setzen.
app.use(express.errorHandler({ showStack: true , dumpExceptions: true }));
errorHandler-Middleware kann auch JSON zurückgeben, wenn Accept: application/json vorhanden ist, was sehr nützlich für die Entwicklung von Anwendungen ist, die stark auf clientseitigem Javascript basieren.
13. Routenparameter-Vorverarbeitung
Die Vorverarbeitung von Routenparametern durch implizites Laden von Daten und Anforderungsüberprüfung kann die Lesbarkeit Ihres Programms erheblich verbessern. Beispielsweise müssen Sie häufig kontinuierlich Basisdaten von mehreren Routen abrufen. So wie das Laden eines Benutzers mit /user/:id, machen wir es normalerweise so:
app.get('/user/:userId', function(req, res, next){
User.get(req.params.userId, function(err, user) {
if (err) return next(err);
res.send('user ' user.name);
});
});
Durch Vorverarbeitung, Wir Parameter können Rückrufen zugeordnet werden, die eine Validierung, Kontrolle (Zwang) durchführen oder sogar Daten aus der Datenbank laden. Im Folgenden rufen wir app.param() mit dem Parameternamen auf, in der Hoffnung, ihn einer Middleware zuzuordnen. Wie Sie sehen, akzeptieren wir den Parameter id, der den Platzhalterwert darstellt. Auf diese Weise laden wir den Benutzer und behandeln Fehler wie gewohnt und rufen einfach next() auf, um die Steuerung an den nächsten Präprozessor oder Routenhandler zu übergeben.
app.param('userId', function (req, res, next, id){
User.get(id, function(err, user){
if (err) return next(err);
if (!user) return next( new Error( 'failed to find user'));
req.user = user;
next();
});
});
Sobald dies erledigt ist , Das oben Genannte Verbessert die Lesbarkeit des Routings erheblich und ermöglicht es uns, die Logik problemlos im gesamten Programm zu teilen:
app.get('/user/:userId', function(req, res){
res.send('user ' req.user.name);
} );
14. Verarbeitung anzeigen
Ansichtsdateien verwenden das Format ., wobei der Name des erforderlichen Moduls ist. Zum Beispiel weist layout.ejs das Ansichtssystem an, „rejs“ zu erfordern, das geladene Modul muss die Methode „exports.compile(str, options)“ (exportieren) und eine Funktion zurückgeben, um Express zu unterstützen. app.register() kann verwendet werden, um dieses Standardverhalten zu ändern und Dateierweiterungen einer bestimmten Engine zuzuordnen. Beispielsweise kann „foo.html“ von ejs verarbeitet werden.
Das folgende Beispiel verwendet Jade, um index.html zu verarbeiten. Da wir „layout: false“ nicht verwenden, wird der von „index.jade“ verarbeitete Inhalt an eine lokale Variable namens „body“ in „layout.jade“ übergeben.
app.get('/', function (req, res){
res.render('index.jade', { title: 'My Site' });
});
Mit der neuen Ansichts-Engine-Einstellung können wir angeben Wenn wir beispielsweise Jade verwenden, können wir die Standard-Template-Engine wie folgt festlegen:
app .set('view engine', 'jade');
ermöglicht uns dies:
res.render('index');
entspricht:
res.render('index.jade');
Wenn die View Engine eingestellt ist, ist die Erweiterung optional, wir können aber trotzdem mischen und match Template engine:
res.render(' another-page.ejs');
Express bietet auch Ansichtsoptionen-Einstellungen, die jedes Mal angewendet werden, wenn eine Ansicht gerendert wird. Sie können dies beispielsweise tun, wenn Sie keine Layouts verwenden möchten:
app.set('view options', {
layout: false
});
Dies kann bei Bedarf innerhalb des res.render()-Aufrufs überladen werden:
res.render('myview.ejs', {layout: true });
Wenn es eine gibt Wenn Sie ein Layout ändern müssen, müssen Sie normalerweise einen anderen Pfad angeben. Wenn wir beispielsweise die Ansichts-Engine auf „Jade“ eingestellt haben und die Datei ./views/mylayout.jade heißt, können wir die Parameter einfach wie folgt übergeben:
res.render('page', { layout: 'mylayout' });
Sonst (Anmerkung: Nein Wenn die Ansichts-Engine auf Jade oder andere Engines eingestellt ist), müssen wir eine Erweiterung angeben:
res.render('page', { layout: 'mylayout.jade' });
Sie können auch absolute Pfade sein:
res.render('page', { layout: __dirname '/../../mylayout.jade ' });
Dafür gibt es ein gutes Beispiel – das Anpassen der öffnenden und schließenden Tags von ejs:
app.set('view options', {
open: '{{',
schließen: '}}'
})
15. Komponente anzeigen
Das Ansichtssystem von Express verfügt über integrierte Unterstützung für Teilansichten und Sammlungen, was dem Ersetzen eines Dokumentfragments durch eine „Mini“-Ansicht entspricht. Um beispielsweise Kommentare wiederholt in einer Ansicht anzuzeigen, können wir den Widget-Satz verwenden:
partial('comment', {collection: comments });
Wenn keine anderen Optionen oder lokalen Variablen benötigt werden, können wir das gesamte Objekt weglassen und einfach ein übergeben Array, das dem oben genannten entspricht:
partial('comment', comments);
Im Einsatz bietet das Widget-Set kostenlose Unterstützung für einige „magische“ lokale Variablen:
1.firstInCollection wahr, wenn es das erste Objekt ist
2.indexInCollection Index im Kollektorobjekt
3.lastInCollection wahr, wenn es das letzte Objekt ist
4 .collectionLength Die Länge des Kollektors Objekt
Die Übertragung (Generierung) lokaler Variablen hat eine höhere Priorität. Gleichzeitig werden an die übergeordnete Ansicht übergebene lokale Variablen auch an die untergeordnete Ansicht angepasst. Wenn wir beispielsweise „partial('blog/post', post)“ verwenden, um einen Blog-Beitrag zu rendern, wird eine lokale Variable „post“ in der Ansicht generiert, die diese Funktion aufruft, und sie ist ebenfalls gültig für Blog/Beitrag. (Anmerkung: Teilweise ähnelt hier eher der Include-Methode in PHP).
Hinweis: Bitte verwenden Sie Widget-Sammler mit Vorsicht. Das Rendern eines Widget-Sammlungs-Arrays mit einer Länge von 100 entspricht der Verarbeitung von 100 Ansichten. Bei einfachen Sammlungen ist es besser, die integrierte Funktion zu wiederholen, anstatt einen Widget-Sammler zu verwenden, um übermäßigen Overhead zu vermeiden.
16. Suche anzeigen
Die Ansichtssuche erfolgt relativ zur übergeordneten Ansicht (Pfad). Wenn wir beispielsweise eine Ansichtsseite mit dem Namen „views/user/list.jade“ haben und „partial(‘edit‘)“ darin geschrieben ist, wird dies versucht Wenn Sie „views/user/edit.jade“ laden, lädt „partial(‘../messages‘)“ auch „views/messages.jade“.
Das Ansichtssystem unterstützt auch die Vorlagenindizierung, sodass Sie ein Verzeichnis mit demselben Namen wie die Ansicht verwenden können. Beispielsweise gibt res.render('users') in einer Route „views/users.jade“ zurück, also „views/users/index.jade“. (Anmerkung: Behandeln Sie zuerst den Fall . und dann den Fall /. Einzelheiten finden Sie unter view.js.)
Bei Verwendung des obigen Ansichtsindex verwenden wir „partial(‘users‘“), um auf „views/users/index.jade“ im selben Verzeichnis wie die Ansicht zu verweisen. Gleichzeitig versucht das Ansichtssystem, ../ zu indizieren. Benutzer/Index. Ohne dass wir partielle('Benutzer') aufrufen.
17. Vorlagen-Engines
Die folgenden sind die am häufigsten verwendeten Template-Engines für Express:
1.Haml: Haml-Implementierung
2.Jade: haml.js-Nachfolger
3.EJS: Eingebettetes JavaScript
4.CoffeeKup: Vorlage basierend auf CoffeeScript
5.jQuery-Vorlagen
18. Sitzungsunterstützung
Sitzungsunterstützung kann durch die Verwendung der Sitzungs-Middleware von Connect erreicht werden. Dazu müssen wir normalerweise die CookieParser-Middleware davor hinzufügen, die Cookie-Daten in req.cookies analysiert und speichert.
app.use(express.cookieParser() );
app.use(express.session({ Secret: "keyboard cat" }));
Standardmäßig verwendet die Sitzungs-Middleware den integrierten Speicher von Connect, es gibt jedoch viele andere Implementierungen . Beispielsweise stellt connect-redis einen Redis-Sitzungsspeicher bereit, der wie folgt verwendet werden kann:
var RedisStore = require('connect-redis')(express);
app.use(express.cookieParser());
app.use(express.session( { Secret: "keyboard cat", Store: new RedisStore }));
Zu diesem Zeitpunkt stehen die Eigenschaften req.session und req.sessionStore allen Routen und nachfolgender Middleware zur Verfügung. Alle Eigenschaften auf req.session werden automatisch in einer Antwort gespeichert, beispielsweise wenn wir Daten zum Warenkorb hinzufügen möchten:
var RedisStore = require('connect-redis')(express);
app.use(express.bodyParser());
app .use(express.cookieParser());
app.use(express.session({ Secret: "keyboard cat", store: new RedisStore }));
app.post('/add-to-cart', function(req, res){
// Wir können mehrere Artikel über ein Formular POSTEN
// (verwenden Sie in einigen Fällen bodyParser() Middleware )
var items = req.body.items;
req.session.items = items;
res.redirect('back');
});
app.get('/add-to-cart', function(req, res){
// Bei der Rückgabe wird die Seite GET /add-to-cart
// Wir können req überprüfen. session.items && req.session.items.length
// Um die Eingabeaufforderung auszudrucken
if (req.session.items && req.session.items.length) {
req.notify('info ' , 'Sie haben %s Artikel in Ihrem Warenkorb', req.session.items.length);
}
res.render('shopping-cart');
});
Für req.session gibt es auch Methoden wie Session#touch(), Session#destroy(), Session#regenerate() usw., um die Sitzung aufrechtzuerhalten und zu betreiben. Weitere Einzelheiten finden Sie in der Dokumentation zur Connect-Sitzung.
19. Upgrade-Anleitung
Wenn Studierende, die Express 1.x verwenden, wichtige Programme haben, die für eine bessere Unterstützung auf 2.x aktualisiert werden müssen, lesen Sie bitte den offiziellen, sehr detaillierten Migrationsleitfaden : http://expressjs. com/guide.html#migration-guide
node.js-Debugging
Was sind die Parameter des Festzeltes?
Lösung für fehlgeschlagenes WIN10-Update
Was tun, wenn das Desktopsymbol des Computers nicht geöffnet werden kann?
Wie viel entspricht Snapdragon 8gen2 Apple?
Eine vollständige Liste der Alter-Befehle in MySQL
ISP-Chip
Die jüngsten Markttrends von Ripple
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
