express()

express()Sert à créer une application Express. La méthodeexpress()est une méthode de niveau supérieur exportée par le moduleexpress.

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

Méthodes

express.static(root, [options])

express.staticC'est le seul middleware intégré d'Express. Il est basé sur le moduleserver-staticet est responsable de l'hébergement des ressources statiques dans les applications Express.rootest le répertoire racine où résident les ressources statiques.optionsest facultatif et prend en charge les propriétés suivantes :

Propriété Description Type Valeur par défaut
dotfiles Indique s'il faut répondre aux dotfiles. Les valeurs disponibles sont "allow", "deny" et "ignore". String "ignore"
etag Activer ou désactiver etag. Boolean vrai
extensions Définir le repli d'extension de fichier. Boolean vrai
index Envoyer le fichier d'index du répertoire. Définir sur false pour ne pas l'envoyer. Mixed "index.html"
lastModified Définir l'heure de dernière modification du fichier dans le système sur l'en-têteLast-Modified. Les valeurs possibles sontfalseettrue。 Boolean vrai
maxAge Définir dans l'en-tête Cache-Control l'attributmax-age, avec une précision en millisecondes (ms) ou unechaîne au format ms. Number 0
redirect Lorsque le chemin demandé est un répertoire, rediriger vers un "/" final. Boolean vrai
setHeaders Méthode pour définir les en-têtes lors de la réponse aux requêtes de fichiers statiques. Fonction  

Si vous souhaitez plus de détails sur l'utilisation des intergiciels, vous pouvez vous référer àServir des fichiers statiques dans Express。

Application()

appL'objet app représente généralement une application Express. En appelant la méthode de niveau supérieurexpress()exportée par le module Express pour la créer :

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

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

app.listen(3000);

L'objet app possède les méthodes suivantes :

  • Route les requêtes HTTP ; pour plus de détails, voirapp.METHODetapp.paramces deux exemples.
  • Configure les intergiciels ; pour plus de détails, voirapp.route。
  • Rend les vues HTML ; pour plus de détails, voirapp.render。
  • Enregistre les moteurs de modèles ; pour plus de détails, voirapp.engine。

Il possède également certains paramètres de propriété qui peuvent modifier le comportement de l'application. Pour plus d'informations, voirParamètres de l'application。

Propriétés

app.locals

L'objet app.locals est un objet JavaScript, et ses propriétés sont des variables locales à l'application.

app.locals.title
// => 'My App'
app.locals.email
// => 'me@myapp.com'

Une fois défini,app.localsses valeurs de propriété persisteront pendant tout le cycle de vie de l'application. En revanche,res.localsn'est valide que pendant le cycle de vie de la requête en cours.

Dans l'application, vous pouvez utiliser ces variables locales lors du rendu de modèles. Elles sont très utiles pour fournir aux modèles des méthodes utiles et des données au niveau deapp. Viareq.app.locals(voirreq.app), les variables locales peuvent être utilisées dans les middlewares.

app.locals.title = 'My App';
app.locals.strftime = require('strftime');
app.locals.email = 'me@myapp.com';

app.mountpath

app.mountpathLa propriété est le motif de chemin sur lequel une sous-application est montée.

Une sous-application est une instanceexpress, qui peut être utilisée comme gestionnaire de route pour traiter les requêtes.

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

Il est similaire à la propriétéreq.baseUrlde l'objet req, sauf que req.baseUrl est le chemin d'URL correspondant, et non le motif correspondant. Si une sous-application est montée sur plusieurs motifs de chemin, app.mountpath est une liste d'éléments de motif de chemin de montage, comme illustré dans l'exemple suivant.

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

Événements

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

Lorsqu'une sous-application est montée sur une application parente, l'événement mount est émis. L'objet d'application parente est passé comme paramètre à la méthode de rappel.

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

Méthodes

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

app.allLa méthode est similaire aux méthodes standardapp.METHOD(), sauf qu'elle correspond à tous les verbes HTTP. Elle est très utile pour mapper la gestion d'une logique globale sur un préfixe spécifique, ou pour une correspondance inconditionnelle. Par exemple, si vous placez le contenu suivant avant toutes les autres définitions de route, cela impose à toutes les routes à partir de ce point d'exiger une authentification et de charger automatiquement un utilisateur. N'oubliez pas que ces callbacks ne sont pas nécessairement des points de terminaison :loadUserAprès avoir terminé une tâche, vous pouvez appelernext()méthode pour continuer à faire correspondre les routes suivantes.

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

Ou cette forme équivalente :

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

Un autre exemple est une méthode de liste blanche globale. Cet exemple est très similaire au précédent, sauf qu'il ne restreint que les chemins commençant par/apile préfixe.

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

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

AchemineHTTP DELETEles requêtes vers des chemins spécifiques avec des méthodes de rappel spéciales. Pour plus d'informations, consultezle guide de routage.next('router')pour contourner les rappels de route restants. Vous pouvez utiliser ce mécanisme pour définir des préconditions pour une route. Si la requête ne peut pas satisfaire les conditions de traitement de la route actuelle, vous pouvez passer le contrôle aux routes suivantes.

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

app.disable(name)

Définit le paramètre booléen nomménameà la valeurfalse, oùnameOuile tableau des paramètres de l'applicationest l'une des propriétés des paramètres de l'application. Appelerapp.set('foo', false)et appelerapp.disable('foo')sont équivalents.

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

app.disabled(name)

Renvoietruesi le paramètre booléennameest désactivé (défini sur false)false, oùnameOuile tableau des paramètres de l'applicationest l'une des propriétés des paramètres de l'application.

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

app.enable(name)

Définit le paramètre booléennameàtrue, oùnameOuiLa table des paramètres de l'application est l'une des propriétés des paramètres de l'application. Appelerapp.set('foo', true)et appelerapp.enable('foo')sont équivalents.

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

app.enabled(name)

Renvoietruesi le paramètre booléennameest activé (défini sur true)true, oùnameOuile tableau des paramètres de l'applicationest l'une des propriétés des paramètres de l'application.

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

app.engine(ext, callback)

Enregistre le callback du moteur donné pour rendre les fichiers avec l'extension ext.require()pour charger les moteurs en fonction des extensions de fichier. Par exemple, si vous essayez de rendre un fichierfoo.jade, Express appelle en interne ce qui suit, et met en cache lerequire()résultat pour les appels suivants afin d'accélérer les performances.

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

Utilisez la méthode suivante pour ceux qui ne fournissent pas de méthode.__expressprête à l'emploi, ou lorsque vous souhaitez utiliser une extension de moteur de template différente..htmlfichier :

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

Dans cet exemple, EJS fournit une méthode.renderFilequi satisfait les règles de signature spécifiées par Express :(path, options, callback), mais rappelez-vous qu'en interne, il s'agit simplement deejs.__expressun alias de, vous pouvez donc directement utiliser l'extension.ejs.consolidate.jsLa bibliothèque associe les moteurs de template de la manière suivante, afin qu'ils puissent fonctionner de manière transparente avec Express.

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

app.get(name)

Obtient le paramètre d'application nomménamela valeur du paramètre d'application, oùnameOuitable des paramètres d'applicationest l'une des propriétés des paramètres d'application.

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

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

AchemineHTTP GETles requêtes vers des chemins spécifiques avec des fonctions de rappel spéciales. Pour plus d'informations, consultezguide de routage.next('router')pour ignorer les fonctions de rappel de route restantes. Vous pouvez utiliser ce mécanisme pour définir des préconditions pour une route. Si la requête ne satisfait pas aux conditions de traitement de la route actuelle, transférez le contrôle aux routes suivantes.

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

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

Lie l'application pour qu'elle écoute sur l'hôte et le port spécifiés. Cette méthode etNodedanshttp.Server.listen()sont identiques.

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

En appelantexpress()l'appretournée est en fait uneFunction JavaScript, conçue pour être passée comme fonction de rappel àserveurs HTTP Nodepour traiter les requêtes. De cette façon, elle peut facilement fournir des versions HTTP et HTTPS basées sur le même code, ainsi l'application n'hérite pas de celles-ci (ce n'est qu'une simple fonction de rappel).

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

La méthode app.listen() est une méthode pratique comme indiqué ci-dessous (uniquement pour le protocole HTTP) :

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

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

Achemine une requête HTTP,METHODest la méthode HTTP de la requête, commeGET,PUT,POSTetc. Notez qu'elles sont en minuscules. Ainsi, les méthodes réelles sontapp.get(),app.post(),app.put()etc. Vous trouverez ci-dessous un tableau complet des méthodes.

Pour plus d'informations, consultezle guide de routage.

  • checkout
  • connect
  • copy
  • effacement
  • get
  • head
  • lock
  • merge
  • mkactivity
  • mkcol
  • move
  • m-search
  • notify
  • options
  • patch
  • post
  • propfind
  • proppatch
  • purege
  • put
  • report
  • search
  • subscribe
  • trace
  • unlock
  • unsubscribe

Si l'utilisation des méthodes ci-dessus produit des noms de variables JavaScript non valides, vous pouvez utiliser la notation entre crochets, par exemple,app['m-search']('/', function ...

Vous pouvez fournir plusieurs fonctions de rappel, qui se comportent comme des intergiciels, sauf que ces callbacks peuvent, en appelantnext('router')contourner les callbacks de route restants. Vous pouvez utiliser ce mécanisme pour définir des préconditions pour une route. Si la requête ne satisfait pas les conditions de traitement de la route actuelle, passez le contrôle aux routes suivantes.

Cette documentation d'API décrit les méthodes HTTP couramment utiliséesapp.get(),app.post,app.put(),app.delete()comme des éléments distincts. Toutefois, les autres méthodes listées ci-dessus fonctionnent exactement de la même manière.

app.all()est une méthode de routage spéciale qui ne fait pas partie des méthodes définies dans le protocole HTTP. Elle charge un middleware pour un chemin, et elle est valide pour toutes les méthodes de requête.

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

app.param([name], callback)

Ajoute des déclencheurs de callback aux paramètres de route, oùnameest le nom du paramètre ou un tableau de noms de paramètres,functionest la méthode de callback. Les paramètres de la méthode de callback, dans l'ordre, sontobjet de requête,objet de réponse,middleware suivant,valeur du paramètreetnom du paramètre.nameS'il s'agit d'un tableau, les déclencheurs de callback sont enregistrés dans l'ordre dans lequel chaque paramètre est déclaré dans le tableau. De plus, pour les paramètres autres que le dernier, appeler next() dans leurs callbacksnext()pour appeler le callback du paramètre déclaré suivant. Pour le dernier paramètre, appelez-le dans le callback.next()appellera le middleware suivant dans la route en cours de traitement, sinameest juste unechaînealors c'est la même chose que lui (c'est-à-dire que s'il n'y a qu'un seul paramètre, alors c'est le dernier paramètre, comme le dernier paramètre du tableau). Par exemple, lorsque:userapparaît dans le chemin de la route, vous pouvez mapper le traitement logique du chargement de l'utilisateur pour fournir automatiquementreq.userà cette route, ou valider les paramètres d'entrée.

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

Pour lesParamroutes définies par des callbacks, elles sont locales. Elles ne sont pas héritées par les applications ou les routes montées. Par conséquent, définies surappsurParamles callbacks ne prennent effet que lorsqueappla route sur ... possède ce paramètre de route, alors ils prennent effet.

Lors de la définition deparamsur les routes, les callbacks deparamsont tous appelés en premier ; ils sont appelés une fois et une seule dans un cycle requête-réponse, même si plusieurs routes correspondent, comme dans l'exemple suivant :

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

Lors d'un GET /user/42, le résultat suivant est obtenu :

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

Lors de l'exécution de GET /user/42/3, le résultat est le suivant :

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

décrit dans la section suivanteapp.param(callback)est obsolète depuis la v4.11.0.

En passant un seul argument de callback à la méthodeapp.param(name, callback),app.param(naem, callback)le comportement de la méthode sera complètement modifié. Cet argument de callback est une méthode personnalisée concernantapp.param(name, callback)quel comportement elle doit avoir. Cette méthode doit accepter deux paramètres et retourner un middleware. Le premier paramètre de ce callback est le nom du paramètre d'URL à capturer, et le second paramètre peut être n'importe quel objet JavaScript pouvant être utilisé lors de l'implémentation du middleware retourné. Le middleware retourné par ce callback détermine le comportement à adopter lorsque l'URL contient ce paramètre. Dans l'exemple suivant,app.param(name, callback)la signature de paramètre a été modifiée enapp.param(name, accessId). Au lieu d'accepter un nom de paramètre et un callback,app.param()il accepte désormais un nom de paramètre et un nombre.

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

Dans cet exemple, la signature de paramètre app.param(name, callback) reste la même qu'avant, mais elle est remplacée par un middleware qui définit une méthode personnalisée de vérification de type de données pour vérifier la validité du type d'identifiant utilisateur.

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

Lors de l'utilisation d'expressions régulières, n'utilisez pas.. Par exemple, vous ne pouvez pas utiliser/user-.+/pour captureruser-gami, utilisez plutôt[\\s\\S]ou[\\w\\>W]pour remplacer (comme/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()

via cette méthode, vous pouvez obtenirapple chemin canonique, qui est unechaîne。

 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'

Si l'app est montée d'une manière complexe, alors le comportement de cette méthode sera également complexe : une meilleure façon est d'utiliser req.baseUrl pour obtenir le chemin canonique de l'app.

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

Route les requêtes HTTP POST vers un chemin spécial avec des callbacks spéciaux. Pour plus d'informations, voir le [guide de routage](http://expressjs.com/guide/routing.html).

Vous pouvez fournir plusieurs fonctions de rappel qui se comportent comme des middlewares, sauf que ces fonctions de rappel peuvent contourner les fonctions de rappel de route restantes en appelant next('router'). Vous pouvez utiliser ce mécanisme pour définir certaines préconditions pour une route ; si la requête ne satisfait pas les conditions de traitement de la route actuelle, transférez le contrôle aux routes suivantes.

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

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

Route les requêtesHTTP PUTvers un chemin spécial avec des callbacks spéciaux. Pour plus d'informations, consultezle guide de routage。

Vous pouvez fournir plusieurs fonctions de rappel qui se comportent comme des middlewares, sauf que ces fonctions de rappel peuvent, en appelantnext('router')contourner les fonctions de rappel de route restantes. Vous pouvez utiliser ce mécanisme pour définir certaines conditions préalables pour une route ; si la requête ne satisfait pas les conditions de traitement de la route actuelle, passez le contrôle aux routes suivantes.

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

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

Via lecallback, le callback renvoie un texte HTML devueobtenu après le rendu. Il peut accepter un paramètre optionnel qui contient lavueles données locales nécessaires. Cette méthode est similaire àres.render(),sauf qu'elle ne peut pas envoyer le texte HTML rendu au client。

vaapp.render()le traiter comme une méthode utilitaire qui peut générer des chaînes de vue rendues. Dansres.render()en interne, il utiliseapp.render()pour effectuer le rendu des vues.

Si la mise en cache des vues est activée, le cache des variables locales sera conservé. Si vous souhaitez mettre en cache les vues pendant le développement, définissez-le surtrue. En production, la mise en cache des vues est activée par défaut.

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

app.route(path)

Retourne une instance de route singleton, sur laquelle vous pouvez ensuite appliquer des middlewares pour diverses actions HTTP. Utilisezapp.route()pour éviter les noms de route en double (par ex., des erreurs de frappe) -- cela signifie que vous devez utiliserapp.router()cette méthode singleton pour éviter de multiples instances de route pour le même chemin.

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)

Attribue la valeur au nom de paramètre, où name estParamètres de l'applicationl'une des propriétés qu'il contient. Pour une propriété booléenne, appeler app.set('foo', ture) équivaut à appeler app.enable('foo'). De même, appeler app.set('foo', false) équivaut à appeler app.disable('foo').

Vous pouvez utiliser app.get() pour obtenir la valeur définie :

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

Paramètres de l'application

Sinameest l'un des paramètres de l'application, cela affectera le comportement de l'application. Les paramètres de l'application sont listés ci-dessous.

Propriété Type Valeur Default
routage sensible à la casse Boolean Active la sensibilité à la casse. Non activé. Pour/Fooet/foole traitement est identique.
env String Mode d'environnement. process.env.NODEENV(variable d'environnement NODEENV) ou 'development'
etag Variable DéfinitETagen-tête de réponse. Pour les valeurs possibles, voirle tableau des options etag. Plus d'informations surl'en-tête HTTP ETag。 faible
nom du callback jsonp String Spécifie le nom du callback JSONP par défaut. ?callback=
remplaçant json String callback JSONP null
espaces json Number Lorsque cette valeur est définie, les chaînes JSON mises en forme avec des espaces d'indentation sont envoyées. Désactivé
analyseur de requête Variable Définissez la valeur surfalsepour désactiverl'analyseur de requêtes, ou définissezsimple,extended, ou vous pouvez implémenter votre propre fonction d'analyse dechaîne de requête.simpleBasé surNodenatifanalyse de requête,querystring。 "extend"
routage strict Boolean Activez le routage strict. Non activé. Pour/fooet/foo/le traitement des routes est identique.
décalage de sous-domaine Number Le nombre de parties de l'hôte séparées par des points à supprimer pour accéder aux sous-domaines 2
trust proxy Variable Indique queappest derrière un proxy inverse, utilisezx-Forwarded-*pour déterminer la connexion et l'adresse IP du client. Remarque :X-Forwarded-*L'en-tête est facile à usurper, donc la détection de l'adresse IP du client n'est pas fiable.trust proxyDésactivé par défaut. Lorsqu'il est activé, Express tente d'obtenir l'adresse IP du client connecté via le proxy frontal ou une série de proxys.req.ipsLa propriété contient un tableau d'adresses IP des clients connectés. Pour l'activer, définissez la valeur définie dansle tableau des options de trust proxysur la valeur définie ci-dessous.trust proxyL'implémentation du paramètre utiliseproxy-addrpaquet. Si vous souhaitez plus d'informations, vous pouvez consulter sa documentation. Désactiver
views Chaîne ou tableau viewle répertoire ou le tableau de répertoires où il se trouve. S'il s'agit d'un tableau, il sera recherché dans l'ordre du tableau.view。 process.cwd() + '/views'
view cache Boolean Activer le cache de compilation des modèles de vue. Activé par défaut en production.
view engine String Lorsqu'il est omis, le moteur par défaut est utilisé pour l'extension.
x-powered-by Boolean ActiverX-Powered-By:Expressen-tête HTTP vrai

trust proxyparamètre d'optionvoirExpress derrière les proxyspour plus d'informations.

TypeValeur
Boolean

S'il esttrue, l'adresse IP du client est considérée comme l'X-Forwarded-*entrée la plus à gauche de l'en-tête. S'il estfalse, on peut comprendre queappest directement connectée à Internet, et l'adresse IP du client est dérivée dereq.connection.remoteAddress。falseest le paramètre par défaut.

Adresses IP

Une adresse IP, un sous-réseau ou un groupe d'adresses IP, et des sous-réseaux délégués. Voici une liste de noms de sous-réseaux prédéfinis.

  • loopback - 127.0.0.1/8, ::1/128
  • linklocal - 169.254.0.0/16, fe80::/10
  • uniquelocal - 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, fc00::/7

Utilisez l'une des méthodes suivantes pour définir l'adresse IP :

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

Lorsqu'une adresse IP est spécifiée, cette adresse IP ou ce sous-réseau est exclu de l'application qui a cette adresse IP ou ce sous-réseau défini ; l'adresse non déléguée la plus proche du serveur d'application sera considérée comme l'adresse IP du client.

Number

Faire confiance aux connexions avec un nombre de sauts inférieur ou égal à n entre le proxy inverse et l'application en tant que client.

Fonction

Mécanisme personnalisé de confiance de proxy délégué. Si vous utilisez ceci, assurez-vous de savoir ce que vous faites.

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

etagOption de paramétrage ETagl'implémentation de la fonctionnalité utiliseetagpaquet. Si vous avez besoin de plus d'informations, vous pouvez consulter sa documentation.

TypeValeur
Boolean

Défini surtrue, active l'ETag faible. C'est le paramètre par défaut. Défini surfalse, désactive tous les ETags.

String S'il eststrong, active l'ETag fort. S'il estweak, activeweak ETag。
Fonction

une implémentation personnalisée de méthode ETag. Si vous utilisez ceci, assurez-vous de savoir ce que vous faites.

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

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

Montemiddlewareméthode sur le chemin. Si le chemin n'est pas spécifié, il utilise '/' par défaut.

Une route correspondra à n'importe quel chemin si le chemin est immédiatement suivi de '/' après le chemin défini de la route. Par exemple :app.use('/appale', ...)correspondra à '/apple', '/apple/images', '/apple/images/news', etc.

dans le middlewarereq.originalUrlOuireq.baseUrletreq.pathLa combinaison, comme montré dans l'exemple ci-dessous.

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

Après avoir monté un middleware sur un chemin, le middleware sera exécuté chaque fois que le préfixe du chemin demandé correspond au chemin de la route. Comme le chemin par défaut est/, si le middleware est monté sans spécifier de chemin, ce middleware sera exécuté pour chaque requête.

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

Les méthodes de middleware sont traitées dans l'ordre, donc l'ordre dans lequel le middleware est inclus est très important.

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

Le chemin peut être une chaîne représentant un chemin, un modèle de chemin, une expression régulière correspondant à un chemin, ou un tableau de ceux-ci.

Voici des exemples simples de chemins.

Type Exemple
Chemin
// will match paths starting with /abcd
app.use('/abcd', function (req, res, next) {
  next();
})
Modèle de chemin
// 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();
})
Expression régulière
// will match paths starting with /abc and /xyz
app.use(/\/abc|\/xyz/, function (req, res, next) {
  next();
})
Tableau
// will match paths starting with /abcd, /xyza, /lmn, and /pqr
app.use(['/abcd', '/xyza', /\/lmn|\/pqr/], function (req, res, next) {
  next();
})

La méthode peut être une méthode de middleware, une série de méthodes de middleware, un tableau de méthodes de middleware, ou une combinaison de celles-ci. Comme router et app implémentent l'interface middleware, vous pouvez les utiliser comme n'importe quelle autre méthode de middleware.

Utilisation Exemple
Middleware unique Vous pouvez définir et monter un middleware localement.
app.use(function (req, res, next) {
  next();
})
Un routeur est un middleware valide.
var router = express.Router();
router.get('/', function (req, res, next) {
  next();
})
app.use(router);
Une application Express est un middleware valide.
var subApp = express();
subApp.get('/', function (req, res, next) {
  next();
})
app.use(subApp);
Une série de middlewares Pour un même chemin de montage, vous pouvez monter plus d'un middleware.
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);
Tableau Logiquement, utilisez un tableau pour organiser un ensemble de middleware. Si vous passez un tableau de middleware comme premier paramètre ou comme seul paramètre, vous devez alors spécifier le chemin de montage.
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]);
Combinaison Vous pouvez combiner toutes les méthodes suivantes pour monter un middleware.
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);

Voici quelques exemples d'utilisation du middleware express.static dans une application Express.

Servez les ressources statiques situées dans le répertoire public sous le répertoire de l'application :

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

Dans/staticMontez le middleware sur le chemin pour fournir l'hébergement de ressources statiques, uniquement lorsque la requête commence par/staticcomme préfixe.

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

Désactivez la journalisation pour les requêtes de ressources statiques en chargeant le middleware logger après avoir configuré le middleware static.

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

Servez des ressources statiques à partir de différents chemins, mais./publicle chemin est plus facilement mis en correspondance que les autres :

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

Demande

reqL’objet représente une requête HTTP et possède des propriétés qui contiennent les données de la requête, telles que les paramètres de lachaîne de requête,, le,corps, les,en-têtes HTTPetc. Dans ce document, par convention, cet objet est toujours appeléreq(la réponse HTTP est appeléeres), mais leurs noms réels sont déterminés par les paramètres de la méthode de rappel dans laquelle ils sont utilisés.

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

En fait, vous pouvez aussi l'écrire comme ceci :

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

Propriétés

DansExpress 4Dans,req.filesPar défaut,reqil n'est plus disponible dans l'objet.req.filesobjet pour obtenir les fichiers téléversés, vous pouvez utiliser unmiddleware de gestion multipart(boîte à outils de gestion multipart), tel quebusboy,multer,formidable,multipraty,connect-multipartyoupez。

req.app

Cette propriété contient une référence à l'instance d'applicationexpress, qui peut être utilisée comme middleware.

Si vous suivez ce modèle, vous créez un module qui exporte un middleware, et ce middleware ne se trouve que dans votre fichier principal ;require()-le, alors ce middleware peut, viareq.app, obtenir l'instance Express.

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

Le chemin d'URL sur lequel une instance de routeur est montée.

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

Même si vous utilisez un modèle de chemin ou un tableau de modèles de chemin pour charger le routeur,baseUrlla propriété renvoie la chaîne correspondante, et non le modèle d'itinéraire. Dans l'exemple suivant,greetle routeur est chargé sur deux modèles de chemin.

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

Lorsqu'un chemin de requête est/greet/jp,baseUrlOui/greet, lorsqu'un chemin de requête est/hello/jp,req.baseUrlOui/hello。 req.baseUrletappla propriétémountpathde l'objet est similaire, sauf queapp.mountpathrenvoie le motif de correspondance du chemin.

req.body

Le corps de la requête contient des paires clé-valeur des données soumises. Par défaut, il estundefined, lorsque vous utilisez, par exemple,body-parseretmulterce type de middleware d'analysedu corpsdes données, il est rempli.body-parsermiddleware pour remplirreq.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

Lors de l'utilisation du middleware cookie-parser, cette propriété est un objet contenant les cookies envoyés avec la requête. Si la requête ne transporte pas de cookies, sa valeur est {}.

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

Pour plus d'informations, questions ou préoccupations, voircookie-parser。

req.fresh

Indique si la requête est fraîche. C'est l'opposé dereq.staleest l'opposé.cache-controll'en-tête de requête ne contient pasno-cachedirective et si l'une des conditions suivantes esttrue, alors c'esttrue:

  • if-modified-sincel'en-tête de requête est spécifié, etlast-modifiedl'en-tête de requête est égal ou antérieur àmodifiedl'en-tête de réponse.
  • if-none-matchl'en-tête de requête est*。
  • if-none-matchl'en-tête de requête, après avoir été analysé en ses directives, estetagn'est pas égal à la valeur de l'en-tête de réponse.

ps : Rôle de If-None-Match : If-None-Match fonctionne avec ETag. Le principe de fonctionnement consiste à ajouter les informations ETag dans la réponse HTTP. Lorsque l'utilisateur demande à nouveau la ressource, les informations If-None-Match (la valeur de l'ETag) sont ajoutées à la requête HTTP. Si le serveur vérifie que l'ETag de la ressource n'a pas changé (la ressource n'a pas été mise à jour), il renvoie un statut 304 pour indiquer au client d'utiliser le fichier de cache local. Sinon, il renvoie un statut 200 avec la nouvelle ressource et l'Etag. L'utilisation d'un tel mécanisme améliorera les performances du site Web.

req.fresh
// => true

req.hostname

contient la valeur dérivée deHostl'en-tête HTTPhostname。

Lorsquetrust proxyLorsque ce paramètre est défini sur une valeur activée,X-Forwarded-Hostl'en-tête est utilisé à la place deHost. Cet en-tête peut être défini par le client ou un proxy.

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

req.ips

Lorsquetrust proxyLorsque ce paramètre est défini sur une valeur activée, cette propriété contient un tableau d'adresses IPX-Forwarded-Forspécifiées dans l'en-tête de la requête. Sinon, elle contient un tableau vide. Cet en-tête peut être défini par le client ou un proxy.

Par exemple, siX-Forwarded-ForOuiclient,proxy1,proxy2,req.ipsalors il est["clinet", "proxy1", "proxy2"], oùproxy2est le plus en aval.

req.originalUrl

req.urln'est pas une propriété native d'Express; elle hérite du module http deNode。

Cette propriété est très similaire àreq.url; cependant, elle conserve l'URL de requête d'origine, ce qui vous permet de rediriger librementreq.urlvers des routes internes. Par exemple,app.use()demontagela fonctionnalité peut redirigerreq.urlvers le point de montage.

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

req.params

Un objet contenant des propriétés qui correspondent un à un aux noms de paramètres nommés dans la route. Par exemple, si vous avez la route/user/:name,namela propriété peut être utilisée commereq.params.name. La valeur par défaut de cet objet est{}。

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

Lorsque vous utilisez des expressions régulières pour définir des règles de route, les combinaisons de groupes de capture utilisent généralementreq.params[n], oùnest le numéro d’ordre du groupe de capture. Cette règle s’applique aux correspondances de jokers sans nom, telles que/file/*la route :

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

req.path

Contient la partie chemin de l’URL de la requête.

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

Lorsqu’il est appelé dans un middleware, le point de montage n’est pas inclus dansreq.path. Vous pouvez consulterapp.use()pour plus d’informations.

req.protocol

Le protocole de la requête, généralementhttp, et lorsque le chiffrement TLS est activé, il s’agit dehttps。

Lorsquetrust proxyLorsque le paramètre est défini sur une valeur activée, si l’en-têteX-Forwarded-Protoexiste, il sera approuvé et utilisé. Cet en-tête peut être défini par le client ou un proxy.

req.ptotocol
// => "http"

req.query

Un objet qui, pour chaque paramètre dechaîne de requêtedans la route, attribue une propriété. S’il n’y a pas dechaîne de requête, il s’agit d’un objet vide.{}。

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

La route actuellement correspondante, qui est une chaîne de caractères. Par exemple :

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

La sortie du segment précédent est :

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

req.secure

Une valeur booléenne. Si une connexion TLS est établie, alors elle esttrue. Équivalent à :

'https' == req.protocol;

req.signedCookies

Lors de l'utilisation ducookie-parsermiddleware, cette propriété contient la valeur signée envoyée avec la requêtecookies, et cette propriété obtient la valeur non signée qui peut être utilisée directement. Lescookies signésest stocké dans un objet différent afin de refléter l'intention du développeur ; sinon, une attaque malveillante peut être appliquée à la valeur dereq.cookie(il est très facile d'être trompé). N'oubliez pas que signer uncookiene consiste pas à le cacher ou à le chiffrer ; c'est simplement pour empêcher la falsification (car le chiffrement utilisé pour la signature est privé). Si aucuncookie signéest envoyé, alors cette propriété vaut par défaut{}。

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

Pour plus d'informations, questions ou préoccupations, voircookie-parser。

req.stale

Indique si la requête estpérimée(stale), ce qui est l'inverse dereq.fresh. Pour plus d'informations, voirreq.fresh。

req.stale
// => true

req.subdomains

Un tableau de sous-domaines dans le domaine de la requête.

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

req.xhr

Une valeur booléenne. SiX-Requested-Witha pour valeurXMLHttpRequest, alors elle esttrue, ce qui indique que la requête a été envoyée par une bibliothèque cliente, telle quejQuery。

req.xhr
// => true

Méthodes

req.accepts(types)

Vérifie si le type de contenu spécifié est accepté, d'après l'en-tête HTTP Accept de la requête. Cette méthode renvoie la meilleure correspondance. S'il n'y a pas de correspondance, elle renvoie undefined (dans ce cas, le serveur doit renvoyer 406 et "Not Acceptable").

La valeur de type peut être une chaîne de type MIME unique (comme application/json), une extension comme json, une liste séparée par des virgules ou un tableau. Pour une liste ou un tableau, cette méthode renvoie le meilleur élément (s'il y en a un).

// 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"

Pour plus d'informations, ou si vous avez des questions ou des préoccupations, consultezaccepts。

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

Renvoie le premier jeu de caractères configuré dans le jeu de caractères spécifié, d'après l'en-tête HTTPAccept-Charsetde la requête. Si aucun jeu de caractères correspondant n'est trouvé, renvoie false. Pour plus d'informations, ou si vous avez des questions ou des préoccupations, consultezaccepts。

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

Retourne le premier encodage accepté de l'ensemble d'encodages spécifié, en fonction deAccept-Encodingl'en-tête HTTP de la requête. Si aucun encodage correspondant n'est trouvé dans l'ensemble d'encodages spécifié, retourne false. Pour plus d'informations, ou si vous avez des questions ou des préoccupations, consultezaccepts。

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

Retourne la première langue acceptée de l'ensemble de langues spécifié, en fonction deAccept-Languagel'en-tête HTTP de la requête. Si aucune langue correspondante n'est trouvée dans l'ensemble de langues spécifié, retourne false. Pour plus d'informations, ou si vous avez des questions ou des préoccupations, consultezaccepts。

req.get(field)

Retourne le contenu du champ d'en-tête HTTP de requête spécifié (insensible à la casse).ReferreretRefererLe contenu du champ est interchangeable.

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

C'est un alias de req.header(field).

req.is(type)

Si le champ d'en-têteContent-typede la requête entrante correspond au paramètretypedonnétype MIME, alors il retournetrue. Sinon, il retournefalse。

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

Pour plus d'informations, ou si vous avez des questions ou des préoccupations, consulteztype-is。

req.param(naem, [, defaultValue])

Obsolète. Utilisez, le cas échéant,req.params,req.bodyoureq.query。

Renvoie lenom/lavaleur du paramètre actuel.

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

La recherche est effectuée dans l'ordre suivant :

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

En option, vous pouvez spécifier undefaultValuepour définir une valeur par défaut si ce paramètre ne peut être trouvé dans aucun des objets de requête.

Directement viareq.params,req.body,req.queryl'obtenir devrait être plus clair - à moins que vous ne soyez certain de l'entrée de chaque objet.Body-parserLe middleware doit être chargé si vous utilisezreq.param(). Pour plus de détails, voirreq.body。

Response

resreprésente, lorsqu'une requête HTTP arrive,Expressla réponse HTTP renvoyée par l'application. Dans cette documentation, par convention, cet objet est toujours abrégé enres(la requête HTTP est abrégée enreq), mais leurs noms réels sont déterminés par les paramètres de la méthode de rappel dans laquelle ils sont utilisés.

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

Par exemple :

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

Propriétés

res.app

Écrire de cette façon revient au même :

Cette propriété contient une référence à l'instance d'application Express, qui peut être utilisée dans un middleware.

res.headersSent

res.app et la propriété req.app dans l'objet requête sont identiques.</p>

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

res.locals

Propriété booléenne indiquant si cette réponse a déjà envoyé des en-têtes HTTP.app.localsUn objet qui contient des variables locales à la réponse de cette requête, et par conséquent ses variables ne sont disponibles que pour le rendu des vues pendant le cycle de la réponse à cette requête (s'il y a des vues). Pour le reste, il et

sont les mêmes.

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

Méthodes

res.append(field [, value])

Ce paramètre est très utile pour exposer des informations au niveau de la requête, telles que le chemin de la requête, l'utilisateur authentifié, les paramètres utilisateur, etc.ExpresxsLa méthode res.append() est

uniquement prise en charge dans les versions 4.11.0 et supérieures.fieldà lavaleur spécifiéechamp d'en-tête HTTP, ajoute la valeur spécifiée.valueSi cet en-tête n'a pas été défini, alors utilisezvaluepour créer cet en-tête.

peut être une chaîne de caractères ou un tableau.res.append()Remarque : après avoir appeléapp.set()calling

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])

la fonction réinitialisera la valeur précédemment définie.Content-DispositionDéfinit le contenu de l'en-têtefilenamede la réponse HTTP sur 'attachment'. Si fournires.type(), puis viaContent-Typeobtenir l'extension pour définirContent-Disposition, et définir

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])

contenu dans 'filename=parameter'.nometvaleurducookie,valeurLa

paramètre peut être une chaîne ou un objet converti en chaîne JSON.

options est un objet qui peut avoir les propriétés suivantes. Propriété Type
domain String Description
expires Date Définit le nom de domaine du cookie. La valeur par défaut est le domaine de votre application.
httpOnly Boolean La date d'expiration du cookie, au format GMT. Si elle n'est pas spécifiée ou définie à 0, un nouveau cookie est généré.
maxAge String Un indicateur indiquant que ce cookie ne peut être obtenu que par le serveur web.
path String est une option pratique pour définir la date d'expiration ; il s'agit de la valeur en millisecondes entre l'heure actuelle et la date d'expiration./。
secure Boolean Le chemin du cookie. La valeur par défaut estHTTPSIndique que ce cookie ne peut être utilisé que par
signed Boolean protocole.

Indique que ce cookie doit être signé.optionsCe que fait res.cookie() est basé sur le paramètre fourniSet-Cookieparamètre pour définiroptionsen-tête. Si aucune desRFC6265options n'est spécifiée, alors la valeur par défaut est

spécifié dans

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

Exemples d'utilisation :

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

maxAge est une option pratique pour définir le délai d'expiration, calculé en millisecondes à partir de l'heure actuelle. L'exemple suivant a le même effet que le deuxième ci-dessus.

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

Vous pouvez passer un objet comme paramètre value. Il sera alors sérialisé en tant que chaîne JSON et analysé par le middleware bodyParser().

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

res.clearCookie(name [,options])

Lors de l'utilisation du middleware cookie-parser, cette méthode prend également en charge les cookies signés. Il suffit d'inclure l'option signed définie sur true lors de la définition des options. Ensuite, res.cookie() utilisera le secret transmis à cookieParser(secret) pour signer la valeur.nameSelon lesoptions spécifiéesefface le cookie correspondant. Pour plus d'informations surres.cookie()。

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

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

objet, voirpathTransfèreContent-Dispositionle fichier spécifié en tant que pièce jointe. Habituellement, le navigateur invite l'utilisateur à télécharger. Par défaut,pathle paramètre 'filename=' dans l'en-tête estfilename(apparaît généralement dans la boîte de dialogue du navigateur). En spécifiant

paramètre pour remplacer la valeur par défaut.fnLorsqu'une erreur se produit ou que le transfert est terminé, cette méthode appellerares.sendFile()la méthode de rappel spécifiée. Cette méthode utilise

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])

pour transférer le fichier.NodeMet fin au processus de réponse. Cette méthode provient en fait de la méthoderesponse.end() de http.ServerResponse。

le module principal, plus précisémentres.send()etres.json()utilisés pour terminer rapidement la requête sans aucune donnée. Si vous devez envoyer des données, vous pouvez utiliser

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

res.format(object)

des méthodes comme celles-ci.AcceptEffectue une négociation de contenu, en fonction de l'en-tête HTTP406Accept de l'objet requête, qui spécifie le contenu acceptable. Il utilise req.accepts() pour sélectionner un gestionnaire pour servir la requête ; ces gestionnaires sont triés par valeur de qualité. Si cet en-tête n'est pas spécifié, la première méthode est appelée par défaut. Lorsqu'il n'y a aucune correspondance, le serveur renvoiepar défaut'Not Acceptable', ou appelle

Content-Typela fonction de rappel.res.set()L'en-tête de réponse est défini lorsqu'une méthode de rappel est sélectionnée. Toutefois, vous pouvez le modifier dans cette méthode à l'aide de méthodes telles queres.type()。

ou{"message":"hey"}L'exemple suivant répondra avecAcceptlorsque*/*l'en-tête de l'objet requête est défini sur 'application/json' ou '*/json' (mais s'il est

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

, alors la réponse sera 'hey').

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

res.get(field)

En plus des types MIME normalisés, vous pouvez également utiliser des extensions pour mapper ces types afin d'éviter des implémentations verbeuses :fieldRenvoie

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

res.json([body])

l'en-tête de réponse HTTP spécifié. La correspondance est sensible à la casse.res.send()Envoie une réponse JSON. Cette méthode est identique au fait de passer un objet ou un tableau comme paramètre ànull,undefinedméthode. Toutefois, vous pouvez utiliser cette méthode pour convertir d'autres valeurs en JSON, telles que

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

res.jsonp([body])

. (Bien que ceux-ci soient techniquement du JSON invalide).

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

Envoie une réponse JSON et prend en charge JSONP. Cette méthode a le même effet que res.json(), sauf qu’elle prend en charge les callbacks JSONP dans ses options.nom du callback JSONPPar défaut, la méthode de callback JSONP est simplement écrite comme callback. Elle peut être

remplacée via le paramètre.

// ?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)

Voici quelques exemples utilisant des réponses JSONP, avec le même code :links,linksJoint les liens

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

fournis en tant que propriétés du paramètre transmis ; le contenu joint est utilisé pour renseigner l’en-tête HTTP Link de la réponse.

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

res.location(path)

Résultat :LocationDéfinit l'en-tête HTTPpathde la réponse à la valeur spécifiée

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

Lorsquepathparamètre.retourLorsque le paramètre estReferer, il a une signification particulière ; il spécifie l'URL comme celle de l'objet de requête

URL spécifiée par l'en-tête. Si elle n'est pas spécifiée dans la requête, alors elle est '/'.LocationExpress transmet la chaîne URL spécifiée comme réponse au navigateur dans la valeur d'en-têtebackde la réponse, sans détection ni manipulation, sauf pourlocationce paramètre. Le navigateur redirigera l'utilisateur versRefererl'URL définie par, oubackl'URL de (

res.redirect([status,] path)

cas du paramètre).pathRedirige vers l'URL dérivée du spécifiécode d'état HTTPstatusURL, et le spécifiéstatus. Si vous ne spécifiez pas

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

, le code de statut vaut par défaut '302 Found'.

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

La redirection peut aussi être une URL complète, pour rediriger vers un autre site.http://example.com/blog/admin/La redirection peut aussi être relative à l'URL actuelle. Par exemple, depuis/(notez le / finalhttp://example.com/blog/admin/post/new。

res.redirect('post/new');

), ce qui suit redirigera vershttp://example.com/blog/admin(sans le / final/), redirigerpost/new, redirigera vershttp://example.com/blog/post/new. Si vous trouvez ce qui précède déroutant, vous pouvez considérer les segments de chemin comme des répertoires (avec '/') ou des fichiers, c'est acceptable. Les redirections de chemin relatif sont également autorisées. Si votre chemin actuel esthttp://example.com/admin/post/new, l'opération suivante redirigera vershttp://example.com/admin/post:

res.redirect('..');

backRedirige la requête versreferer, lorsqu'aucunreferern'est fourni, la valeur par défaut est/。

res.redirect('back');

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

Affiche une vue, puis envoie le document HTML rendu au client. Les paramètres facultatifs sont :

  • locals, un objet qui définit les attributs des propriétés locales de la vue.
  • callback, une fonction de rappel. Si ce paramètre est fourni, la méthoderenderrenverra l'erreur et le modèle rendu, et n'enverra pas automatiquement la réponse. Lorsqu'une erreur se produit, vous pouvez appelernext(err)méthode à l'intérieur de ce callback.

La mise en cache des variables locales active la mise en cache des vues. Pour mettre en cache les vues dans l'environnement de développement, vous devez le définir manuellement sur true ; la mise en cache des vues est activée par défaut dans l'environnement de production.

// 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])

Envoie une réponse HTTP.

bodyLe paramètre peut être un objetBuffer, une chaîne, un objet ou un tableau. Par exemple :

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

Pour les requêtes générales non-streaming, cette méthode peut effectuer de nombreuses tâches utiles : par exemple, elle attribue automatiquement l'en-tête de réponse HTTP Content-Length (sauf s'il a été défini précédemment), et prend également en charge les mises à jour automatiques du cache HEAD et HTTP.

Lorsque le paramètre est un objet Buffer, cette méthode définit l'en-tête de réponse Content-Type sur application/octet-stream, sauf s'il est fourni à l'avance, comme indiqué ci-dessous :

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

Lorsque le paramètre est une chaîne, cette méthode définit l'en-tête de réponse Content-Type sur text/html :

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

Lorsque le paramètre est un objet ou un tableau, Express le représente au format JSON :

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

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

res.sendFile()à partir deExpress v4.8.0La prise en charge a commencé.

Transférerpathle fichier spécifié. Définir l'en-tête HTTPContent-Typeen fonction de l'extension de fichier. Sauf dansoptionsil y a un paramètre concernantroot,pathdoit être un chemin absolu vers le fichier.optionsdétails des paramètres :

Propriété Description Valeur par défaut Versions disponibles
maxAge Définir leCache-Controldemax-agepropriété, en millisecondes, ou une chaîne au formatmsformat 0
root Répertoire racine relatif au nom du fichier
lastModified Définir l'en-têteLast-Modifiedsur la dernière heure de modification de ce fichier dans le système. Définirfalsepour le désactiver. Activer 4.9.0+
headers Un objet contenant des en-têtes HTTP liés aux fichiers.
dotfiles L'option pour savoir si les dotfiles sont pris en charge. Les valeurs possibles sont "allow", "deny", "ignore" "ignore"  

Lorsque le transfert est terminé ou qu'une erreur se produit, cette méthode appelle la méthode de rappelfn. Si ce paramètre de rappel est spécifié et qu'une erreur se produit, la méthode de rappel doit explicitement gérer le processus de réponse en terminant le cycle requête-réponse ou en passant le contrôle à la route suivante.

Voici un exemple d'utilisation de tous les paramètres avecres.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 offre une prise en charge fine du service de fichiers, comme illustré dans l'exemple suivant :

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

Pour plus d'informations, ou si vous avez des questions ou des préoccupations, reportez-vous àsend。

res.sendStatus(statusCode)

Définit lecode d'état HTTP de l'objet de réponseeststatusCodeet envoiestatusCodela représentation sous forme de chaîne correspondante de comme corps de la réponse.

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

Si un statut non pris en charge est spécifié, le statut HTTP est quand même défini surstatusCodeet la chaîne de ce code est utilisée comme corps.

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

En savoir plus sur les codes d'état HTTP

res.set(field [, value])

Définit l'en-tête HTTP de l'objet de réponsefieldestvalue. Pour définir plusieurs valeurs à la fois, vous pouvez passer un objet comme paramètre.

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

Il a le même effet que res.header(field [,value]).

res.status(code)

Utilisez cette méthode pour définir le statut HTTP de l'objet de réponse. C'est, dans Node, un alias chaînable deresponse.statusCode.

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

res.type(type)

L'application définira le type MIMEContent-Typede l'en-tête HTTP, si cetypedéfini peut êtremime.lookupanalysé en le bonContent-Type. Sitypecontient/caractères, l'application définira directementContent-Typeesttype。

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)

Ajoute l'en-tête de réponse Vary lorsqu'il n'y a pas d'en-tête de réponse Vary.

Remarque : la signification de Vary est d'indiquer aux serveurs proxy/caches/CDN comment déterminer si les requêtes sont identiques. Les combinaisons dans Vary sont la base pour que les serveurs/caches/CDN puissent déterminer cela. Par exemple, si Vary contient User-Agent, alors même pour la même requête, si un utilisateur ouvre une page avec IE puis l'ouvre à nouveau avec Firefox, le CDN/proxy les considérera comme des pages différentes. Si Vary ne contient pas User-Agent, le CDN/proxy les considérera comme la même page et renverra directement la page mise en cache à l'utilisateur sans redemander la page au serveur web. En termes simples, cela équivaut àfielden l'utilisant comme clé de cache pour déterminer si le cache est touché.

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

Router

Arouterobjet est une instance autonome de middleware et de routage. Vous pouvez le considérer comme une « mini-application » qui a la capacité d'opérer sur les méthodes de middleware et de routage. ChaqueExpressapplication possède un routeur d'application intégré.app.use()paramètre de méthode ou comme celui d'une autre routeuse()paramètre.expressobjet a unRouter()méthode, et vous pouvez utiliserRouter()pour créer un nouveaurouterobjet.

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

Router([options])

Comme suit, vous pouvez créer une route :

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

optionsLe paramètre peut spécifier le comportement de la route, avec les options suivantes :

Propriété Description Valeur par défaut Disponibilité
caseSensitive Indique s'il faut distinguer la casse Non activé par défaut. Traitez/Fooet/foode la même manière.
mergeParams Préserve lesres.paramsde la route parente. Si les paramètres de la route parente entrent en conflit avec les paramètres de la route enfant, les paramètres de la route enfant sont prioritaires. false 4.5.0+
strict Active le routage strict. Non activé par défaut,/fooet/foo/sont traités de la même manière par le routage.  

Vous pouvez considérerroutercomme une application, à laquelle vous pouvez ajouter des middlewares et des méthodes de routage HTTP (telles queget,put,postetc.).

// 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) {
  // ..
});

Vous pouvez monter un routeur sur une URL racine spécifique, afin de pouvoir placer vos différentes routes dans différents fichiers ou même des mini-programmes.

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

Méthodes

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

Cette méthode est identique à la méthoderouter.METHOD(), sauf que cette méthode correspond à toutes les actions HTTP.

Cette méthode est très utile pour mapper une logique globale à un préfixe de chemin spécifique ou à une correspondance arbitraire. Par exemple, si vous placez la route présentée ci-dessous avant d'autres routes, elle exigera que toutes les routes à partir de ce point effectuent des opérations de vérification et chargent automatiquement les informations utilisateur. N'oubliez pas que ces opérations de logique globale n'ont pas besoin de terminer le cycle requête-réponse :loaduserVous pouvez effectuer une tâche, puis appelernext()pour transmettre le flux d'exécution aux routes suivantes.

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

Forme équivalente :

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

Ceci est un exemple de fonctionnalité globale de liste blanche. Cet exemple est similaire au précédent, mais il ne s'applique qu'aux chemins commençant par/api:

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

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

router.METHOD()La méthode fournit des méthodes de routage dansExpress, oùMETHODest l'une des méthodes HTTP, telles queGET,PUT,POSTetc., mais lerouterMETHOD y est en minuscules. Par conséquent, les méthodes réelles sontrouter.get(),router.put(),router.post()etc.

Vous pouvez fournir plusieurs fonctions de rappel, qui se comportent comme des intergiciels, sauf que ces rappels peuvent appelernext('router')pour contourner les rappels de route restants. Vous pouvez utiliser ce mécanisme pour définir des préconditions pour une route. Si la requête ne satisfait pas les conditions de traitement de la route actuelle, passez le contrôle aux routes suivantes.

L'extrait suivant peut illustrer la définition de route la plus simple. Express convertit la chaîne de chemin en une expression régulière pour la correspondance interne des requêtes entrantes. Lors de la correspondance, il ne prend pas en compteles chaînes de requête, par exemple, "GET /" correspondra à la route suivante, et "GET /?name=tobi" aussi.

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

Si vous avez des restrictions spéciales sur le chemin à mettre en correspondance, vous pouvez utiliser des expressions régulières. Par exemple, ce qui suit peut correspondre à "GET /commits/71dbb9c" et "GET /commits/71bb92..4c084f9".

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)

Ajoute des déclencheurs de rappel aux paramètres de route, oùnameest le nom du paramètre,functionest la méthode de rappel. Les paramètres de la méthode de rappel, dans l'ordre, sont l'objet de requête, l'objet de réponse, le prochain intergiciel, la valeur du paramètre et le nom du paramètre. Bien quenamesoit techniquement facultatif, il n'est pas recommandé après Express V4.11.0 (voir ci-dessous).

Contrairement àapp.param(),router.param()n'accepte pas un tableau comme paramètres de route.

Par exemple, lorsque:userapparaît dans le chemin de route, vous pouvez mapper la logique de chargement de l'utilisateur pour fournir automatiquementreq.userà cette route, ou valider les paramètres d'entrée.

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

Pour les routes définies par callbackParam, elles sont locales. Elles ne sont pas héritées par l'application ou le routeur monté. Par conséquent, définies surrouterleparamcallbacks uniquement si surrouterne prennent effet que lorsque la route sur celui-ci possède ce paramètre de route.

Lors de la définition deparamsur la route,paramles callbacks sont les premiers à être appelés, et ils seront appelés une fois et une seule dans un cycle requête-réponse, même si plusieurs routes correspondent, comme dans l'exemple suivant :

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

Lorsqu'une requête GET /user/42 est demandée, le résultat suivant est obtenu :

CALLED ONLY ONCE
although this matches
and this matches too

Décrit dans la section suivante,router.param(callback)est obsolète depuis la v4.11.0.

En ne passant qu'un seul paramètre callback à la méthoderouter.param(name, callback),router.param(naem, callback)le comportement de la méthode sera complètement modifié. Ce paramètre callback est une méthode personnalisée qui définitrouter.param(name, callback)le comportement qu'elle doit avoir. Cette méthode doit accepter deux paramètres et renvoyer un middleware.

Le premier paramètre de ce callback est le nom du paramètre d'URL à capturer, et le second paramètre peut être n'importe quel objet JavaScript, qui peut être utilisé lors de l'implémentation du middleware retourné. Le middleware retourné par cette méthode callback détermine le comportement à adopter lorsque l'URL contient ce paramètre.

Dans l'exemple suivant,router.param(name, callback)la signature des paramètres a été modifiée enrouter.param(name, accessId). Le remplacement accepte un nom de paramètre et un callback,router.param()et accepte maintenant un nom de paramètre et un nombre.

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

Dans cet exemple, la signature du paramètre router.param(name. callback) reste la même qu'auparavant, mais elle est remplacée par un middleware qui définit une méthode de détection de type de données personnalisée pour vérifier la validité du type d'identifiant utilisateur.

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)

Renvoie une instance de route singleton, sur laquelle vous pouvez ensuite appliquer des middlewares pour diverses actions HTTP. Utilisezrouter.route()pour éviter les noms de route en double (par ex. les fautes de frappe) -- l'objectif est d'utiliserrouter.route()cette méthode singleton pour éviter plusieurs instances de route pour le même chemin.

Basé sur l'exemplerouter.param()ci-dessus, le code suivant montre comment utiliserrouter.route()pour spécifier des gestionnaires pour diverses méthodes HTTP.

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

Cette méthode réutilise un seul chemin /usrs/:userid pour ajouter diverses méthodes HTTP.

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

Pour le paramètre optionnelpath, montez la méthode middleware donnée sur le chemin spécifié. Si le paramètrepathn'est pas spécifié, la valeur par défaut est/.app.use(). Cette méthode est similaire àapp.use()pour plus d'informations.

Un middleware est comme une canalisation. La requête commence au premier middleware que vous définissez et descend dans la pile de middlewares, en traitant la requête si le chemin correspond.

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

Pour les fonctions middleware, le chemin monté est supprimé et invisible. Le principal impact de cette fonctionnalité est que, pour différents chemins, le montage du même middleware peut ne pas nécessiter de modifications de code, même si son préfixe a changé.

L'ordre dans lequel vous définissez les middlewares à l'aide de router.use() est important. Les middlewares sont appelés dans l'ordre, donc l'ordre détermine la priorité des middlewares. Par exemple, la journalisation est généralement le premier middleware que vous utilisez, afin que chaque requête soit enregistrée.

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

Maintenant, pour gérer le fait que vous ne souhaitez pas journaliser les requêtes de fichiers statiques, mais que vous souhaitez continuer à journaliser les routes et middlewares définis aprèslogger(). Vous pouvez simplement déplacerstatic()au début pour résoudre cela :

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

Un autre exemple concret est l'hébergement de fichiers statiques à partir de chemins différents. Vous pouvez placer./publicdevant pour obtenir une priorité plus élevée :

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

router.use()La méthode prend également en charge les paramètres nommés, de sorte que votre point de montage peut utiliser des paramètres nommés pour le préchargement par rapport à d'autres routes, ce qui est très bénéfique.

Adresse d'origine : https://github.com/bajian/express_api_4.x_chinese