Routage
Routage fait rĂ©fĂ©rence Ă la dĂ©finition de points finaux dâapplication (URI) et Ă la façon dont ils rĂ©pondent aux demandes client. Pour une introduction au routage, voir Basic routing.
You define routing using methods of the Express app
object that correspond to HTTP methods;
for example, app.get()
to handle GET requests and app.post
to handle POST requests. For a full list,
see app.METHOD. You can also use app.all() to handle all HTTP methods and app.use() to
specify middleware as the callback function (See Using middleware for details).
These routing methods specify a callback function (sometimes called âhandler functionsâ) called when the application receives a request to the specified route (endpoint) and HTTP method. In other words, the application âlistensâ for requests that match the specified route(s) and method(s), and when it detects a match, it calls the specified callback function.
In fact, the routing methods can have more than one callback function as arguments.
With multiple callback functions, it is important to provide next
as an argument to the callback function and then call next()
within the body of the function to hand off control
to the next callback.
Le code suivant est un exemple de routage trĂšs basique.
const express = require('express')
const app = express()
// respond with "hello world" when a GET request is made to the homepage
app.get('/', (req, res) => {
res.send('hello world')
})
Méthodes de routage
Une mĂ©thode de routage est dĂ©rivĂ©e de lâune des mĂ©thodes HTTP, et est liĂ©e Ă une instance de la classe express
.
Le code suivant est un exemple de routes qui sont dĂ©finies pour les mĂ©thodes GET et POST jusquâĂ la route de lâapplication.
// GET method route
app.get('/', (req, res) => {
res.send('GET request to the homepage')
})
// POST method route
app.post('/', (req, res) => {
res.send('POST request to the homepage')
})
Express supports methods that correspond to all HTTP request methods: get
, post
, and so on.
For a full list, see app.METHOD.
Il existe une méthode de routage spéciale, app.all()
, qui nâest pas dĂ©rivĂ©e dâune mĂ©thode HTTP. Cette mĂ©thode est utilisĂ©e pour charger des fonctions middleware Ă un chemin dâaccĂšs pour toutes les mĂ©thodes de demande.
app.all('/secret', (req, res, next) => {
console.log('Accessing the secret section ...')
next() // pass control to the next handler
})
Chemins de routage
Les chemins de routage, combinĂ©s Ă une mĂ©thode de demande, dĂ©finissent les noeuds finaux sur lesquels peuvent ĂȘtre effectuĂ©es les demandes. Les chemins de routage peuvent ĂȘtre des chaĂźnes, des masques de chaĂźne ou des expressions rĂ©guliĂšres.
Caution
In express 5, the characters ?
, +
, *
, []
, and ()
are handled differently than in version 4, please review the migration guide for more information.
Caution
In express 4, regular expression characters such as $
need to be escaped with a \
.
Note
Express uses path-to-regexp for matching the route paths; see the path-to-regexp documentation for all the possibilities in defining route paths. Express Route Tester est un outil pratique permettant de tester des routes Express de base, bien quâil ne prenne pas en charge le filtrage par motif.
Warning
Query strings are not part of the route path.
Il sâagit dâexemples de chemins de routage basĂ©s sur des chaĂźnes.
Ce chemin de routage fera correspondre des demandes Ă la route racine, /
.
app.get('/', (req, res) => {
res.send('root')
})
Ce chemin de routage fera correspondre des demandes Ă /about
.
app.get('/about', (req, res) => {
res.send('about')
})
Ce chemin de routage fera correspondre des demandes Ă /random.text
.
app.get('/random.text', (req, res) => {
res.send('random.text')
})
Il sâagit dâexemples de chemins de routage basĂ©s sur des masques de chaĂźne.
Caution
The string patterns in Express 5 no longer work. Please refer to the migration guide for more information.
Ce chemin de routage fait correspondre acd
et abcd
.
app.get('/ab?cd', (req, res) => {
res.send('ab?cd')
})
Ce chemin de routage fait correspondre abcd
, abbcd
, abbbcd
, etc.
app.get('/ab+cd', (req, res) => {
res.send('ab+cd')
})
Ce chemin de routage fait correspondre abcd
, abxcd
, abRABDOMcd
, ab123cd
, etc.
app.get('/ab*cd', (req, res) => {
res.send('ab*cd')
})
Ce chemin de routage fait correspondre /abe
et /abcde
.
app.get('/ab(cd)?e', (req, res) => {
res.send('ab(cd)?e')
})
Exemples de chemins de routage basés sur des expressions réguliÚres :
Ce chemin de routage fera correspondre tout Ă©lĂ©ment dont le nom de chemin comprend la lettre âaâ.
app.get(/a/, (req, res) => {
res.send('/a/')
})
Ce chemin de routage fera correspondre butterfly
et dragonfly
, mais pas butterflyman
, dragonfly man
, etc.
app.get(/.*fly$/, (req, res) => {
res.send('/.*fly$/')
})
Les chaĂźnes de requĂȘte ne font pas partie du chemin de routage.
Route parameters are named URL segments that are used to capture the values specified at their position in the URL. The captured values are populated in the req.params
object, with the name of the route parameter specified in the path as their respective keys.
Route path: /users/:userId/books/:bookId
Request URL: http://localhost:3000/users/34/books/8989
req.params: { "userId": "34", "bookId": "8989" }
To define routes with route parameters, simply specify the route parameters in the path of the route as shown below.
app.get('/users/:userId/books/:bookId', (req, res) => {
res.send(req.params)
})
The name of route parameters must be made up of âword charactersâ ([A-Za-z0-9_]).
Since the hyphen (-
) and the dot (.
) are interpreted literally, they can be used along with route parameters for useful purposes.
Route path: /flights/:from-:to
Request URL: http://localhost:3000/flights/LAX-SFO
req.params: { "from": "LAX", "to": "SFO" }
Route path: /plantae/:genus.:species
Request URL: http://localhost:3000/plantae/Prunus.persica
req.params: { "genus": "Prunus", "species": "persica" }
Caution
In express 5, Regexp characters are not supported in route paths, for more information please refer to the migration guide.
To have more control over the exact string that can be matched by a route parameter, you can append a regular expression in parentheses (()
):
Route path: /user/:userId(\d+)
Request URL: http://localhost:3000/user/42
req.params: {"userId": "42"}
Warning
Because the regular expression is usually part of a literal string, be sure to escape any \
characters with an additional backslash, for example \\d+
.
Warning
In Express 4.x, the *
character in regular expressions is not interpreted in the usual way. As a workaround, use {0,}
instead of *
. This will likely be fixed in Express 5.
Gestionnaires de routage
Vous pouvez fournir plusieurs fonctions de rappel qui se comportent comme des middleware pour gérer une demande. La seule exception est que ces fonctions de rappel peuvent faire appel à next('route')
pour ignorer les rappels de route restants. Vous pouvez utiliser ce mĂ©canisme pour imposer des conditions prĂ©alables sur une route, puis passer aux routes suivantes si aucune raison nâest fournie pour traiter la route actuelle.
Les gestionnaires de route se trouvent sous la forme dâune fonction, dâun tableau de fonctions ou dâune combinaison des deux, tel quâindiquĂ© dans les exemples suivants.
Une fonction de rappel unique peut traiter une route. Par exemple :
app.get('/example/a', (req, res) => {
res.send('Hello from A!')
})
Plusieurs fonctions de rappel peuvent traiter une route (nâoubliez pas de spĂ©cifier lâobjet next
). Par exemple :
app.get('/example/b', (req, res, next) => {
console.log('the response will be sent by the next function ...')
next()
}, (req, res) => {
res.send('Hello from B!')
})
Un tableau de fonctions de rappel peut traiter une route. Par exemple :
const cb0 = function (req, res, next) {
console.log('CB0')
next()
}
const cb1 = function (req, res, next) {
console.log('CB1')
next()
}
const cb2 = function (req, res) {
res.send('Hello from C!')
}
app.get('/example/c', [cb0, cb1, cb2])
Une combinaison de fonctions indépendantes et des tableaux de fonctions peuvent gérer une route. Par exemple :
const cb0 = function (req, res, next) {
console.log('CB0')
next()
}
const cb1 = function (req, res, next) {
console.log('CB1')
next()
}
app.get('/example/d', [cb0, cb1], (req, res, next) => {
console.log('the response will be sent by the next function ...')
next()
}, (req, res) => {
res.send('Hello from D!')
})
Méthodes de réponse
Les mĂ©thodes de lâobjet de rĂ©ponse (res
) dĂ©crites dans le tableau suivant peuvent envoyer une rĂ©ponse au client, et mettre fin au cycle de demande-rĂ©ponse. Si aucune de ces mĂ©thodes nâest appelĂ©e par un gestionnaire de routage, la demande du client restera bloquĂ©e.
Méthode | Description |
---|---|
res.download() | Vous invite à télécharger un fichier. |
res.end() | Met fin au processus de réponse. |
res.json() | Envoie une réponse JSON. |
res.jsonp() | Envoie une réponse JSON avec une prise en charge JSONP. |
res.redirect() | Redirige une demande. |
res.render() | GénÚre un modÚle de vue. |
res.send() | Envoie une réponse de divers types. |
res.sendFile() | Send a file as an octet stream. |
res.sendStatus() | Définit le code de statut de réponse et envoie sa représentation sous forme de chaßne comme corps de réponse. |
app.route()
Vous pouvez créer des gestionnaires de routage sous forme de chaßne pour un chemin de routage en utilisant app.route()
.
Etant donnĂ© que le chemin est spĂ©cifiĂ© Ă une seul emplacement, la crĂ©ation de routes modulaires est utile car elle rĂ©duit la redondance et les erreurs. Pour plus dâinformations sur les routes, voir la documentation Router().
Voici quelques exemples de gestionnaires de chemin de chaĂźnage dĂ©finis Ă lâaide de app.route()
.
app.route('/book')
.get((req, res) => {
res.send('Get a random book')
})
.post((req, res) => {
res.send('Add a book')
})
.put((req, res) => {
res.send('Update the book')
})
express.Router
Utilisez la classe express.Router
pour crĂ©er des gestionnaires de route modulaires et pouvant ĂȘtre montĂ©s. Une instance Router
est un middleware et un systĂšme de routage complet ; pour cette raison, elle est souvent appelĂ©e âmini-appâ.
Lâexemple suivant créé une routeur en tant que module, charge une fonction middleware, dĂ©finit des routes et monte le module de routeur sur un chemin dans lâapplication principale.
Créez un fichier de routage nommé birds.js
dans le répertoire app, avec le contenu suivant :
const express = require('express')
const router = express.Router()
// middleware that is specific to this router
const timeLog = (req, res, next) => {
console.log('Time: ', Date.now())
next()
}
router.use(timeLog)
// define the home page route
router.get('/', (req, res) => {
res.send('Birds home page')
})
// define the about route
router.get('/about', (req, res) => {
res.send('About birds')
})
module.exports = router
Puis, chargez le module de routage dans lâapplication :
const birds = require('./birds')
// ...
app.use('/birds', birds)
Lâapplication pourra dorĂ©navant gĂ©rer des demandes dans /birds
et /birds/about
, et appeler la fonction middleware timeLog
spécifique à la route.
But if the parent route /birds
has path parameters, it will not be accessible by default from the sub-routes. To make it accessible, you will need to pass the mergeParams
option to the Router constructor reference.
const router = express.Router({ mergeParams: true })