Routage en node.js avec express.js

Le routage fait référence à la façon dont les points de terminaison (URI) d’une application répondent aux demandes des clients.

Le routage fait référence à la détermination de la façon dont une application répond à une requête client vers un point d’extrémité particulier, qui est un URI (ou chemin) et une méthode de requête HTTP spécifique (GET, POST, et ainsi de suite).

Chaque route peut avoir une ou plusieurs fonctions de gestion, qui sont exécutées lorsque la route est mise en correspondance.

La définition de route prend la structure suivante :

app.METHOD(PATH, HANDLER)
or 
app.METHOD(path, callback )

Où:

• app est une instance de express.
• METHOD est une méthode de requête HTTP .METHOD est la méthode HTTP de la requête, comme GET, PUT, POST, et ainsi de suite, en minuscules. Ainsi, les méthodes réelles sont app.get()app.post()app.put(), et ainsi de suite.
• PATH est un chemin d’accès sur le serveur.
• HANDLER est la fonction callback exécutée lorsque la route et la méthode correspondent. En fait, les méthodes de routage peuvent avoir plus d’une fonction de rappel comme arguments. Avec plusieurs fonctions de rappel, il est important de fournir next comme argument à la fonction de rappel, puis d’appeler next() dans le corps de la fonction pour transmettre le contrôle à la prochaine fonction de rappel.

app.get('/example/b', function (req, res, next) {
console.log('the response will be sent by the next function ...')
next()
}, function (req, res) {
res.send('Hello from B!')
})

Les exemples suivants illustrent la définition de routes simples.

Répondre avec Hello World! sur la page d’accueil :

app.get('/', function (req, res) {
res.send('Hello World!')
})

Répondre à une requête POST sur la route racine (/), la page d’accueil de l’application :

app.post('/', function (req, res) {
res.send('Got a POST request')
})

Répondre à une requête PUT sur la route /user :

app.put('/user', function (req, res) {
res.send('Got a PUT request at /user')
})

Répond à une demande DELETE à la route /user :

app.delete('/user', function (req, res) {
res.send('Got a DELETE request at /user')
})

Il existe une méthode de routage spéciale, app.all(), utilisée pour charger les fonctions d’intergiciel à un chemin pour toutes les méthodes de requête HTTP.

La fonction de rappel suivante est exécutée pour les demandes adressées à /secret, qu’elles utilisent GET, POST, PUT, DELETE ou toute autre méthode de demande HTTP :

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

Plus d’une fonction de rappel peut gérer une route (veillez à spécifier l’objet next). Par exemple :

app.get('/example/b', function (req, res, next) {
console.log('the response will be sent by the next function ...')
next()
}, function (req, res) {
res.send('Hello from B!')
})

Les chemins d’accès aux routes, en combinaison avec une méthode de requête, définissent les points d’extrémité auxquels les requêtes peuvent être effectuées. Les chemins d’accès peuvent être des chaînes de caractères, des motifs de chaînes de caractères ou des expressions régulières.

Les caractères ?+* et () sont des sous-ensembles de leurs équivalents en expression régulière. Le tiret (-) et le point (.) sont interprétés littéralement par les chemins basés sur des chaînes de caractères.

Si vous devez utiliser le caractère dollar ($) dans une chaîne de chemin, enfermez-le échappé dans (). Par exemple, la chaîne de chemin pour les demandes à « /data/$book« , serait « /data/()book« .

Voici quelques exemples de chemins d’accès basés sur des chaînes de caractères.

Ce chemin de route correspondra aux requêtes vers la route racine, /.

app.get('/', function (req, res) {
res.send('root')
})

Ce chemin de route correspondra aux requêtes vers /about.

app.get('/about', function (req, res) {
res.send('about')
})

Ce chemin d’accès correspondra aux requêtes adressées à /random.text.

app.get('/random.text', function (req, res) {
res.send('random.text')
})

Voici quelques exemples de chemins d’accès basés sur des modèles de chaînes de caractères.

Ce chemin d’accès correspondra à acd et abcd.

app.get('/ab?cd', function (req, res) {
res.send('ab?cd')
})

Ce chemin d’accès correspondra à abcdabbcdabbbcd, et ainsi de suite.

app.get('/ab+cd', function (req, res) {
res.send('ab+cd')
})

Ce chemin d’accès correspondra à abcdabxcdabRANDOMcdab123cd, et ainsi de suite.

app.get('/ab*cd', function (req, res) {
res.send('ab*cd')
})

Ce chemin d’accès correspondra à /abe et /abcde.

app.get('/ab(cd)?e', function (req, res) {
res.send('ab(cd)?e')
})

Exemples de chemins de route basés sur des expressions régulières :

Ce chemin de route correspondra à tout ce qui contient un « a ».

app.get(/a/, function (req, res) {
res.send('/a/')
})

Ce chemin d’itinéraire correspondra à butterfly et dragonfly, mais pas à butterflymandragonflyman, et ainsi de suite.

Manipulateurs de routage

Vous pouvez fournir plusieurs fonctions de rappel qui se comportent comme des intergiciels pour traiter une requête. La seule exception est que ces callbacks pourraient invoquer next('route') pour contourner les autres callbacks de route. Vous pouvez utiliser ce mécanisme pour imposer des conditions préalables à une route, puis passer le contrôle aux routes suivantes s’il n’y a aucune raison de poursuivre avec la route actuelle.

Les gestionnaires de route peuvent être

• sous la forme d’une fonction,
• un tableau de fonctions, ou
• des combinaisons des deux, comme le montrent les exemples suivants.

Une seule fonction de rappel peut gérer un itinéraire. Par exemple :

app.get('/example/a', function (req, res) {
res.send('Hello from A!')
})

Plus d’une fonction de rappel peut gérer un itinéraire (assurez-vous de spécifier l’objet next). Par exemple:

app.get('/example/b', function (req, res, next) {
console.log('the response will be sent by the next function ...')
next()
}, function (req, res) {
res.send('Hello from B!')
})

Un tableau de fonctions de rappel peut gérer un itinéraire. Par exemple:

var cb0 = function (req, res, next) {
console.log('CB0')
next()
}var cb1 = function (req, res, next) {
console.log('CB1')
next()
}var cb2 = function (req, res) {
res.send('Hello from C!')
}app.get('/example/c', )

Une combinaison de fonctions indépendantes et de tableaux de fonctions peut gérer un itinéraire. Par exemple:

var cb0 = function (req, res, next) {
console.log('CB0')
next()
}var cb1 = function (req, res, next) {
console.log('CB1')
next()
}app.get('/example/d', , function (req, res, next) {
console.log('the response will be sent by the next function ...')
next()
}, function (req, res) {
res.send('Hello from D!')
})

app.route()

Vous pouvez créer des gestionnaires d’itinéraire chaînables pour un chemin d’itinéraire en utilisant app.route(). Comme le chemin d’accès est spécifié à un seul endroit, la création de routes modulaires est utile, tout comme la réduction des redondances et des fautes de frappe. Pour plus d’informations sur les routes, voir : Documentation de Router().

Voici un exemple de gestionnaires de route chaînés qui sont définis en utilisant app.route().

app.route('/book')
.get(function (req, res) {
res.send('Get a random book')
})
.post(function (req, res) {
res.send('Add a book')
})
.put(function (req, res) {
res.send('Update the book')
})

.