Qual é o parâmetro "next" usado no Express?

Suponha que você tenha um bloco de código simples como este:

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

Essa função possui dois parâmetros, reqe res, que representam os objetos de solicitação e resposta, respectivamente.

Por outro lado, existem outras funções com um terceiro parâmetro chamado next. Por exemplo, vamos dar uma olhada no seguinte código:

app.get('/users/:id?', function(req, res, next){ // Why do we need next?
    var id = req.params.id;
    if (id) {
        // do something
    } else {
        next(); // What is this doing?
    }
});

Não consigo entender qual é o objetivo next()ou por que está sendo usado. Nesse exemplo, se o ID não existir, o que nextrealmente está fazendo?

Passa o controle para a próxima rota correspondente . No exemplo que você fornece, por exemplo, você pode procurar o usuário no banco de dados se um idfoi fornecido e atribuí-lo a req.user.

Abaixo, você pode ter uma rota como:

app.get('/users', function(req, res) {
  // check for and maybe do something with req.user
});

Como / users / 123 corresponderá primeiro à rota no seu exemplo, que primeiro verificará e encontrará o usuário 123; então /userspode fazer algo com o resultado disso.

O middleware de rota é uma ferramenta mais flexível e poderosa, no entanto, na minha opinião, uma vez que não depende de um esquema URI ou de um pedido de rota específico. Eu estaria inclinado a modelar o exemplo mostrado assim, assumindo um Usersmodelo com uma assíncrona findOne():

function loadUser(req, res, next) {
  if (req.params.userId) {
    Users.findOne({ id: req.params.userId }, function(err, user) {
      if (err) {
        next(new Error("Couldn't find user: " + err));
        return;
      }

      req.user = user;
      next();
    });
  } else {
    next();
  }
}

// ...

app.get('/user/:userId', loadUser, function(req, res) {
  // do something with req.user
});

app.get('/users/:userId?', loadUser, function(req, res) {
  // if req.user was set, it's because userId was specified (and we found the user).
});

// Pretend there's a "loadItem()" which operates similarly, but with itemId.
app.get('/item/:itemId/addTo/:userId', loadItem, loadUser, function(req, res) {
  req.user.items.append(req.item.name);
});

Ser capaz de controlar o fluxo dessa maneira é bastante útil. Você pode querer que determinadas páginas estejam disponíveis apenas para usuários com um sinalizador de administrador:

/**
 * Only allows the page to be accessed if the user is an admin.
 * Requires use of `loadUser` middleware.
 */
function requireAdmin(req, res, next) {
  if (!req.user || !req.user.admin) {
    next(new Error("Permission denied."));
    return;
  }

  next();
}

app.get('/top/secret', loadUser, requireAdmin, function(req, res) {
  res.send('blahblahblah');
});

Espero que isso tenha lhe dado alguma inspiração!

Eu também tive problemas para entender next (), mas isso ajudou

var app = require("express")();

app.get("/", function(httpRequest, httpResponse, next){
    httpResponse.write("Hello");
    next(); //remove this and see what happens 
});

app.get("/", function(httpRequest, httpResponse, next){
    httpResponse.write(" World !!!");
    httpResponse.end();
});

app.listen(8080);

Antes de entender next, você precisa ter uma pequena idéia do ciclo de solicitação-resposta no nó, embora não muito detalhadamente. Começa com você solicitando HTTP para um recurso específico e termina quando você envia uma resposta de volta ao usuário, ou seja, quando você encontra algo como res.send ('Hello World');

vamos dar uma olhada em um exemplo muito simples.

app.get('/hello', function (req, res, next) {
  res.send('USER')
})

Aqui não precisamos de next (), porque resp.send encerrará o ciclo e entregará o controle de volta ao middleware da rota.

Agora vamos dar uma olhada em outro exemplo.

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

app.get('/hello', function (req, res, next) {
  res.send("Hello Planet !!!!");
});

Aqui temos duas funções de middleware para o mesmo caminho. Mas você sempre obterá a resposta do primeiro. Porque isso é montado primeiro na pilha de middleware e o res.send encerrará o ciclo.

Mas e se nem sempre queremos o "Olá Mundo !!!!" resposta de volta. Para algumas condições, podemos querer o "Olá Planeta !!!!" resposta. Vamos modificar o código acima e ver o que acontece.

app.get('/hello', function (req, res, next) {
  if(some condition){
    next();
    return;
  }
  res.send("Hello World !!!!");  
});

app.get('/hello', function (req, res, next) {
  res.send("Hello Planet !!!!");
});

O que está nextfazendo aqui. E sim, você pode ter gusses. Irá pular a primeira função do middleware se a condição for verdadeira e chamar a próxima função do middleware e você terá a "Hello Planet !!!!"resposta.

Portanto, passe o controle para a próxima função na pilha de middleware.

E se a primeira função de middleware não enviar nenhuma resposta, mas executar uma parte da lógica e você receber a resposta da segunda função de middleware.

Algo como abaixo: -

app.get('/hello', function (req, res, next) {
  // Your piece of logic
  next();
});

app.get('/hello', function (req, res, next) {
  res.send("Hello !!!!");
});

Nesse caso, você precisa que ambas as funções do middleware sejam invocadas. Portanto, a única maneira de alcançar a segunda função do middleware é chamando next ();

E se você não ligar para o próximo. Não espere que a segunda função de middleware seja chamada automaticamente. Depois de invocar a primeira função, sua solicitação será deixada em suspenso. A segunda função nunca será chamada e você não receberá a resposta novamente.

Next é usado para passar o controle para a próxima função de middleware. Caso contrário, a solicitação será deixada suspensa ou aberta.

A chamada dessa função chama a próxima função de middleware no aplicativo. A função next () não faz parte da API Node.js ou Express, mas é o terceiro argumento que é passado para a função middleware. A função next () pode ter o nome de qualquer coisa, mas por convenção é sempre chamada de "next".

A execução da nextfunção notifica o servidor que você concluiu esta etapa do middleware e ela pode executar a próxima etapa da cadeia.