Roteamento

O Roteamento refere-se a como os endpoints de uma aplicação (URIs) respondem às requisições do cliente. Para uma introdução ao roteamento, consulte Roteamento básico.

Rotas são definidas utilizando métodos do objeto app do Express que correspondem aos métodos HTTP; por exemplo, app.get() para lidar com requisições GET e app.post() para requisições POST. Para a lista completa, veja app.METHOD. Você também pode utilizar app.all() para lidar com todos os métodos HTTP e app.use() para especificar middleware como funções callback (Veja Usando middlewares para mais detalhes).

Esses métodos de roteamento especificam uma função callback a ser chamada quando a aplicação recebe uma requisição à rota e método HTTP especificados. Em outras palavras, a aplicação “escuta” requisições que se encaixam nas rotas e métodos especificados e, quando há alguma correspondência, chama a função callback especificada.

Na realidade, métodos de roteamento podem possuir mais de uma função callback como argumento. Com múltiplas funções, é importante passar next como argumento da função e chamar next() para passar o controle para a próxima.

O código a seguir é um exemplo de uma rota muito básica.

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étodos de roteamento

Um método de roteamento é derivado a partir de um dos métodos HTTP, e é anexado a uma instância da classe express.

o código a seguir é um exemplo de rotas para a raiz do aplicativo que estão definidas para os métodos GET e POST.

// 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')
})

O Express suporta métodos que correspondem a todos os métodos de requisição HTTP: get, post, etc. Pra uma lista completa, veja app.METHOD.

Existe um método de roteamento especial, app.all(), que não é derivado de nenhum método HTTP. Este método é usado para carregar funções de middleware em um caminho para todos os métodos de solicitação. For example, the following handler is executed for requests to the route "/secret" whether using GET, POST, PUT, DELETE, or any other HTTP request method supported in the http module.

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

Caminhos de rota

Caminhos de rota, em combinação com os métodos de solicitação, definem os terminais em que as solicitações podem ser feitas. Caminhos de rota podem ser sequências de caracteres, padrões de sequência, ou expressões regulares.

Aqui estão alguns exemplos de caminhos de rota baseados em sequências de caracteres

Este caminho de rota irá corresponder a solicitações ao /qualquer.texto.

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

Este caminho de rota irá corresponder a solicitações ao /ajuda.

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

Este caminho de rota corresponde a solicitações à rota raiz, /.

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

Aqui estão alguns exemplos de caminhos de rota baseados em padrões de sequência

Este caminho de rota irá corresponder ao /abe e /abcde.

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

Este caminho de rota irá corresponder ao abcd, abbcd, abbbcd, e assim por diante.

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

Este caminho de rota irá corresponder ao abcd, abxcd, abRANDOMcd, ab123cd, e assim por diante.

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

Este caminho de rota irá corresponder ao acd e abcd.

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

Exemplos de caminhos de rota baseados em expressões regulares:

Este caminho de rota irá corresponder a qualquer coisa com um “a” no nome.

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

Este caminho de rota irá corresponder a butterfly e dragonfly, mas não a butterflyman, dragonfly man, e assim por diante.

app.get(/.*fly$/, (req, res) => {
  res.send('/.*fly$/')
})

Sequências de consulta não fazem parte dos caminhos de rota.

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

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

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

Manipuladores de rota

É possível fornecer várias funções callback que se comportam como middleware para manipular uma solicitação. A única exceção é que estes callbacks podem chamar next('route') para efetuar um bypass nos callbacks restantes. É possível usar este mecanismo para impor pré-condições em uma rota, e em seguida passar o controle para rotas subsequentes se não houveram razões para continuar com a rota atual.

Manipuladores de rota podem estar na forma de uma função, uma matriz de funções, ou combinações de ambas, como mostrado nos seguintes exemplos.

Uma única função callback pode manipular uma rota. Por exemplo:

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

Mais de uma função callback pode manipular uma rota (certifique-se de especificar o objeto next). Por exemplo:

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!')
})

Uma matriz de funções callback podem manipular uma rota. Por exemplo:

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])

Uma combinação de funções independentes e matrizes de funções podem manipular uma rota. Por exemplo:

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étodos de resposta

Os métodos do objeto de resposta (res) na seguinte tabela podem enviar uma resposta ao cliente, e finalizar o ciclo solicitação-resposta. Se nenhum destes métodos forem chamados a partir de um manipulador de rota, a solicitação do cliente será deixada em suspenso.

app.route()

É possível criar manipuladores de rota encadeáveis para um caminho de rota usando o app.route(). Como o caminho é especificado em uma localização única, criar rotas modulares é útil, já que reduz redundâncias e erros tipográficos. Para obter mais informações sobre rotas, consulte: documentação do Router().

Aqui está um exemplo de manipuladores de rotas encadeáveis que são definidos usando 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

Use a classe express.Router para criar manipuladores de rota modulares e montáveis. Uma instância de Router é um middleware e sistema de roteamento completo; por essa razão, ela é frequentemente referida como um “mini-aplicativo”

O seguinte exemplo cria um roteador como um módulo, carrega uma função de middleware nele, define algumas rotas, e monta o módulo router em um caminho no aplicativo principal.

Crie um arquivo de roteador com um arquivo chamado passaros.js no diretório do aplicativo, com o seguinte conteúdo:

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

Em seguida, carregue o módulo roteador no aplicativo:

const birds = require('./birds')

// ...

app.use('/birds', birds)

O aplicativo será agora capaz de manipular solicitações aos caminhos /passaros e /passaros/ajuda, assim como chamar a função de middleware timeLog que é específica para a rota.

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