À quoi sert le paramètre «suivant» dans Express?

Supposons que vous ayez un simple bloc de code comme celui-ci:

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

Cette fonction a deux paramètres, reqet res, qui représentent respectivement les objets de demande et de réponse.

D'autre part, il existe d'autres fonctions avec un troisième paramètre appelé next. Par exemple, jetons un œil au code suivant:

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

Je ne comprends pas à quoi ça next()sert ni pourquoi il est utilisé. Dans cet exemple, si id n'existe pas, que fait-il nextréellement?

Il passe le contrôle à la prochaine route correspondante . Dans l'exemple que vous donnez, par exemple, vous pouvez rechercher l'utilisateur dans la base de données si un a idété donné et l'affecter àreq.user .

Ci-dessous, vous pourriez avoir un itinéraire comme:

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

Puisque / users / 123 correspondra d'abord à l'itinéraire dans votre exemple, cela vérifiera et trouvera d'abord l'utilisateur 123; /userspeut alors faire quelque chose avec le résultat de cela.

Le middleware de route est un outil plus flexible et plus puissant, à mon avis, car il ne dépend pas d'un schéma d'URI ou d'un ordre de routage particulier. Je serais enclin à modéliser l'exemple montré comme ceci, en supposant un Usersmodèle avec une async 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);
});

Être capable de contrôler le flux comme celui-ci est assez pratique. Vous souhaiterez peut-être que certaines pages ne soient accessibles qu'aux utilisateurs disposant d'un indicateur d'administrateur:

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

J'espère que cela vous a donné de l'inspiration!

J'ai également eu du mal à comprendre ensuite (), mais cela a aidé

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

Avant de comprendre next, vous devez avoir une petite idée du cycle demande-réponse dans le nœud, mais pas beaucoup en détail. Cela commence lorsque vous faites une requête HTTP pour une ressource particulière et se termine lorsque vous renvoyez une réponse à l'utilisateur, c'est-à-dire lorsque vous rencontrez quelque chose comme res.send ('Hello World');

regardons un exemple très simple.

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

Ici, nous n'avons pas besoin de next (), car resp.send mettra fin au cycle et remettra le contrôle au middleware de route.

Voyons maintenant un autre exemple.

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

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

Ici, nous avons 2 fonctions middleware pour le même chemin. Mais vous obtiendrez toujours la réponse du premier. Parce qu'il est monté en premier dans la pile du middleware et que res.send mettra fin au cycle.

Mais que se passe-t-il si nous ne voulons pas toujours le "Hello World !!!!" réponse en retour. Pour certaines conditions, nous pouvons vouloir le "Hello Planet !!!!" réponse. Modifions le code ci-dessus et voyons ce qui se passe.

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

Que nextfait-on ici. Et oui, vous pourriez avoir des bus. Cela va sauter la première fonction middleware si la condition est vraie et appeler la prochaine fonction middleware et vous aurez la "Hello Planet !!!!"réponse.

Donc, passez ensuite le contrôle à la fonction suivante dans la pile du middleware.

Que se passe-t-il si la première fonction middleware ne renvoie aucune réponse mais exécute un morceau de logique et que vous obtenez ensuite la réponse de la deuxième fonction middleware.

Quelque chose comme ci-dessous: -

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

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

Dans ce cas, vous devez appeler les deux fonctions middleware. Ainsi, la seule façon d'atteindre la deuxième fonction middleware est d'appeler next ();

Et si vous n'appelez pas au suivant. Ne vous attendez pas à ce que la deuxième fonction middleware soit invoquée automatiquement. Après avoir invoqué la première fonction, votre demande restera suspendue. La deuxième fonction ne sera jamais invoquée et vous ne récupérerez pas la réponse.

Next est utilisé pour passer le contrôle à la prochaine fonction middleware. Sinon, la demande sera suspendue ou ouverte.

L'appel de cette fonction appelle la prochaine fonction middleware de l'application. La fonction next () ne fait pas partie de Node.js ou de l'API Express, mais est le troisième argument transmis à la fonction middleware. La fonction next () peut être nommée n'importe quoi, mais par convention, elle est toujours nommée «next».

L'exécution de la nextfonction informe le serveur que vous avez terminé cette étape de middleware et peut exécuter l'étape suivante de la chaîne.