Quel est le paramètre “next” utilisé 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 parameters, req et res , qui représentent respectivement les objects de requête et de réponse.

D’autre part, il existe d’autres fonctions avec un troisième paramètre appelé next . Par exemple, regardons le 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 peux pas comprendre quel est le but de next() ou pourquoi il est utilisé. Dans cet exemple, si id n’existe pas, que fait-on next ?

Il passe le contrôle au prochain itinéraire correspondant . Dans l’exemple que vous donnez, par exemple, vous pouvez rechercher l’utilisateur dans la firebase database si un id été fourni et l’assigner à 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 ; les /users peuvent alors faire quelque chose avec le résultat.

Middleware de routage (note: link est à la documentation 2.x, mais ceci est testé comme fonctionnant sur 3.x) est un outil plus souple et puissant, bien que, à mon avis, il ne repose pas sur un schéma URI particulier ou ordonnancement d’itinéraire. Je serais enclin à modéliser l’exemple montré comme ceci, en supposant un modèle Users avec un findOne() asynchrone:

 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 stream comme ça est très pratique. Vous voudrez peut-être que certaines pages ne soient disponibles que pour les utilisateurs avec un drapeau admin:

 /** * 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 aussi eu du mal à comprendre next (), 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, vous devez avoir une petite idée du cycle Requête-Réponse dans le nœud, mais pas dans le détail. Il commence par faire une requête HTTP pour une ressource particulière et se termine lorsque vous renvoyez une réponse à l’utilisateur, par exemple lorsque vous rencontrez quelque chose comme res.send (‘Hello World’);

Examinons 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 terminera le cycle et remettra le contrôle au middleware de routage.

Regardons 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 de middleware pour le même chemin. Mais tu vas toujours recevoir la réponse du premier. Parce que cela est monté en premier dans la stack du middleware et res.send mettra fin au cycle.

Mais que se passe-t-il si nous ne voulons pas toujours la réponse «Hello World !!!!». 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 !!!!"); }); 

Quelle est la next ici? Et oui, vous pourriez avoir des gusses. Il va sauter la première fonction du middleware si la condition est vraie et appeler la fonction middleware suivante et vous aurez le "Hello Planet !!!!" réponse.

Passez ensuite le contrôle à la fonction suivante de la stack de middleware.

Que se passe-t-il si la première fonction de middleware ne renvoie aucune réponse mais exécute un morceau de logique et que vous obtenez la réponse de la deuxième fonction du 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 avez besoin des deux fonctions de middleware à invoquer. Donc, la seule façon d’atteindre la deuxième fonction de middleware est d’appeler next ();

Et si vous ne téléphonez pas à la prochaine. Ne vous attendez pas à ce que la deuxième fonction de middleware soit appelée automatiquement. Après avoir appelé la première fonction, votre demande sera 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 fonction middleware suivante. Sinon, la demande sera laissée en suspens ou ouverte.

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