Routage

Caution

Dans Express 5, les caractères ?, +, *, [], et () sont traités différemment par rapport à la version 4. Veuillez consulter le migration guide pour plus d’informations.

Caution

Dans Express 4, les caractères d’expression régulière tels que $ doivent être échappés avec un \.

Caution

Les motifs de chaînes (string patterns) ne fonctionnent plus dans Express 5. Veuillez consulter migration guide pour plus d’informations.

Le nom des paramètres de route doit être composé de “caractères alphanumériques” ([A-Za-z0-9_]).</div>

Comme le tiret (-) et le point (.) sont interprétés littéralement, ils peuvent être utilisés avec les paramètres de route à des fins pratiques.

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

Pour mieux contrôler la chaîne exacte pouvant être capturée par un paramètre de route, vous pouvez ajouter une expression régulière entre parenthèses (()):

Route path: /user/:userId(\d+)
Request URL: http://localhost:3000/user/42
req.params: {"userId": "42"}

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.

app.get('/user/:id', (req, res, next) => {
  if (req.params.id === '0') {
    return next('route')
  }
  res.send(`User ${req.params.id}`)
})

app.get('/user/:id', (req, res) => {
  res.send('Special handler for user ID 0')
})

Dans cet exemple :

• GET /user/5 → géré par la première route → envoie “User 5”
• GET /user/0 → la première route appelle next('route'), en passant à la prochaine route correspondant à /user/:id

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.

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.

Mais si la route parente /birds possède des paramètres de chemin, ils ne seront pas accessibles par défaut depuis les sous-routes. Pour qu’ils soient accessibles, vous devez passer l’option mergeParams au constructeur de Router reference.

const router = express.Router({ mergeParams: true })