Traduire cette page

Utilisation du middleware

Express is a routing and middleware web framework with minimal functionality of its own: an Express application is essentially a series of middleware function calls executed during the request-response cycle.

Middleware functions are functions that have access to:

  • The request object (req)
  • The response object (res)
  • The next middleware function in the application’s request-response cycle, commonly named next

Les fonctions Middleware peuvent effectuer les tâches suivantes :

  • Exécuter n’importe quel code.
  • Modify the request and response objects.
  • Termine le cycle de réponse de la requête.
  • Pass control to the next middleware function.

If a middleware function does not end the request-response cycle, it must call next() to pass control to the next middleware function. Sinon, la demande sera laissée en suspens.

Une application Express peut utiliser les types de middleware suivants :

Vous pouvez charger le middleware au niveau de l’application et du routeur avec un chemin de montage optionnel. Multiple middleware functions can also be loaded together, which creates a middleware sub-stack at a mount point.

Outil d’interface de l’application

Bind application-level middleware to an instance of the app object by using the app.use() and app.METHOD() functions, where METHOD is the lowercase HTTP method of the request that the middleware function handles, such as get, post, put, or delete.

Middleware without a mount path

The following middleware function runs every time the app receives a request:

index.cjs
const express = require('express');
const app = express();


app.use((req, res, next) => {
  console.log('Time:', Date.now());
  next();
});

Middleware mounted on a path

The following middleware function runs for any type of HTTP request on the /user/:id path:

app.use('/user/:id', (req, res, next) => {
  console.log('Request Type:', req.method);
  next();
});

Gestionnaires de routes

Cet exemple montre une route et sa fonction de gestion (système middleware). La fonction gère les requêtes GET vers le chemin /user/:id.

app.get('/user/:id', (req, res) => {
  res.send('USER');
});

Middleware sub-stacks

Multiple middleware functions can be loaded together at a mount point to form a middleware sub-stack. This example prints request info for any type of HTTP request to the /user/:id path:

app.use(
  '/user/:id',
  (req, res, next) => {
    console.log('Request URL:', req.originalUrl);
    next();
  },
  (req, res, next) => {
    console.log('Request Type:', req.method);
    next();
  }
);

Multiple route handlers

Les gestionnaires de routes vous permettent de définir plusieurs routes pour un chemin. L’exemple ci-dessous définit deux routes pour les requêtes GET vers le chemin /user/:id. La deuxième route ne posera aucun problème, mais elle ne sera jamais appelée parce que le premier parcours termine le cycle de réponse de la requête.

app.get(
  '/user/:id',
  (req, res, next) => {
    console.log('ID:', req.params.id);
    next();
  },
  (req, res) => {
    res.send('User Info');
  }
);


// handler for the /user/:id path, which prints the user ID
app.get('/user/:id', (req, res) => {
  res.send(req.params.id);
});

Skipping to the next route

Call next('route') to skip the remaining middleware functions in a router middleware stack and pass control to the next route.

next('route') ne fonctionnera que dans les fonctions du middleware qui ont été chargées en utilisant les fonctions app.METHOD() ou router.METHOD().

In the following example, if the user ID is 0, the first handler skips to the next route, which sends a special response:

app.get(
  '/user/:id',
  (req, res, next) => {
    // if the user ID is 0, skip to the next route
    if (req.params.id === '0') next('route');
    // otherwise pass the control to the next middleware function in this stack
    else next();
  },
  (req, res) => {
    // send a regular response
    res.send('regular');
  }
);


// handler for the /user/:id path, which sends a special response
app.get('/user/:id', (req, res) => {
  res.send('special');
});

Reusable middleware arrays

Middleware functions can also be grouped into arrays for better reusability. Cet exemple montre un tableau avec une sous-pile middleware qui gère les requêtes GET vers le chemin /user/:id

function logOriginalUrl(req, res, next) {
  console.log('Request URL:', req.originalUrl);
  next();
}


function logMethod(req, res, next) {
  console.log('Request Type:', req.method);
  next();
}


const logStuff = [logOriginalUrl, logMethod];
app.get('/user/:id', logStuff, (req, res) => {
  res.send('User Info');
});

middleware au niveau du routeur

Router-level middleware works the same way as application-level middleware, except it is bound to an instance of express.Router().

const router = express.Router();

Charger le middleware au niveau du routeur en utilisant les fonctions router.use() et router.METHOD().

L’exemple suivant réplique le système middleware qui est affiché ci-dessus pour le middleware au niveau de l’application, en utilisant le middleware au niveau du routeur:

index.cjs
const express = require('express');
const app = express();
const router = express.Router();


// a middleware function with no mount path. This code is executed for every request to the router
router.use((req, res, next) => {
  console.log('Time:', Date.now());
  next();
});


// a middleware sub-stack shows request info for any type of HTTP request to the /user/:id path
router.use(
  '/user/:id',
  (req, res, next) => {
    console.log('Request URL:', req.originalUrl);
    next();
  },
  (req, res, next) => {
    console.log('Request Type:', req.method);
    next();
  }
);


// a middleware sub-stack that handles GET requests to the /user/:id path
router.get(
  '/user/:id',
  (req, res, next) => {
    // if the user ID is 0, skip to the next route
    if (req.params.id === '0') next('route');
    // otherwise pass control to the next middleware function in this stack
    else next();
  },
  (req, res) => {
    // render a regular page
    res.render('regular');
  }
);


// handler for the /user/:id path, which renders a special page
router.get('/user/:id', (req, res) => {
  console.log(req.params.id);
  res.render('special');
});


// mount the router on the app
app.use('/', router);

Skipping out of a router

Use next('router') to skip the rest of the router’s middleware functions and pass control back out of the router instance.

In the following example, the router only responds when the request includes an x-auth header. Otherwise, next('router') exits the router and the app responds with a 401 status:

index.cjs
const express = require('express');
const app = express();
const router = express.Router();


// predicate the router with a check and bail out when needed
router.use((req, res, next) => {
  if (!req.headers['x-auth']) return next('router');
  next();
});


router.get('/user/:id', (req, res) => {
  res.send('hello, user!');
});


// use the router and 401 anything falling through
app.use('/admin', router, (req, res) => {
  res.sendStatus(401);
});

Gestion des erreurs du middleware

Définissez les fonctions du middleware de la même manière que les autres fonctions du middleware, sauf avec quatre arguments au lieu de trois, spécifiquement avec la signature (err, req, res, next):

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

La gestion d’erreurs du middleware prend toujours four arguments. Vous devez fournir quatre arguments à l’identifier comme une fonction de gestion des erreurs du middleware. Même si vous n’avez pas besoin d’utiliser l’objet next , vous devez le spécifier pour maintenir la signature. Sinon, l’objet next sera interprété comme un middleware normal et ne gérera pas les erreurs.

middleware intégré

Express a les fonctions internes suivantes :

middleware de tierce partie

Utilisez des logiciels tiers pour ajouter des fonctionnalités aux applications Express.

Installez le module Node.js pour la fonctionnalité requise, puis chargez-le dans votre application au niveau de l’application ou au niveau du routeur.

L’exemple suivant illustre l’installation et le chargement de la fonction middleware d’analyse de cookies cookie-parser.

Terminal window
npm install cookie-parser
index.cjs
const express = require('express');
const app = express();
const cookieParser = require('cookie-parser');


// load the cookie-parsing middleware
app.use(cookieParser());