Usando o middleware

Express é uma web framework de roteamento e middleware que tem a funcionalidade mínima de sua própria funcionalidade: Um aplicativo Express é essencialmente uma série de chamadas de função middleware.

Middleware_ são funções que têm acesso ao objeto de requisição (req), a objeto de resposta (res) e a próxima função de middleware no ciclo de resposta de solicitação do aplicativo. A próxima função de middleware é comumente denotada por uma variável chamada next.

As funções do Middleware podem executar as seguintes tarefas:

• Execute qualquer código.
• Fazer alterações na solicitação e nos objetos de resposta.
• Encerrar o ciclo de solicitação-resposta.
• Chame a próxima função middleware na pilha.

Se a função middleware atual não encerra o ciclo de resposta de solicitação, ela deve chamar next() para passar o controle para a próxima função middleware. Caso contrário, o pedido ficará pendurado.

Um aplicativo Express pode usar os seguintes tipos de middleware:

• Meio do aplicativo
• Meio do roteador
• Middleware com erro
• middleware
• Middleware de terceiros

Você pode carregar o nível de aplicação e middleware de nível de roteador com um caminho de montagem opcional. Você também pode carregar uma série de funções intermediárias juntas, o que cria uma sub-pilha do sistema intermediário em um ponto de montagem.

Midddleware no nível de aplicação

Vincular aplicativo de nível middleware a uma instância do objeto de aplicativo usando o app.use() e app. Funções ETHOD(), onde METHOD é o método HTTP da solicitação que a função middleware lida (como GET, PUT, ou POST) em minúsculas.

Este exemplo mostra uma função middleware sem caminho de montagem. A função é executada toda vez que o aplicativo recebe uma solicitação.

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

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

Este exemplo mostra uma função middleware montada no caminho /user/:id. A função é executada para qualquer tipo de solicitação HTTP no caminho /user/:id.

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

Este exemplo mostra uma rota e sua função de manipulador (sistema de middleware). A função lida com requisições GET para o caminho /user/:id.

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

Aqui está um exemplo de carregar uma série de funções intermediárias em um ponto de montagem, com um caminho de montagem. Isto ilustra um sub-stack de middleware que imprime informação de solicitação para qualquer tipo de solicitação de HTTP no caminho /user/:id.

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

Os gerenciadores de rotas permitem que você defina várias rotas para um caminho. O exemplo abaixo define duas rotas para solicitações GET para o caminho /user/:id. A segunda via não causará quaisquer problemas, mas nunca será chamada, porque a primeira via termina o ciclo de resposta aos pedidos.

Este exemplo mostra uma sub-pilha de middleware que lida com requisições GET para o caminho /user/:id.

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

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

Para ignorar o resto das funções de middleware a partir de uma pilha de middleware do roteador, chame next('route') para passar o controle para a próxima rota.

Este exemplo mostra uma sub-pilha de middleware que lida com requisições GET para o caminho /user/:id.

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, next) => {
    // send a regular response
    res.send('regular');
  }
);

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

O Middleware também pode ser declarado em um array para reutilizabilidade.

Este exemplo mostra um array com um sub-stack de middleware que lida com requisições GET para o caminho /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, next) => {
  res.send('User Info');
});

Midddleware nível de roteamento

O middleware de roteador funciona da mesma maneira que o middleware no nível de aplicativo, exceto que está vinculado a uma instância de express.Router().

const router = express.Router();

Carregue o middleware no nível de roteador usando as funções router.use() e router.METHOD().

O código a seguir replica o sistema middleware que é mostrado acima para o middleware no nível de aplicativos, usando o middleware no nível de roteador:

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 router
    if (req.params.id === '0') next('route');
    // otherwise pass control to the next middleware function in this stack
    else next();
  },
  (req, res, next) => {
    // render a regular page
    res.render('regular');
  }
);

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

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

Para ignorar o resto das funções de middleware do roteador, chame next('router') para passar o controle de volta para fora da instância do roteador.

Este exemplo mostra uma sub-pilha de middleware que lida com requisições GET para o caminho /user/:id.

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

Midddleware com erro manipulado

Definir funções intermediárias de manipulação de erros da mesma forma que outras funções de middleware, exceto quatro argumentos em vez de três, especificamente com a assinatura (err, req, res, next):

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

Para detalhes sobre o middleware, consulte: Error handling.

Midddleware integrado

A partir da versão 4.x, o Express não depende mais do Connect. O middleware funções que foram previamente incluídas com Express estão agora em módulos separados; consulte a lista de funções de middleware.

O Express tem as seguintes funções de middleware incorporadas:

• express.static serve como arquivos estáticos, como arquivos HTML, imagens e assim por diante.
• express.json analisa solicitações recebidas com carga JSON. NOTA: Disponível com Expresso 4.16.0+
• express.urlencoded analisa solicitações recebidas com payloads codificados por URL. NOTA: Disponível com Expresso 4.16.0+

Midddleware de terceiros

Usar middleware de terceiros para adicionar funcionalidades a aplicativos Express.

Instale o módulo Node.js para a funcionalidade requerida e, em seguida, carregue-o em seu aplicativo ao nível do aplicativo ou no nível do roteador.

O exemplo a seguir ilustra a instalação e o carregamento da função middleware de análise de cookie-parser`.

$ npm install cookie-parser

const express = require('express');
const app = express();
const cookieParser = require('cookie-parser');

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

Para uma lista parcial de funções intermediárias de terceiros que são comumente usadas com Express, veja: middleware de terceiros.