express()

express()Wird verwendet, um eine Express-Anwendung zu erstellen.express()Die Methode istexpresseine vom Modul exportierte Top-Level-Methode.

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

Methoden

express.static(root, [options])

express.staticEs ist die einzige in Express integrierte Middleware. Sie basiert auf demserver-staticModul und ist für die Bereitstellung statischer Assets in Express-Anwendungen zuständig.rootist das Stammverzeichnis, in dem statische Assets liegen.optionsist optional und unterstützt die folgenden Eigenschaften:

Wenn Sie weitere Details zur Verwendung von Middleware wünschen, lesen SieBereitstellen statischer Dateien in Express。

Application()

appDas app-Objekt stellt im Allgemeinen eine Express-Anwendung dar. Durch Aufrufen der oberstenexpress()-Methode, die vom Express-Modul exportiert wird, um sie zu erstellen:

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

app.get('/', function(req, res) {
    res.send('hello world!');
});

app.listen(3000);

Das app-Objekt hat die folgenden Methoden:

• Routet HTTP-Anfragen; für Details sieheapp.METHODundapp.paramdiese beiden Beispiele.
• Konfiguriert Middleware; für Details sieheapp.route。
• Rendert HTML-Ansichten; für Details sieheapp.render。
• Registriert Template-Engines; für Details sieheapp.engine。

Es verfügt außerdem über einige Eigenschaftseinstellungen, die das Verhalten der Anwendung ändern können. Weitere Informationen finden Sie unterAnwendungseinstellungen。

Eigenschaften

app.locals

Das Objekt app.locals ist ein JavaScript-Objekt, und seine Eigenschaften sind anwendungslokale Variablen.

app.locals.title
// => 'My App'
app.locals.email
// => '[email protected]'

Sobald sie festgelegt wurden, bleiben die Eigenschaftswerte vonapp.localswährend des gesamten Lebenszyklus der Anwendung erhalten. Im Gegensatz dazu istres.localsnur innerhalb des Lebenszyklus der aktuellen Anfrage gültig.

In der Anwendung können Sie diese lokalen Variablen beim Rendern von Vorlagen verwenden. Sie sind sehr nützlich, um Vorlagen hilfreiche Methoden und Daten aufapp-Ebene bereitzustellen. Überreq.app.locals(siehereq.app), können lokale Variablen in Middleware verwendet werden.

app.locals.title = 'My App';
app.locals.strftime = require('strftime');
app.locals.email = '[email protected]';

app.mountpath

app.mountpathDie Eigenschaft ist das Pfadmuster, auf dem eine Unteranwendung montiert ist.

Eine Unteranwendung ist eineexpress-Instanz, die als Routen-Handler verwendet werden kann, um Anfragen zu verarbeiten.

var express = require('express');
var app = express(); // the main app
var admin = express(); // the sub app
admin.get('/', function(req, res) {
    console.log(admin.mountpath); // /admin
    res.send('Admin Homepage');
});
app.use('/admin', admin); // mount the sub app

Es ähnelt der Eigenschaftreq.baseUrldes req-Objekts, außer dass req.baseUrl der passende URL-Pfad ist, nicht das passende Muster. Wenn eine Unteranwendung unter mehreren Pfadmustern montiert ist, ist app.mountpath eine Liste von Mount-Pfadmuster-Einträgen, wie im folgenden Beispiel gezeigt.

var admin = express();

admin.get('/', function (req, res) {
  console.log(admin.mountpath); // [ '/adm*n', '/manager' ]
  res.send('Admin Homepage');
});

var secret = express();
secret.get('/', function (req, res) {
  console.log(secret.mountpath); // /secr*t
  res.send('Admin Secret');
});

admin.use('/secr*t', secret); // load the 'secret' router on '/secr*t', on the 'admin' sub app
app.use(['/adm*n', '/manager'], admin); // load the 'admin' router on '/adm*n' and '/manager', on the parent app

Ereignisse

app.on('mount', callback(parent))

Wenn eine Unteranwendung an eine übergeordnete Anwendung montiert wird, wird das mount-Ereignis ausgelöst. Das Objekt der übergeordneten Anwendung wird als Parameter an die Callback-Methode übergeben.

var admin = express();
admin.on('mount', function(parent) {
    console.log('Admin Mounted');
    console.log(parent); // refers to the parent app
});
admin.get('/', function(req, res) {
    res.send('Admin Homepage');
});
app.use('/admin', admin);

Methoden

app.all(path, callback[, callback ...]

app.allDie Methode ähnelt den Standardapp.METHOD()-Methoden, außer dass sie alle HTTP-Verben abgleicht. Sie ist sehr nützlich, um globale Logikbehandlung einem bestimmten Präfix zuzuordnen oder für bedingungsloses Abgleichen. Wenn Sie beispielsweise den folgenden Inhalt vor allen anderen Routendefinitionen platzieren, erfordert er, dass alle Routen ab diesem Punkt eine Authentifizierung verlangen und automatisch einen Benutzer laden. Denken Sie daran, dass diese Callbacks nicht unbedingt Endpunkte sind:loadUserNach Abschluss einer Aufgabe können Sie die Methodenext()aufrufen, um weiter nachfolgende Routen abzugleichen.

app.all('*', requireAuthentication, loadUser);

Oder diese äquivalente Form:

app.all('*', requireAuthentication);
app.all('*', loadUser);

Ein weiteres Beispiel ist eine globale Whitelist-Methode. Dieses Beispiel ist dem vorherigen sehr ähnlich, außer dass es nur Pfade mit dem Präfix/apieinschränkt.

app.all('/api/*', requireAuthentication);

app.delete(path, callback[, callback ...])

LeitetHTTP DELETEAnfragen an bestimmte Pfade mit speziellen Callback-Methoden weiter. Weitere Informationen finden Sie imRouting-Leitfaden.next('router'), um die verbleibenden Route-Callbacks zu umgehen. Sie können diesen Mechanismus verwenden, um Vorbedingungen für eine Route festzulegen. Wenn die Anfrage die Verarbeitungsbedingungen der aktuellen Route nicht erfüllen kann, können Sie die Kontrolle an nachfolgende Routen übergeben.

app.delete('/', function(req, res) {
    res.send('DELETE request to homepage');
});

app.disable(name)

Legt die boolesche Einstellung mit dem Namennameauf den Wertfalsefest, wobeinameJaApp-Einstellungstabelleist eine der Eigenschaften in den App-Einstellungen. Der Aufruf vonapp.set('foo', false)und der Aufruf vonapp.disable('foo')sind äquivalent.

app.disable('trust proxy');
app.get('trust proxy');
// => false

app.disabled(name)

Gibttruezurück, wenn die boolesche Einstellungnamedeaktiviert ist (auf false gesetzt)false, wobeinameJa,App-Einstellungstabelleist eine der Eigenschaften in den App-Einstellungen.

app.disabled('trust proxy');
// => true
app.enable('trust proxy');
app.disabled('trust proxy');
// => false

app.enable(name)

Setzt die boolesche Einstellungnameauftrue, wobeinameJaDie App-Einstellungstabelle ist eine der Eigenschaften in den App-Einstellungen. Der Aufruf vonapp.set('foo', true)und der Aufruf vonapp.enable('foo')sind äquivalent.

app.enable('trust proxy');
app.get('trust proxy');
// => true

app.enabled(name)

Gibttruezurück, wenn die boolesche Einstellungnameaktiviert ist (auf true gesetzt)true, wobeinameJa,App-Einstellungstabelleist eine der Eigenschaften in den App-Einstellungen.

app.enabled('trust proxy');
// => false
app.enable('trust proxy');
app.enabled('trust proxy');
// => true

app.engine(ext, callback)

Registriert den Callback der angegebenen Engine, um Dateien mit der Erweiterung ext zu rendern.require()zum Laden von Engines basierend auf Dateierweiterungen. Wenn Sie beispielsweise versuchen, einefoo.jade-Datei zu rendern, ruft Express intern Folgendes auf und speichert dierequire()Ergebnis für nachfolgende Aufrufe, um die Leistung zu verbessern.

app.engine('jade', require('jade').__express);

Verwenden Sie die folgende Methode für diejenigen, die keine sofort einsatzbereite.__express-Methode bereitstellen, oder wenn Sie eine andere Template-Engine-Erweiterung verwenden möchten..html-Datei:

app.engine('html', require('ejs').renderFile);

In diesem Beispiel stellt EJS eine.renderFile-Methode bereit, die die von Express vorgegebenen Signaturregeln erfüllt:(path, options, callback), aber denken Sie daran, dass es intern nurejs.__expressein Alias von, sodass Sie direkt die.ejs-Erweiterung verwenden können.consolidate.jsDie Bibliothek ordnet Template-Engines auf die folgende Weise zu, sodass sie nahtlos mit Express zusammenarbeiten können.

var engines = require('consolidate');
app.engine('haml', engines.haml);
app.engine('html', engines.hogan);

app.get(name)

Ruft die App-Einstellung mit dem Namennameden Wert der App-Einstellung ab, wobeinameJaApp-Einstellungstabelleist eine der Eigenschaften in den App-Einstellungen.

app.get('title');
// => undefined
app.set('title', 'My Site');
app.get('title');
// => 'My Site'

app.get(path, callback [, callback ...])

LeitetHTTP GETAnfragen an bestimmte Pfade mit speziellen Callbacks weiter. Weitere Informationen finden Sie imRouting-Leitfaden.next('router')um die verbleibenden Route-Callbacks zu umgehen. Sie können diesen Mechanismus verwenden, um Vorbedingungen für eine Route festzulegen. Wenn die Anfrage die Verarbeitungsbedingungen der aktuellen Route nicht erfüllt, übergeben Sie die Kontrolle an nachfolgende Routen.

app.get('/', function(req, res) {
    res.send('GET request to homepage');
});

app.listen(port, [hostname], [backlog], [callback])

Bindet die Anwendung so, dass sie am angegebenen Host und Port lauscht. Diese Methode undNodeinhttp.Server.listen()sind identisch.

var express = require('express');
var app = express();
app.listen(3000);

Durch den Aufruf vonexpress()ist das zurückgegebeneapptatsächlich eine JavaScriptFunktion, dafür gedacht, als Callback anNode-HTTP-Serverübergeben zu werden, um Anfragen zu verarbeiten. Auf diese Weise können auf Basis desselben Codes leicht HTTP- und HTTPS-Versionen bereitgestellt werden, sodass die App nicht von diesen erbt (sie ist nur ein einfacher Callback).

var express = require('express');
var https = require('https');
var http = require('http');
http.createServer(app).listen(80);
https.createServer(options, app).listen(443);

Die Methode app.listen() ist eine Komfortmethode, wie unten gezeigt (nur für das HTTP-Protokoll):

app.listen = function() {
    var server = http.createServer(this);
    return server.listen.apply(server, arguments);
};

app.METHOD(path, callback [, callback ...])

Leitet eine HTTP-Anfrage weiter,METHODist die HTTP-Methode der Anfrage, wie z. B.GET，PUT，POSTusw. Beachten Sie, dass sie kleingeschrieben sind. Die tatsächlichen Methoden sind alsoapp.get()，app.post()，app.put()usw. Unten finden Sie eine vollständige Tabelle der Methoden.

Weitere Informationen finden Sie imRouting-Leitfaden.

Wenn die Verwendung der oben genannten Methoden zu ungültigen JavaScript-Variablennamen führt, können Sie die Klammernotation verwenden, zum Beispiel,app['m-search']('/', function ...

Sie können mehrere Callback-Funktionen bereitstellen, die sich wie Middleware verhalten, mit der Ausnahme, dass diese Callbacks durch Aufruf vonnext('router')die verbleibenden Routen-Callbacks umgehen können. Sie können diesen Mechanismus verwenden, um Vorbedingungen für eine Route festzulegen. Wenn die Anfrage die Verarbeitungsbedingungen der aktuellen Route nicht erfüllt, übergeben Sie die Kontrolle an nachfolgende Routen.

Diese API-Dokumentation beschreibt die häufig verwendeten HTTP-Methodenapp.get()，app.post，app.put()，app.delete()als separate Elemente. Die anderen oben aufgeführten Methoden funktionieren jedoch genau auf die gleiche Weise.

app.all()ist eine spezielle Routing-Methode, die nicht zu den im HTTP-Protokoll definierten Methoden gehört. Sie lädt Middleware für einen Pfad, und sie ist für alle Anforderungsmethoden gültig.

app.all('/secret', function (req, res) {
    console.log('Accessing the secret section...');
    next(); // pass control to the next handler
});

app.param([name], callback)

Fügt Callback-Trigger zu Routenparametern hinzu, wobeinameder Parametername oder ein Array von Parameternamen ist,functiondie Callback-Methode ist. Die Parameter der Callback-Methode sind in dieser Reihenfolge:Request-Objekt，Response-Objekt，nächste Middleware，ParameterwertundParametername.nameWenn es ein Array ist, werden die Callback-Trigger in der Reihenfolge registriert, in der jeder Parameter im Array deklariert ist. Auch für andere Parameter als den letzten: Wenn in ihren Callbacks next() aufgerufen wird,next()um den Callback des nächsten deklarierten Parameters aufzurufen. Für den letzten Parameter rufen Sie ihn im Callback auf.next()ruft die nächste Middleware in der aktuell verarbeiteten Route auf, wennnamenur einStringist, dann ist es dasselbe wie es (das heißt, wenn es nur einen Parameter gibt, dann ist es der letzte Parameter, genau wie der letzte Parameter im Array). Zum Beispiel, wenn:userim Routenpfad vorkommt, können Sie die logische Verarbeitung des Benutzerladens zuordnen, um automatischreq.userfür diese Route bereitzustellen, oder die Eingabeparameter validieren.

app.param('user', function(req, res, next, id) {
    User.find(id, function(error, user) {
        if (err) {
            next(err);
        }
        else if (user){
            req.user = user;
        } else {
            next(new Error('failed to load user'));
        }
    });
});

FürParam-Routen, die durch Callbacks definiert werden, sind sie lokal. Sie werden nicht von eingebundenen Apps oder Routen geerbt. Daher, definiert aufappaufParamCallbacks werden erst wirksam, wennappdie Route auf ... diesen Routenparameter hat, dann werden sie wirksam.

Wennparamauf Routen definiert wird, werdenparamCallbacks alle zuerst aufgerufen; sie werden einmal und nur einmal in einem Anfrage-Antwort-Zyklus aufgerufen, selbst wenn mehrere Routen übereinstimmen, wie im folgenden Beispiel:

app.param('id', function(req, res, next, id) {
    console.log('CALLED ONLY ONCE');
    next();
});
app.get('/user/:id', function(req, res, next) {
    console.log('although this matches');
    next();
});
app.get('/user/:id', function(req, res) {
    console.log('and this mathces too');
    res.end();
});

Bei GET /user/42 erhält man das folgende Ergebnis:

CALLED ONLY ONCE
although this matches
and this matches too

app.param(['id', 'page'], function(req, res, next, value) {
    console.log('CALLED ONLY ONCE with', value);
    next();
});
app.get('/user/:id/:page', function(req. res, next) {
    console.log('although this matches');
    next();
});
app.get('/user/:id/:page', function (req, res, next) {
    console.log('and this matches too');
    res.end();
});

Bei Ausführung von GET /user/42/3 lautet das Ergebnis wie folgt:

CALLED ONLY ONCE with 42
CALLED ONLY ONCE with 3
although this matches
and this mathes too

Das im folgenden Abschnitt beschriebeneapp.param(callback)ist seit v4.11.0 veraltet.

Wenn nur ein Callback-Argument an dieapp.param(name, callback)Methode übergeben wird,app.param(naem, callback)wird das Verhalten der Methode vollständig geändert. Dieses Callback-Argument ist eine benutzerdefinierte Methode fürapp.param(name, callback)welches Verhalten es haben soll. Diese Methode muss zwei Parameter akzeptieren und eine Middleware zurückgeben. Der erste Parameter dieses Callbacks ist der zu erfassende URL-Parametername, und der zweite Parameter kann ein beliebiges JavaScript-Objekt sein, das bei der Implementierung der zurückgegebenen Middleware verwendet werden kann. Die von diesem Callback zurückgegebene Middleware bestimmt das Verhalten, das ausgeführt werden soll, wenn die URL diesen Parameter enthält. Im folgenden Beispiel,app.param(name, callback)die Parametersignatur wurde geändert zuapp.param(name, accessId). Statt einen Parameternamen und einen Callback zu akzeptieren,app.param()akzeptiert sie jetzt einen Parameternamen und eine Zahl.

var express = require('express');
var app = express();
app.param(function(param, option){
    return function(req, res, next, val) {
        if (val == option) {
            next();
        }
        else {
            res.sendStatus(403);
        }
    }
});
app.param('id', 1337);
app.get('/user/:id', function(req, res) {
    res.send('Ok');
});
app.listen(3000, function() {
    console.log('Ready');
}); 

In diesem Beispiel bleibt die Parametersignatur von app.param(name, callback) wie zuvor, aber sie wird durch eine Middleware ersetzt, die eine benutzerdefinierte Methode zur Prüfung des Datentyps definiert, um die Korrektheit des Benutzer-ID-Typs zu überprüfen.

app.param(function(param, validator) {
    return function(req, res, next, val) {
        if (validator(val)) {
            next();
        }
        else {
            res.sendStatus(403);
        }
    }
});
app.param('id', function(candidate) {
    return !isNaN(parseFloat(candidate)) && isFinite(candidate);
});

Wenn Sie reguläre Ausdrücke verwenden, verwenden Sie nicht.. Beispielsweise dürfen Sie nicht/user-.+/verwenden, umuser-gamizu erfassen, sondern verwenden Sie[\\s\\S]oder[\\w\\>W]zum Ersetzen (genau wie/user-[\\s\\S]+/).

//captures '1-a_6' but not '543-azser-sder'
router.get('/[0-9]+-[[\\w]]*', function); 
//captures '1-a_6' and '543-az(ser"-sder' but not '5-a s'
router.get('/[0-9]+-[[\\S]]*', function); 
//captures all (equivalent to '.*')
router.get('[[\\s\\S]]*', function); 

app.path()

Mit dieser Methode können Sie den kanonischen Pfad vonappabrufen, der eineZeichenfolge ist。

 var app = express()
      , blog = express()
      , blogAdmin = express();
    app.use('/blog', blog);
    app.use('/admin', blogAdmin);
    console.log(app.path()); // ''
    console.log(blog.path()); // '/blog'
    console.log(blogAdmin.path()); // '/blog/admin'

Wenn die App auf komplexe Weise eingebunden ist, ist auch das Verhalten dieser Methode komplex: Ein besserer Weg ist, req.baseUrl zu verwenden, um den kanonischen Pfad der App abzurufen.

app.post(path, callback, [callback ...])

Leitet HTTP-POST-Anfragen an einen bestimmten Pfad mit bestimmten Callbacks weiter. Weitere Informationen finden Sie im [Routing-Leitfaden](http://expressjs.com/guide/routing.html).

Sie können mehrere Callback-Funktionen angeben, die sich wie Middleware verhalten, mit der Ausnahme, dass diese Callbacks durch Aufrufen von next('router') die verbleibenden Route-Callbacks umgehen können. Sie können diesen Mechanismus verwenden, um einige Vorbedingungen für eine Route festzulegen; wenn die Anfrage die Bearbeitungsbedingungen der aktuellen Route nicht erfüllt, übergeben Sie die Steuerung an die nachfolgenden Routen.

app.post('/', function(req, res) {
    res.send('POST request to homepage')
});

app.put(path, callback, [callback ...])

LeitetHTTP PUTAnfragen an einen bestimmten Pfad mit bestimmten Callbacks weiter. Weitere Informationen finden Sie unterRouting-Leitfaden。

Sie können mehrere Callback-Funktionen angeben, die sich wie Middleware verhalten, mit der Ausnahme, dass diese Callbacks durch Aufrufen vonnext('router')die verbleibenden Route-Callbacks umgehen können. Sie können diesen Mechanismus verwenden, um einige Vorbedingungen für eine Route festzulegen; wenn die Anfrage die Bearbeitungsbedingungen der aktuellen Route nicht erfüllt, übergeben Sie die Steuerung an die nachfolgenden Routen.

app.put('/', function(req, res) {
    res.send('PUT request to homepage');
});

app.render(view, [locals], callback)

Durchcallbackgibt callback einen nach dem Rendern erhaltenenviewHTML-Text zurück. Er kann einen optionalen Parameter akzeptieren, der denview enthältbenötigten lokalen Daten. Diese Methode ähneltres.render()，, außer dass sie den gerenderten HTML-Text nicht an den Client senden kann。

wirdapp.render()Betrachten Sie es als eine Hilfsmethode, die gerenderte View-Strings generieren kann. Inres.render()verwendet es internapp.render()um Views zu rendern.

Wenn View-Caching aktiviert ist, bleibt der Cache lokaler Variablen erhalten. Wenn Sie Views während der Entwicklung cachen möchten, setzen Sie es auftrue. In der Produktion ist View-Caching standardmäßig aktiviert.

app.render('email', function(err, html) {
// ...
});
app.render('email', {name:'Tobi'}, function(err, html) {
// ...
});

app.route(path)

Gibt eine Singleton-Routeninstanz zurück, auf die Sie dann Middleware für verschiedene HTTP-Aktionen anwenden können. Verwenden Sieapp.route(), um doppelte Routennamen zu vermeiden (z. B. Tippfehler) -- die Bedeutung ist, dass Sieapp.router()diese Singleton-Methode verwenden sollten, um mehrere Routeninstanzen für denselben Pfad zu vermeiden.

var app = express();
app.route('/events')
.all(function(req, res, next) {
  // runs for all HTTP verbs first
  // think of it as route specific middleware!
})
.get(function(req, res, next) {
  res.json(...);
})
.post(function(req, res, next) {
  // maybe add a new event...
})

app.set(name, value)

Weist dem Einstellungsnamen value zu, wobei name eine der Eigenschaften inAnwendungseinstellungenist. Für eine boolesche Eigenschaft ist der Aufruf von app.set('foo', ture) äquivalent zum Aufruf von app.enable('foo'). Ebenso ist der Aufruf von app.set('foo', false) äquivalent zum Aufruf von app.disable('foo').

Sie können app.get() verwenden, um den festgelegten Wert abzurufen:

app.set('title', 'My Site');
    app.get('title'); // 'My Site'

Anwendungseinstellungen

Wennnameeine der Anwendungseinstellungen ist, wirkt sich das auf das Verhalten der Anwendung aus. Die Anwendungseinstellungen sind unten aufgeführt.

trust proxyOptionseinstellungsieheExpress behind proxiesfür weitere Informationen.

app.set('trust proxy', 'loopback') // specify a single subnet
app.set('trust proxy', 'loopback, 123.123.123.123') // specify a subnet and an address
app.set('trust proxy', 'loopback, linklocal, uniquelocal') // specify multiple subnets as CSV
app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']) // specify multiple subnets as an array

app.set('trust proxy', function (ip) {
    if (ip === '127.0.0.1' || ip === '123.123.123.123') return true; // trusted IPs
    else return false;
  })

etagEinstellungsoption ETagdie Implementierung der Funktion verwendetetag-Paket. Wenn Sie weitere Informationen benötigen, können Sie dessen Dokumentation konsultieren.

app.set('etag', function (body, encoding) {
  return generateHash(body, encoding); // consider the function is defined
  })

app.use([path,], function [, function...])

BindetMiddlewareMethode an den Pfad. Wenn der Pfad nicht angegeben ist, wird standardmäßig '/' verwendet.

Eine Route stimmt mit jedem Pfad überein, wenn dem festgelegten Pfad der Route unmittelbar '/' folgt. Zum Beispiel:app.use('/appale', ...)stimmt mit '/apple', '/apple/images', '/apple/images/news' usw. überein.

in der Middlewarereq.originalUrlJareq.baseUrlundreq.pathDie Kombination, wie im folgenden Beispiel gezeigt.

app.use('/admin', function(req, res, next) {
// GET 'http://www.example.com/admin/new'
console.log(req.originalUrl); // '/admin/new'
console.log(req.baseUrl); // '/admin'
console.log(req.path);// '/new'
});

Nach dem Einbinden einer Middleware an einem Pfad wird die Middleware immer dann ausgeführt, wenn das Präfix des angeforderten Pfads mit dem Routenpfad übereinstimmt. Da der Standardpfad/ist, wird diese Middleware bei jeder Anfrage ausgeführt, wenn sie ohne Angabe eines Pfads eingebunden wird.

 // this middleware will be executed for every request to the app.
app.use(function(req, res, next) {
    console.log('Time: %d', Date.now());
    next();
});

Middleware-Methoden werden der Reihe nach verarbeitet, daher ist die Reihenfolge, in der Middleware eingebunden wird, sehr wichtig.

// this middleware will not allow the request to  go beyond it
app.use(function(req, res, next) {
    res.send('Hello World');
});
// this middleware will never reach this route
app.use('/', function(req, res) {
    res.send('Welcome');
});

Der Pfad kann ein String sein, der einen Pfad darstellt, ein Pfadmuster, ein regulärer Ausdruck, der auf einen Pfad passt, oder ein Array aus diesen.

Nachfolgend finden Sie einfache Beispiele für Pfade.

// will match paths starting with /abcd
app.use('/abcd', function (req, res, next) {
  next();
})

// will match paths starting with /abcd and /abd
app.use('/abc?d', function (req, res, next) {
  next();
})

// will match paths starting with /abcd, /abbcd, /abbbbbcd and so on
app.use('/ab+cd', function (req, res, next) {
  next();
})

// will match paths starting with /abcd, /abxcd, /abFOOcd, /abbArcd and so on
app.use('/ab\*cd', function (req, res, next) {
  next();
})

// will match paths starting with /ad and /abcd
app.use('/a(bc)?d', function (req, res, next) {
  next();
})

// will match paths starting with /abc and /xyz
app.use(/\/abc|\/xyz/, function (req, res, next) {
  next();
})

// will match paths starting with /abcd, /xyza, /lmn, and /pqr
app.use(['/abcd', '/xyza', /\/lmn|\/pqr/], function (req, res, next) {
  next();
})

Die Methode kann eine Middleware-Methode, eine Reihe von Middleware-Methoden, ein Array von Middleware-Methoden oder eine Kombination davon sein. Da router und app die Middleware-Schnittstelle implementieren, können Sie sie wie jede andere Middleware-Methode verwenden.

app.use(function (req, res, next) {
  next();
})

var router = express.Router();
router.get('/', function (req, res, next) {
  next();
})
app.use(router);

var subApp = express();
subApp.get('/', function (req, res, next) {
  next();
})
app.use(subApp);

var r1 = express.Router();
r1.get('/', function (req, res, next) {
  next();
})

var r2 = express.Router();
r2.get('/', function (req, res, next) {
  next();
})

app.use(r1, r2);

var r1 = express.Router();
r1.get('/', function (req, res, next) {
  next();
})

var r2 = express.Router();
r2.get('/', function (req, res, next) {
  next();
})

app.use('/', [r1, r2]);

function mw1(req, res, next) { next(); }
function mw2(req, res, next) { next(); }

var r1 = express.Router();
r1.get('/', function (req, res, next) { next(); });

var r2 = express.Router();
r2.get('/', function (req, res, next) { next(); });

var subApp = express();
subApp.get('/', function (req, res, next) { next(); });

app.use(mw1, [mw2, r1, r2], subApp);

Im Folgenden finden Sie einige Beispiele für die Verwendung der express.static-Middleware in einer Express-App.

Statische Assets bereitstellen, die sich im public-Verzeichnis unter dem App-Verzeichnis befinden:

// GET /style.css etc
app.use(express.static(__dirname + '/public'));

Binden Sie die Middleware unter dem Pfad/staticein, um statisches Asset-Hosting bereitzustellen, und zwar nur, wenn die Anfrage mit/staticals Präfix beginnt.

// GET /static/style.css etc.
app.use('/static', express.static(express.__dirname + '/public'));

Deaktivieren Sie die Protokollierung für Anfragen nach statischen Assets, indem Sie die Logger-Middleware nach dem Einrichten der Static-Middleware laden.

app.use(express.static(__dirname + '/public'));
app.use(logger());

Statische Assets aus verschiedenen Pfaden bereitstellen, aber./publicder Pfad lässt sich leichter abgleichen als andere:

app.use(express.static(__dirname + '/public'));
app.use(express.static(__dirname + '/files'));
app.use(express.static(__dirname + '/uploads'));

Anfrage

reqDas Objekt repräsentiert eine HTTP-Anfrage und besitzt Eigenschaften, die Daten aus der Anfrage enthalten, wie z. B.Query-String，Parameter，Body，HTTP-Headerusw. In diesem Dokument wird dieses Objekt konventionsgemäß immer alsreqbezeichnet (die HTTP-Antwort wird alsresbezeichnet), aber ihre tatsächlichen Namen werden durch die Parameter der Callback-Methode bestimmt, in der sie verwendet werden.

app.get('/user/:id', function(req, res) {
    res.send('user' + req.params.id);
});

Tatsächlich können Sie es auch so schreiben:

app.get('/user/:id', function(request, response) {
    response.send('user' + request.params.id);
});

Eigenschaften

InExpress 4In,req.filesStandardmäßig,reqes ist nicht mehr im Objekt verfügbar.req.files-Objekt, um hochgeladene Dateien zu erhalten, können Sie eineMultipart-Handling(Multipart-Handling-Toolkit)-Middleware verwenden, wie z. B.busboy，multer，formidable，multipraty，connect-multipartyoderpez。

req.app

Diese Eigenschaft enthältexpresseine Referenz auf die App-Instanz, die als Middleware verwendet werden kann.

Wenn Sie diesem Muster folgen, erstellen Sie ein Modul, das eine Middleware exportiert, und diese Middleware ist nur in Ihrer Hauptdatei; wenn Sie sie mitrequire()einbinden, dann kann diese Middleware überreq.appdie Express-Instanz abrufen.

// index.js
app.get("/viewdirectory", require('./mymiddleware.js'));

// mymiddleware.js
module.exports = function(req, res) {
    res.send('The views directory is ' + req.app.get('views'));
};

req.baseUrl

Der URL-Pfad, auf dem eine Router-Instanz eingebunden ist.

var greet = express.Router();
greet.get('/jp', function(req, res) {
    console.log(req.baseUrl); // greet
    res.send('Konichiwa!');
});
app.use('/greet', greet);

Selbst wenn Sie ein Pfadmuster oder ein Array von Pfadmustern verwenden, um den Router zu laden,baseUrlgibt die Eigenschaft die übereinstimmende Zeichenkette zurück, nicht das Routenmuster. Im folgenden Beispielgreetwird der Router auf zwei Pfadmustern geladen.

app.use(['/gre+t', 'hel{2}o'], greet); // load the on router on '/gre+t' and '/hel{2}o'

Wenn ein Anforderungspfad/greet/jp，baseUrlJa/greetist, wenn ein Anforderungspfad/hello/jp，req.baseUrlJa/hello。 req.baseUrlundappdiemountpathEigenschaft des Objekts ist ähnlich, außer dassapp.mountpathdas passende Pfadmuster zurückgibt.

req.body

Der Anfrage-Body enthält Schlüssel-Wert-Paare übermittelter Daten. Standardmäßig ist erundefined, wenn Sie zum Beispielbody-parserundmulter verwendenDiese Art des Parsens vonBodyDaten-Middleware, sie wird befüllt.body-parserMiddleware zum Befüllen vonreq.body。

var app = require('express');
var bodyParser = require('body-parser');
var multer = require('multer')；// v1.0.5
var upload = multer(); // for parsing multipart/form-data
app.use(bodyParser.json()); // for parsing application/json
app.use(bodyParser.urlencoded({extended:true})); // for parsing application/x-www-form-urlencoded
app.post('/profile', upload.array(), function(req, res, next) {
    console.log(req.body);
    res.json(req.body);
});

req.cookies

Bei Verwendung der cookie-parser-Middleware ist diese Eigenschaft ein Objekt, das die mit der Anfrage gesendeten Cookies enthält. Wenn die Anfrage keine Cookies enthält, ist ihr Wert {}.

// Cookie: name=tj
req.cookies.name
// => "tj"

Weitere Informationen, Fragen oder Bedenken finden Sie untercookie-parser。

req.fresh

Gibt an, ob die Anfrage frisch ist. Sie ist das Gegenteil vonreq.staleist das Gegenteil.cache-controlDer Anfrage-Header hat keinno-cacheDirektive und eine beliebige der folgenden Bedingungen isttrue, dann ist sietrue：

• if-modified-sinceDer Anfrage-Header ist angegeben, undlast-modifiedDer Anfrage-Header ist gleich oder früher alsmodifiedder Antwort-Header.
• if-none-matchDer Anfrage-Header ist*。
• if-none-matchDer Anfrage-Header ist, nachdem er in seine Direktiven geparst wurde,etagnicht gleich dem Wert des Antwort-Headers.

PS: Rolle von If-None-Match: If-None-Match arbeitet mit ETag zusammen. Das Funktionsprinzip besteht darin, ETag-Informationen in der HTTP-Antwort hinzuzufügen. Wenn der Benutzer die Ressource erneut anfordert, werden If-None-Match-Informationen (der Wert von ETag) zur HTTP-Anfrage hinzugefügt. Wenn der Server überprüft, dass sich das ETag der Ressource nicht geändert hat (die Ressource wurde nicht aktualisiert), gibt er den Status 304 zurück, um dem Client mitzuteilen, dass er die lokale Cache-Datei verwenden soll. Andernfalls gibt er den Status 200 mit der neuen Ressource und dem ETag zurück. Die Verwendung eines solchen Mechanismus verbessert die Performance der Website.

req.fresh
// => true

req.hostname

enthält den Wert, der ausHostdem HTTP-Headerhostname abgeleitet wird。

Wenntrust proxyWenn die Einstellung auf einen aktivierten Wert gesetzt ist,X-Forwarded-Hostwird der Header anstelle vonHost verwendet. Dieser Header kann vom Client oder einem Proxy gesetzt werden.

// Host: "example.com"
req.hostname
// => "example.com"

req.ips

Wenntrust proxyWenn die Einstellung auf einen aktivierten Wert gesetzt ist, enthält diese Eigenschaft ein Array vonX-Forwarded-ForIP-Adressen, die im Anfrage-Header angegeben sind. Andernfalls enthält sie ein leeres Array. Dieser Header kann vom Client oder einem Proxy gesetzt werden.

Zum Beispiel, wennX-Forwarded-ForJaclient，proxy1，proxy2，req.ipsdann ist es["clinet", "proxy1", "proxy2"], wobeiproxy2am weitesten stromabwärts liegt.

req.originalUrl

req.urlist keine nativeExpressEigenschaft; sie erbt vonNodes http-Modul。

Diese Eigenschaft ist sehr ähnlich zureq.url; sie behält jedoch die ursprüngliche Anfrage-URL bei, sodass Siereq.urlfrei auf interne Routen umleiten können. Zum Beispielapp.use()desMountenskann die Funktionreq.urlzum Mount-Punkt umleiten.

// GET /search?q=something
req.originalUrl
// => "/search?q=something"

req.params

Ein Objekt, das Eigenschaften enthält, die eins zu eins den in der Route benannten Parameternamen entsprechen. Wenn Sie beispielsweise/user/:nameRoute haben, kann die Eigenschaftnamealsreq.params.name verwendet werden. Der Standardwert dieses Objekts ist{}。

// GET /user/tj
req.params.name
// => "tj"

Wenn Sie reguläre Ausdrücke verwenden, um Routenregeln zu definieren, verwenden die Capture-Gruppen-Kombinationen im Allgemeinenreq.params[n], wobeindie Ordnungszahl der Capture-Gruppe ist. Diese Regel wird auf unbenannte Wildcard-Übereinstimmungen angewendet, wie z. B./file/*die Route:

// GET /file/javascripts/jquery.js
req.params[0]
// => "javascripts/jquery.js"

req.path

Enthält den Pfadteil der Anfrage-URL.

// example.com/users?sort=desc
req.path
// => "/users"

Wenn es in einer Middleware aufgerufen wird, ist der Mount-Punkt nicht inreq.pathenthalten. Weitere Informationen finden Sie unterapp.use().

req.protocol

Das Protokoll der Anfrage, normalerweisehttp, und wenn TLS-Verschlüsselung aktiviert ist, ist eshttps。

Wenn die Einstellungtrust proxyauf einen aktivierten Wert gesetzt ist, wird derX-Forwarded-ProtoHeader, falls vorhanden, vertraut und verwendet. Dieser Header kann vom Client oder einem Proxy gesetzt werden.

req.ptotocol
// => "http"

req.query

Ein Objekt, das für jedenQuery-StringParameter in der Route eine Eigenschaft zuweist. Wenn keinQuery-Stringvorhanden ist, ist es ein leeres Objekt.{}。

// GET /search?q=tobi+ferret
req.query.q
// => "tobi ferret"
// GET /shoes?order=desc&shoe[color]=blue&shoe[type]=converse
req.query.order
// => "desc"
req.query.shoe.color
// => "blue"
req.query.shoe.type
// => "converse"

req.route

Die aktuell übereinstimmende Route, die eine Zeichenkette ist. Zum Beispiel:

app.get('/user/:id?', function userIdHandler(req, res) {
    console.log(req.route);
    res.send('GET')
})

Die Ausgabe des vorherigen Segments ist:

{ path:"/user/:id?"
    stack:
    [
        { handle:[Function:userIdHandler],
          name:"userIdHandler",
          params:undefined,
          path:undefined,
          keys:[],
          regexp:/^\/?$/i,
          method:'get'
        }
    ]
    methods:{get:true}
}

req.secure

Ein boolescher Wert. Wenn eine TLS-Verbindung hergestellt ist, dann ist ertrue. Entspricht:

'https' == req.protocol;

req.signedCookies

Bei Verwendung voncookie-parserMiddleware enthält diese Eigenschaft den signierten Wert, der mit den Anfrage-Cookiesgesendet wurde, und diese Eigenschaft ruft den unsignierten Wert ab, der direkt verwendet werden kann. Die signiertenCookieswird in einem anderen Objekt gespeichert, um die Absicht des Entwicklers widerzuspiegeln; andernfalls kann ein bösartiger Angriff auf den Wert vonreq.cookieangewendet werden (es ist sehr leicht, getäuscht zu werden). Denken Sie daran, einCookiezu signieren bedeutet nicht, es zu verbergen oder zu verschlüsseln; es dient lediglich dazu, Manipulationen zu verhindern (weil die zum Signieren verwendete Verschlüsselung privat ist). Wenn kein signiertesCookiegesendet wird, dann hat diese Eigenschaft standardmäßig den Wert{}。

// Cookie： user=tobi.CP7AWaXDfAKIRfH49dQzKJx7sKzzSoPq7/AcBBRVwlI3
req.signedCookies.user
// => "tobi"

Weitere Informationen, Fragen oder Bedenken finden Sie untercookie-parser。

req.stale

Gibt an, ob die Anfragestale(stale) ist, was das Gegenteil vonreq.freshist. Weitere Informationen finden Sie unterreq.fresh。

req.stale
// => true

req.subdomains

Ein Array von Subdomains in der Domain der Anfrage.

// Host: "tobi.ferrets.example.com"
req.subdomains
// => ["ferrets", "tobi"]

req.xhr

Ein boolescher Wert. WennX-Requested-Withden Wert vonXMLHttpRequesthat, dann ist ertrue, was angibt, dass die Anfrage von einer Client-Bibliothek wiejQuery gesendet wurde。

req.xhr
// => true

Methoden

req.accepts(types)

Prüft, ob der angegebene Inhaltstyp akzeptiert wird, basierend auf dem Accept-HTTP-Header der Anfrage. Diese Methode gibt die beste Übereinstimmung zurück. Wenn es keine Übereinstimmung gibt, gibt sie undefined zurück (in diesem Fall sollte der Server 406 und "Not Acceptable" zurückgeben).

Der Typwert kann eine einzelne MIME-Typ-Zeichenfolge (wie application/json), eine Erweiterung wie json, eine kommagetrennte Liste oder ein Array sein. Für eine Liste oder ein Array gibt diese Methode das beste Element zurück (falls vorhanden).

// Accept: text/html
req.accepts('html');
// => "html"
// Accept: text/*, application/json
req.accepts('html');
// => "html"
req.accepts('text/html');
// => "text/html"
req.accepts(['json', 'text']);
// => "json"
req.accepts('application/json');
// => "application/json"
// Accept: text/*, application/json
req.accepts('image/png');
req.accepts('png');
// => undefined
// Accept: text/*;q=.5, application/json
req.accepts(['html', 'json']);
// => "json"

Weitere Informationen oder bei Fragen oder Bedenken sieheaccepts。

req.acceptsCharsets(charset[, ...])

Gibt den ersten konfigurierten Zeichensatz im angegebenen Zeichensatz zurück, basierend auf demAccept-CharsetHTTP-Header der Anfrage. Wenn kein passender Zeichensatz gefunden wird, wird false zurückgegeben. Weitere Informationen oder bei Fragen oder Bedenken sieheaccepts。

req.acceptsEncodings(encoding[, ...])

Gibt die erste akzeptierte Kodierung des angegebenen Kodierungssatzes zurück, basierend auf demAccept-EncodingHTTP-Header der Anfrage. Wenn keine passende Kodierung im angegebenen Kodierungssatz gefunden wird, gibt false zurück. Für weitere Informationen oder bei Fragen oder Bedenken sieheaccepts。

req.acceptsLanguages(lang [, ...])

Gibt die erste akzeptierte Sprache des angegebenen Sprachsatzes zurück, basierend auf demAccept-LanguageHTTP-Header der Anfrage. Wenn keine passende Sprache im angegebenen Sprachsatz gefunden wird, gibt false zurück. Für weitere Informationen oder bei Fragen oder Bedenken sieheaccepts。

req.get(field)

Gibt den Inhalt des angegebenen HTTP-Header-Felds der Anfrage zurück (Groß-/Kleinschreibung wird nicht beachtet).ReferrerundRefererDer Feldinhalt ist austauschbar.

req.get('Content-type');
// => "text/plain"
req.get('content-type');
// => "text/plain"
req.get('Something')
// => undefined

Es ist ein Alias von req.header(field).

req.is(type)

Wenn dasContent-typeHeader-Feld der eingehenden Anfrage mit dem Parametertypeübereinstimmt, der alsMIME-Typ angegeben ist, dann gibt estruezurück. Andernfalls gibt esfalse zurück.。

// With Content-Type: text/html; charset=utf-8
req.is('html');
req.is('text/html');
req.is('text/*');
// => true
// When Content-Type is application/json
req.is('json');
req.is('application/json');
req.is('application/*');
// => true
req.is('html');
// => false

Für weitere Informationen oder bei Fragen oder Bedenken siehetype-is。

req.param(naem, [, defaultValue])

Veraltet. Verwenden Sie, wo angemessen,req.params，req.bodyoderreq.query。

Gibt den aktuellen Parameternamenwert zurück.

// ?name=tobi
req.param('name')
// => "tobi"
// POST name=tobi
req.param('name')
// => "tobi"
// /user/tobi for /user/:name
req.param('name')
// => "tobi"

Die Suche erfolgt in der folgenden Reihenfolge:

• req.params
• req.body
• req.query

Optional können Sie einendefaultValueangeben, um einen Standardwert festzulegen, falls dieser Parameter in keinem der Anfrageobjekte gefunden werden kann.

Direkt überreq.params，req.body，req.querysollte das Abrufen klarer sein – es sei denn, Sie sind sich über die Eingabe jedes Objekts sicher.Body-parserDie Middleware muss geladen werden, wenn Siereq.param()verwenden. Einzelheiten finden Sie unterreq.body。

Response

res-Objekt repräsentiert, wenn eine HTTP-Anfrage eintrifft,Expressdie von der App zurückgegebene HTTP-Antwort. In dieser Dokumentation wird dieses Objekt konventionell immer abgekürzt alsres(die HTTP-Anfrage wird abgekürzt alsreq), aber ihre tatsächlichen Namen werden durch die Parameter der Callback-Methode bestimmt, in der sie verwendet werden.

app.get('/user/:id', function(req, res) {
    res.send('user' + req.params.id);
});

Zum Beispiel:

app.get('/user/:id', function(request, response) {
    response.send('user' + request.params.id);
});

Eigenschaften

res.app

So geschrieben ist es dasselbe:

Diese Eigenschaft enthält eine Referenz auf die Express-App-Instanz, die in Middleware verwendet werden kann.

res.headersSent

res.app und die req.app-Eigenschaft im Request-Objekt sind identisch.</p>

app.get('/', function(req, res) {
    console.log(res.headersSent); // false
    res.send('OK'); // send之后就发送了头部
    console.log(res.headersSent); // true
});

res.locals

Eine boolesche Eigenschaft, die angibt, ob diese Antwort bereits HTTP-Header gesendet hat.app.localsEin Objekt, das Variablen enthält, die lokal für die Antwort dieser Anfrage sind, und daher sind seine Variablen nur für das View-Rendering innerhalb des Zyklus der Antwort dieser Anfrage verfügbar (falls Views vorhanden sind). In anderer Hinsicht sind es und

sind gleich.

app.use(function(req, res, next) {
    res.locals.user = req.user;
    res.locals.authenticated = !req.user.anonymous;
    next();
});

Methoden

res.append(field [, value])

Dieser Parameter ist sehr nützlich, um Informationen auf Anfrageebene verfügbar zu machen, wie z. B. Anfragepfad, authentifizierter Benutzer, Benutzereinstellungen usw.ExpresxsDie Methode res.append() ist

nur in den Versionen 4.11.0 und höher unterstützt.fieldan das angegebenevalueHTTP-Header-Feld, den angegebenen Wert anhängen.valueWenn dieser Header nicht gesetzt wurde, verwenden Sievalue, um diesen Header zu erstellen.

kann eine Zeichenkette oder ein Array sein.res.append()Hinweis: Nachapp.set()aufrufen

res.append('Lind', ['<http://localhost>', '<http://localhost:3000>']);
res.append('Set-Cookie', 'foo=bar;Path=/;HttpOnly');
res.append('Warning', '199 Miscellaneous warning');

res.attachment([filename])

die Funktion setzt den zuvor festgelegten Wert zurück.Content-DispositionLegt denfilenameHeader-Inhalt auf 'attachment' fest. Wenn angegebenres.type(), dann überContent-Typedie Erweiterung abrufen, umContent-Disposition, und setzen

res.attachment();
// Content-Disposition: attachment
res.attachment('path/to/logo.png');
// Content-Disposition: attachment; filename="logo.png"
// Content-Type: image/png

res.cookie(name, value [,options])

Inhalt zu 'filename=parameter'.NameundWertdesCookies，WertDer

Parameter kann eine Zeichenkette oder ein in eine JSON-Zeichenkette konvertiertes Objekt sein.

Gibt an, dass dieses Cookie signiert werden soll.optionsWas res.cookie() tut, basiert auf dem bereitgestelltenSet-CookieParameter, umoptions zu setzenheader. Wenn keine derRFC6265options angegeben sind, dann ist der Standardwert

angegeben in

res.cookie('name', 'tobi', {'domain':'.example.com', 'path':'/admin', 'secure':true});
res.cookie('remenberme', '1', {'expires':new Date(Date.now() + 90000), 'httpOnly':true});

Anwendungsbeispiele:

res.cookie('rememberme', '1', {'maxAge':90000}, "httpOnly":true);

maxAge ist eine praktische Option zum Festlegen der Ablaufzeit, berechnet in Millisekunden ab der aktuellen Zeit. Das folgende Beispiel hat denselben Effekt wie das zweite oben.

res.cookie('cart', {'items':[1, 2, 3]});
res.cookie('cart', {'items':[1, 2, 3]}, {'maxAge':90000});

Sie können ein Objekt als value-Parameter übergeben. Es wird dann als JSON-Zeichenfolge serialisiert und von der bodyParser()-Middleware geparst.

res.cookie('name', 'tobi', {'signed':true});

res.clearCookie(name [,options])

Wenn Sie die cookie-parser-Middleware verwenden, unterstützt diese Methode auch signierte Cookies. Fügen Sie einfach die Option signed mit dem Wert true hinzu, wenn Sie Optionen festlegen. Dann verwendet res.cookie() das an cookieParser(secret) übergebene Secret, um den Wert zu signieren.nameEntsprechend den angegebenenoptionslöscht das entsprechende Cookie. Weitere Informationen zures.cookie()。

res.cookie('name', 'tobi', {'path':'/admin'});
res.clearCookie('name', {'path':'admin'});

res.download(path, [,filename], [,fn])

Objekt, siehepathÜberträgtContent-Dispositiondie angegebene Datei als Anhang. Normalerweise fordert der Browser den Benutzer zum Herunterladen auf. Standardmäßig,pathder Parameter 'filename=' im Header istfilename(erscheint normalerweise im Dialog des Browsers). Durch Angabe von

Parameter, um den Standardwert zu überschreiben.fnWenn ein Fehler auftritt oder die Übertragung abgeschlossen ist, ruft diese Methoderes.sendFile()die angegebene Callback-Methode auf. Diese Methode verwendet

res.download('/report-12345.pdf');
res.download('/report-12345.pdf', 'report.pdf');
res.download('report-12345.pdf', 'report.pdf', function(err) {
// Handle error, but keep in mind the response may be partially-sent
// so check res.headersSent
if (err) {
} else {
// decrement a download credit, etc.
}
});

res.end([data] [, encoding])

um die Datei zu übertragen.NodeBeendet den Antwortprozess. Diese Methode stammt tatsächlich vonresponse.end()-Methode von http.ServerResponse。

das Kernmodul, insbesondereres.send()undres.json()verwendet, um die Anfrage schnell ohne Daten zu beenden. Wenn Sie Daten senden möchten, können Sie

res.end();
res.status(404).end();

res.format(object)

Methoden wie diese.AcceptFührt Inhaltsaushandlung durch, basierend auf dem vom Anfrageobjekt angegebenen akzeptablen Inhalt im406Accept-HTTP-Header. Es verwendet req.accepts(), um einen Handler auszuwählen, der die Anfrage bedient; diese Handler sind nach Qualitätswert sortiert. Wenn dieser Header nicht angegeben ist, wird standardmäßig die erste Methode aufgerufen. Wenn es keine Übereinstimmung gibt, gibt der Serverstandardmäßig'Not Acceptable', oder ruft

Content-Typedie Callback-Funktion.res.set()Der Antwort-Header wird gesetzt, wenn eine Callback-Methode ausgewählt wird. Sie können ihn jedoch in dieser Methode mit Methoden wieres.type() ändern.。

oder{"message":"hey"}Das folgende Beispiel antwortet mitAccept, wenn der*/*Header des Anfrageobjekts auf 'application/json' oder '*/json' gesetzt ist (aber wenn er

res.format({
    'text/plain':function() {
        res.send('hey');
    },
    'text/html':function() {
        res.send('<p>hey</p>');
    },
    'application/json':function() {
        res.send({message:'hey'});
    },
    'default':function() {
        res.status(406).send('Not Acceptable');
    }
})

, dann wird die Antwort 'hey' sein).

res.format({
    text:function() {
        res.send('hey');
    },
    html:function() {
        res.send('<p>hey</p>');
    },
    json:function() {
        res.send({message:'hey'});
    }
})

res.get(field)

Zusätzlich zu normalisierten MIME-Typen können Sie auch Erweiterungen verwenden, um diese Typen zuzuordnen, um ausführliche Implementierungen zu vermeiden:fieldGibt zurück

res.get('Content-Type');
// => "text/plain"

res.json([body])

den angegebenen HTTP-Antwortheader. Bei der Übereinstimmung wird zwischen Groß- und Kleinschreibung unterschieden.res.send()Sendet eine JSON-Antwort. Diese Methode entspricht dem Übergeben eines Objekts oder eines Arrays als Parameter annull，undefinedMethode. Sie können diese Methode jedoch verwenden, um andere Werte in JSON umzuwandeln, wie z. B.

res.json(null);
res.json({user:'tobi'});
res.status(500).json({error:'message'});

res.jsonp([body])

. (Obwohl diese technisch gesehen ungültiges JSON sind).

res.jsonp(null)
// => null
res.jsonp({user:'tobi'})
// => {"user" : "tobi"}
res.status(500).jsonp({error:'message'})
// => {"error" : "message"}

Sendet eine JSON-Antwort und unterstützt JSONP. Diese Methode hat denselben Effekt wie res.json(), außer dass sie JSONP-Callbacks in ihren Optionen unterstützt.jsonp callback nameStandardmäßig wird die JSONP-Callback-Methode einfach als callback geschrieben. Sie kann

über die Einstellung überschrieben werden.

// ?callback=foo
res.jsonp({user:'tobo'})
// => foo({"user":"tobi"})
app.set('jsonp callback name', 'cb')
// ?cb=foo
res.status(500).jsonp({error:'message'})
// => foo({"error":"message"})

res.links(links)

Im Folgenden finden sich einige Beispiele für die Verwendung von JSONP-Antworten mit demselben Code:links，linksVerbindet die Links,

res.links({
    next:'http://api.example.com/users?page=2',
    last:'http://api.example.com/user?page=5'
});

die als Eigenschaften des übergebenen Parameters bereitgestellt werden; der zusammengefügte Inhalt wird verwendet, um den Link-HTTP-Header der Antwort zu befüllen.

Link:<http://api.example.com/users?page=2>;rel="next",
<http://api.example.com/users?page=5>;rel="last"

res.location(path)

Ergebnis:LocationSetzt denpathHTTP-Header der Antwort auf den angegebenen

res.location('/foo/bar');
res.location('http://example.com');
res.location('back');

WennpathParameter.backWenn der ParameterReferer ist, es hat eine besondere Bedeutung; es legt die URL als die vom Request-Objekt

im Header angegebene URL. Wenn sie in der Anfrage nicht angegeben ist, dann ist sie '/'.LocationExpress übergibt die angegebene URL-Zeichenkette als Antwort an den Browser imback-Headerwert der Antwort, ohne Erkennung oder Manipulation, außer fürlocationdiesen Parameter. Der Browser leitet den Benutzer zu der vonRefererfestgelegten URL weiter, oder zu der vonbackfestgelegten URL (

res.redirect([status,] path)

Parameterfall).pathLeitet zur URL weiter, die aus dem angegebenenHTTP-StatuscodestatusURL und dem angegebenenstatus. Wenn Sie nicht angeben

res.redirect('/foo/bar');
res.redirect('http://example.com');
res.redirect(301, 'http://example.com');
res.redirect('../login');

, wird der Statuscode standardmäßig auf '302 Found' gesetzt.

res.redirect('http://google.com');</p><p>
重定向也可以相对于主机的根路径。比如，如果程序的路径为<strong>http://example.com/admin/post/new</strong>，那么下面将重定向到<strong>http://example.com/admim</strong>:</p>
<pre>res.redirect('/admin');

Die Weiterleitung kann auch eine vollständige URL sein, um auf eine andere Website umzuleiten.http://example.com/blog/admin/Die Weiterleitung kann auch relativ zur aktuellen URL sein. Zum Beispiel von/(beachten Sie den abschließenden /http://example.com/blog/admin/post/new。

res.redirect('post/new');

), wird Folgendes weiterleiten zuhttp://example.com/blog/admin(ohne abschließenden/), leitetpost/newweiter, wird weiterleiten zuhttp://example.com/blog/post/new. Wenn Sie das Obige verwirrend finden, können Sie Pfadsegmente als Verzeichnisse (mit '/') oder Dateien behandeln, was in Ordnung ist. Relative Pfadweiterleitungen sind ebenfalls erlaubt. Wenn Ihr aktueller Pfadhttp://example.com/admin/post/new ist, wird die folgende Operation weiterleiten zuhttp://example.com/admin/post：

res.redirect('..');

backLeitet die Anfrage anrefererweiter, wenn keinrefererangegeben ist, ist der Standard/。

res.redirect('back');

res.render(view [, locals] [, callback])

Rendert eine View und sendet dann das gerenderte HTML-Dokument an den Client. Optionale Parameter sind:

• locals, ein Objekt, das die lokalen Eigenschaftsattribute der View definiert.
• callback, eine Callback-Funktion. Wenn dieser Parameter angegeben wird, gibt die Methoderenderden Fehler und die gerenderte Vorlage zurück und sendet die Antwort nicht automatisch. Wenn ein Fehler auftritt, können Sienext(err) aufrufenMethode innerhalb dieses Callbacks.

Lokales Variablen-Caching ermöglicht View-Caching. Um Views in der Entwicklungsumgebung zu cachen, müssen Sie es manuell auf true setzen; in der Produktionsumgebung ist View-Caching standardmäßig aktiviert.

// send the rendered view to the client
res.render('index');
// if a callback is specified, the render HTML string has to be sent explicitly
res.render('index', function(err, html) {
    res.send(html);
});
// pass a local variable to  the view
res.render('user', {name:'Tobi'}, function(err, html) {
    // ...
});

res.send([body])

Sendet eine HTTP-Antwort.

bodyDer Parameter kann einBuffer-Objekt, ein String, ein Objekt oder ein Array sein. Zum Beispiel:

res.send(new Buffer('whoop'));
res.send({some:'json'});
res.send('<p>some html</p>');
res.status(404).send('Sorry, we cannot find that!');
res.status(500).send({ error: 'something blew up' });

Für allgemeine Nicht-Streaming-Anfragen kann diese Methode viele nützliche Aufgaben ausführen: Zum Beispiel weist sie automatisch den HTTP-Antwortheader Content-Length zu (sofern nicht zuvor definiert) und unterstützt außerdem automatische HEAD- und HTTP-Cache-Aktualisierungen.

Wenn der Parameter ein Buffer-Objekt ist, setzt diese Methode den Content-Type-Antwortheader auf application/octet-stream, sofern nicht vorab angegeben, wie unten gezeigt:

res.set('Content-Type', 'text/html');
res.send(new Buffer('<p>some html</p>'));

Wenn der Parameter ein String ist, setzt diese Methode den Content-Type-Antwortheader auf text/html:

res.send('<p>some html</p>');

Wenn der Parameter ein Objekt oder ein Array ist, stellt Express ihn im JSON-Format dar:

res.send({user:'tobi'});
res.send([1, 2, 3]);

res.sendFile(path [, options] [, fn])

res.sendFile()abExpress v4.8.0begann die Unterstützung.

Überträgtpathdie angegebene Datei. Setzt denContent-TypeHTTP-Header basierend auf der Dateiendung. Sofern nicht inoptionsEs gibt eine Einstellung bezüglichroot,pathmuss ein absoluter Pfad zur Datei sein.optionsParameterdetails:

Wenn die Übertragung abgeschlossen ist oder ein Fehler auftritt, ruft diese Methode diefnCallback-Methode auf. Wenn dieser Callback-Parameter angegeben ist und ein Fehler auftritt, muss die Callback-Methode den Antwortprozess explizit handhaben, indem sie den Request-Response-Zyklus beendet oder die Kontrolle an die nächste Route übergibt.

Das Folgende ist ein Beispiel für die Verwendung aller Parameter mitres.sendFile():

app.get('/file/:name', function(req, res, next) {
    var options = {
        root:__dirname + '/public',
        dotfile:'deny',
        headers:{
            'x-timestamp':Date.now(),
            'x-sent':true
        }
    };
    var fileName = req.params.name;
    res.sendFile(fileName, options, function(err) {
        if (err) {
            console.log(err);
            res.status(err.status).end();
        }
        else {
            console.log('sent', fileName);
        }
    });
});

res.sendFile bietet feingranulare Unterstützung für die Dateibereitstellung, wie im folgenden Beispiel veranschaulicht:

app.get('/user/:uid/photos/:file', function(req, res) {
    var uid = req.params.uid
        , file = req.params.file;
    req.user.mayViewFilesFrom(uid, function(yes) {
        if (yes) {
            res.sendFile('/upload/' + uid + '/' + file);
        }
        else {
            res.status(403).send('Sorry! you cant see that.');
        }
    });
})

Weitere Informationen oder bei Fragen oder Bedenken finden Sie untersend。

res.sendStatus(statusCode)

Legt denHTTP-Statuscodedes Antwortobjekts aufstatusCodefest und sendetstatusCodedie entsprechende Zeichenfolgendarstellung davon als Antworttext.

res.sendStatus(200); // equivalent to res.status(200).send('OK');
res.sendStatus(403); // equivalent to res.status(403).send('Forbidden');
res.sendStatus(404); // equivalent to res.status(404).send('Not Found');
res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')

Wenn ein nicht unterstützter Status angegeben wird, wird der HTTP-Status dennoch aufstatusCodegesetzt und die Zeichenfolge dieses Codes als Body verwendet.

res.sendStatus(2000); // equivalent to res.status(2000).send('2000');

Mehr über HTTP-Statuscodes

res.set(field [, value])

Legt das HTTP-Header-Feld des Antwortobjekts fest:fieldistvalue. Um mehrere Werte gleichzeitig festzulegen, können Sie ein Objekt als Parameter übergeben.

res.set('Content-Type', 'text/plain');
res.set({
    'Content-Type':'text/plain',
    'Content-Length':'123',
    'ETag':'123456'
})

Es hat die gleiche Wirkung wie res.header(field [,value]).

res.status(code)

Verwenden Sie diese Methode, um den HTTP-Status des Antwortobjekts festzulegen. Sie ist ein chainable Alias von Noderesponse.statusCode.

res.status(403).end();
res.status(400).send('Bad Request');
res.status(404).sendFile('/absolute/path/to/404.png');

res.type(type)

Die App legt denContent-TypeMIME-Typ des HTTP-Headers fest, wenn dieser festgelegtetypedurchmime.lookupin den korrektenContent-Typegeparst werden kann. Wenntypecontains/Zeichen enthält, legt die App direkt festContent-TypeistTyp。

res.type('.html');              // => 'text/html'
res.type('html');               // => 'text/html'
res.type('json');               // => 'application/json'
res.type('application/json');   // => 'application/json'
res.type('png');                // => image/png:

res.vary(field)

Fügt den Vary-Antwortheader hinzu, wenn kein Vary-Antwortheader vorhanden ist.

Hinweis: Die Bedeutung von Vary besteht darin, Proxy-Servern/Caches/CDNs mitzuteilen, wie sie feststellen können, ob Anfragen gleich sind. Die Kombinationen in Vary sind die Grundlage für Server/Caches/CDNs, dies zu bestimmen. Wenn Vary beispielsweise User-Agent enthält, dann werden CDN/Proxy selbst bei derselben Anfrage, wenn ein Benutzer eine Seite mit IE öffnet und sie dann erneut mit Firefox öffnet, sie als unterschiedliche Seiten betrachten. Wenn Vary User-Agent nicht enthält, betrachten CDN/Proxy sie als dieselbe Seite und geben die zwischengespeicherte Seite direkt an den Benutzer zurück, ohne die Seite erneut vom Webserver anzufordern. Laienhaft ausgedrückt ist es gleichbedeutend mitfieldindem es als Cache-Schlüssel verwendet wird, um zu bestimmen, ob der Cache getroffen wird.

res.vary('User-Agent').render('docs');

Router

ArouterObjekt ist eine eigenständige Instanz von Middleware und Routing. Man kann es sich als eine "Mini-Anwendung" vorstellen, die in der Lage ist, mit Middleware- und Routing-Methoden zu arbeiten. JedeExpressApp verfügt über einen integrierten App-Router.app.use()Methodenparameter oder als Parameter einer anderen Routeuse().expressObjekt hat einRouter()Methode, und Sie könnenRouter()verwenden, um ein neuesrouterObjekt zu erstellen.

res.vary('User-Agent').render('docs');

Router([options])

Wie folgt können Sie eine Route erstellen:

var router = express.Router([options]);

optionsDer Parameter kann das Verhalten der Route angeben, mit den folgenden Optionen:

Sie könnenrouterwie eine App behandeln, auf der Sie Middleware und HTTP-Routing-Methoden hinzufügen können (wie z. B.get，put，postusw.).

// invoked for any requests passed to this router
router.use(function(req, res, next) {
  // .. some logic here .. like any other middleware
  next();
});
// will handle any request that ends in /events
// depends on where the router is "use()'d"
router.get('/events', function(req, res, next) {
  // ..
});

Sie können einen Router unter einer bestimmten Stamm-URL einhängen, sodass Sie Ihre verschiedenen Routen in unterschiedlichen Dateien oder sogar Mini-Programmen unterbringen können.

// only requests to /calendar/* will be sent to our "router"
app.use('/calendar', router);

Methoden

router.all(path, [callback, ...] callback)

Diese Methode ist dieselbe wie dierouter.METHOD()-Methode, außer dass diese Methode alle HTTP-Aktionen abgleicht.

Diese Methode ist sehr nützlich, um globale Logik einem bestimmten Pfadpräfix oder einer beliebigen Übereinstimmung zuzuordnen. Wenn Sie beispielsweise die unten gezeigte Route vor anderen Routen platzieren, wird sie von allen Routen ab diesem Punkt verlangen, Verifizierungsvorgänge durchzuführen und Benutzerinformationen automatisch zu laden. Denken Sie daran, diese globalen Logikoperationen müssen den Anfrage-Antwort-Zyklus nicht beenden:loaduserDu kannst eine Aufgabe ausführen und dannnext()aufrufen, um den Ausführungsfluss an nachfolgende Routen weiterzugeben.

router.all('*', requireAuthentication, loadUser);

Äquivalente Form:

router.all('*', requireAuthentication)
router.all('*', loadUser);

Dies ist ein Beispiel für eine globale Whitelist-Funktion. Dieses Beispiel ähnelt dem vorherigen, gilt jedoch nur für Pfade, die mit/api beginnen:

router.all('/api/*', requireAuthentication);

router.METHOD(path, [callback, ...] callback)

router.METHOD()Die Methode stellt Routing-Methoden inExpressbereit, wobeiMETHODeine der HTTP-Methoden ist, wie zum BeispielGET，PUT，POSTusw., aber dierouterMETHOD ist kleingeschrieben. Daher lauten die tatsächlichen Methodenrouter.get()，router.put()，router.post()usw.

Du kannst mehrere Callback-Funktionen angeben, die sich wie Middleware verhalten, mit der Ausnahme, dass diese Callbacksnext('router')aufrufen können, um die verbleibenden Route-Callbacks zu umgehen. Du kannst diesen Mechanismus verwenden, um Vorbedingungen für eine Route festzulegen. Wenn die Anfrage die Bearbeitungsbedingungen der aktuellen Route nicht erfüllt, übergib die Kontrolle an die nachfolgenden Routen.

Das folgende Snippet veranschaulicht möglicherweise die einfachste Routendefinition. Express wandelt die Pfadzeichenkette in einen regulären Ausdruck um, um eingehende Anfragen intern abzugleichen. Beim Abgleich werdenQuery-Stringsnicht berücksichtigt; zum Beispiel passt "GET /" auf die folgende Route, und "GET /?name=tobi" ebenfalls.

router.get('/', function(req, res) {
    res.send('Hello World');
});

Wenn du besondere Einschränkungen für den abzugleichenden Pfad hast, kannst du reguläre Ausdrücke verwenden. Zum Beispiel kann das Folgende auf "GET /commits/71dbb9c" und "GET /commits/71bb92..4c084f9" passen.

router.get(/^\/commits\/(\w+)(?:\.\.(\w+))?$/, function(req, res) {
    var from = req.params[0];
    var to = req.params[1];
    res.send('commit range ' + from + '..' + to);
});

router.param(name, callback)

Fügt Callback-Trigger zu Routenparametern hinzu, wobeinameder Parametername ist undfunctiondie Callback-Methode. Die Parameter der Callback-Methode sind in dieser Reihenfolge: das Request-Objekt, das Response-Objekt, die nächste Middleware, der Parameterwert und der Parametername. Obwohlnametechnisch optional ist, wird es ab Express V4.11.0 nicht empfohlen (siehe unten).

Im Gegensatz zuapp.param()，akzeptiert router.param()kein Array als Routenparameter.

Zum Beispiel, wenn:userim Routenpfad erscheint, können Sie die Benutzerladelogik so zuordnen, dassreq.userautomatisch für diese Route bereitgestellt wird, oder die Eingabeparameter validieren.

router.param('user', function(req, res, next, id) {
    User.find(id, function(error, user) {
        if (err) {
            next(err);
        }
        else if (user){
            req.user = user;
        } else {
            next(new Error('failed to load user'));
        }
    });
});

FürParam-Callback definierte Routen sind sie lokal. Sie werden nicht von der eingebundenen App oder dem Router geerbt. Daher sind aufrouterdieparamCallbacks nur, wenn aufrouternur dann wirksam, wenn die darauf befindliche Route diesen Routenparameter hat.

Beim Definieren vonparamauf der Route werdenparamCallbacks zuerst aufgerufen, und sie werden in einem Request-Response-Zyklus genau einmal aufgerufen, selbst wenn mehrere Routen übereinstimmen, wie im folgenden Beispiel:

router.param('id', function(req, res, next, id) {
    console.log('CALLED ONLY ONCE');
    next();
});
router.get('/user/:id', function(req, res, next) {
    console.log('although this matches');
    next();
});
router.get('/user/:id', function(req, res) {
    console.log('and this mathces too');
    res.end();
});

Wenn GET /user/42 angefordert wird, ergibt sich das folgende Ergebnis:

CALLED ONLY ONCE
although this matches
and this matches too

Wie im folgenden Abschnitt beschrieben, istrouter.param(callback)seit v4.11.0 veraltet.

Wenn nur ein Callback-Parameter an dierouter.param(name, callback)-Methode übergeben wird, wirdrouter.param(naem, callback)das Verhalten der Methode vollständig geändert. Dieser Callback-Parameter ist eine benutzerdefinierte Methode, die definiertrouter.param(name, callback)welches Verhalten es haben soll. Diese Methode muss zwei Parameter akzeptieren und eine Middleware zurückgeben.

Der erste Parameter dieses Callbacks ist der Name des zu erfassenden URL-Parameters, und der zweite Parameter kann ein beliebiges JavaScript-Objekt sein, das bei der Implementierung der zurückgegebenen Middleware verwendet werden kann. Die von dieser Callback-Methode zurückgegebene Middleware bestimmt das Verhalten, das ausgeführt werden soll, wenn die URL diesen Parameter enthält.

Im folgenden Beispiel wurderouter.param(name, callback)die Parametersignatur geändert zurouter.param(name, accessId). Die Ersetzung akzeptiert einen Parameternamen und einen Callback,router.param()und akzeptiert jetzt einen Parameternamen und eine Zahl.

var express = require('express');
var app = express();
var router = express.Router();
router.param(function(param, option){
    return function(req, res, next, val) {
        if (val == option) {
            next();
        }
        else {
            res.sendStatus(403);
        }
    }
});
router.param('id', 1337);
router.get('/user/:id', function(req, res) {
    res.send('Ok');
});
app.use(router);
app.listen(3000, function() {
    console.log('Ready');
}); 

In diesem Beispiel bleibt die Parametersignatur von router.param(name. callback) wie zuvor, aber sie wird durch eine Middleware ersetzt, die eine benutzerdefinierte Methode zur Erkennung des Datentyps definiert, um die Korrektheit des Benutzer-ID-Typs zu überprüfen.

router.param(function(param, validator) {
    return function(req, res, next, val) {
        if (validator(val)) {
            next();
        }
        else {
            res.sendStatus(403);
        }
    }
});
router.param('id', function(candidate) {
    return !isNaN(parseFloat(candidate)) && isFinite(candidate);
});

router.route(path)

Gibt eine Singleton-Routeninstanz zurück, auf die Sie dann Middleware für verschiedene HTTP-Aktionen anwenden können. Verwenden Sierouter.route(), um doppelte Routennamen (z. B. Tippfehler) zu vermeiden -- die Bedeutung ist,router.route()diese Singleton-Methode zu verwenden, um mehrere Routeninstanzen für denselben Pfad zu vermeiden.

Aufbauend auf dem obigenrouter.param()-Beispiel zeigt der folgende Code, wie manrouter.route()verwendet, um Handler für verschiedene HTTP-Methoden anzugeben.

var router = express.Router();
router.param('user_id', function(req, res, next, id) {
    // sample user, would actually fetch from DB, etc...
    req.user = {
        id:id,
        name:"TJ"
    };
    next();
});
router.route('/users/:user_id')
    .all(function(req, res, next) {
        // runs for all HTTP verbs first
        // think of it as route specific middleware!
        next();
    })
    .get(function(req, res, next) {
        res.json(req.user);
    })
    .put(function(req, res, next) {
        // just an example of maybe updating the user
        req.user.name = req.params.name;
        // save user ... etc
        res.json(req.user);
    })
    .post(function(req, res, next) {
        next(new Error('not implemented'));
    })
    .delete(function(req, res, next) {
        next(new Error('not implemented'));
    })

Diese Methode verwendet einen einzelnen single/usrs/:userid-Pfad wieder, um verschiedene HTTP-Methoden hinzuzufügen.

router.use([path], [function, ...] function)

Für den optionalenpathParameter hängen Sie die angegebene Middleware-Methode an den angegebenen Pfad an. Wenn derpathParameter nicht angegeben ist, ist der Standardwert/.app.use(). Diese Methode ähneltapp.use(); weitere Informationen finden Sie dort.

Middleware ist wie ein Rohrleitungssystem. Die Anfrage beginnt bei der ersten Middleware, die Sie definieren, und fließt den Middleware-Stack hinunter, wobei die Anfrage verarbeitet wird, wenn der Pfad übereinstimmt.

var express = require('express');
var app = express();
var router = express.Router();
// simple logger for this router`s requests
// all requests to this router will first hit this middleware
router.use(function(req, res, next) {
    console.log('%s %s %s', req.method, req.url, req.path);
    next();
})
// this will only be invoked if the path starts with /bar form the mount ponit
router.use('/bar', function(req, res, next) {
    // ... maybe some additional /bar logging ...
    next();
})
// always be invoked
router.use(function(req, res, next) {
    res.send('hello world')；
})
app.use('/foo', router);
app.listen(3000);

Bei Middleware-Funktionen wird der eingehängte Pfad entfernt und ist unsichtbar. Die Hauptauswirkung dieser Funktion besteht darin, dass für verschiedene Pfade das Einhängen derselben Middleware möglicherweise keine Codeänderungen erfordert, obwohl sich ihr Präfix geändert hat.

Die Reihenfolge, in der Sie Middleware mit router.use() definieren, ist wichtig. Middleware werden der Reihe nach aufgerufen, daher bestimmt die Reihenfolge die Priorität der Middleware. Beispielsweise ist Logging normalerweise die erste Middleware, die Sie verwenden, damit jede Anfrage aufgezeichnet wird.

var logger = require('morgan');
router.use(logger());
router.use(express.static(__dirname + '/public'));
router.use(function(req, res) {
    res.send('Hello');
});

Nun, um zu unterstützen, dass Sie statische Dateianfragen nicht protokollieren möchten, aber weiterhin die Routen und Middleware protokollieren möchten, die nachlogger()definiert wurden. Sie können einfachstatic()nach vorne verschieben, um dies zu lösen:

router.use(express.static(__dirname + '/public'));
router.use(logger());
router.use(function(req, res){
  res.send('Hello');
});

Ein weiteres konkretes Beispiel ist das Hosten statischer Dateien aus verschiedenen Pfaden. Sie können./publicdavor setzen, um höhere Priorität zu erhalten:

app.use(express.static(__dirname + '/public'));
app.use(express.static(__dirname + '/files'));
app.use(express.static(__dirname + '/uploads'));

router.use()Die Methode unterstützt auch benannte Parameter, sodass Ihr Einhängepunkt benannte Parameter zum Vorladen in Bezug auf andere Routen verwenden kann, was sehr vorteilhaft ist.

Originaladresse: https://github.com/bajian/express_api_4.x_chinese