A quoi sert le paramètre "next" dans Express?
Supposons que vous ayez un simple bloc de code comme ceci:
app.get('/', function(req, res){
res.send('Hello World');
});
Cette fonction a deux paramètres, req et res, qui représentent respectivement les objets requête et 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 comprends pas quel est le but de next() ni pourquoi il est utilisé. Dans cet exemple, si id n'existe pas, que fait réellement next?
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 id a été donné 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
});
Etant donné que/users/123 correspondra en premier à la route dans votre exemple, il va d'abord vérifier et trouver l'utilisateur 123; alors /users peut faire quelque chose avec le résultat.
Middleware Route (note: le lien renvoie à la documentation 2.x, mais cela a été testé pour fonctionner sur 3.x) est un outil plus flexible et puissant, bien que, à mon avis, se fier à un schéma d’URI ou à un ordre de route particulier. Je serais enclin à modéliser l'exemple présenté comme ceci, en supposant un modèle Users avec un asynchrone 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 débit comme celui-ci est très pratique. Vous voudrez peut-être que certaines pages ne soient disponibles que pour les utilisateurs dotés 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 aussi eu du mal à comprendre next (), mais this m'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 de requête-réponse dans le nœud, même si elle n’est pas très détaillée. Elle commence par la création d’une requête HTTP pour une ressource particulière et se termine lorsque vous envoyez une réponse à l’utilisateur, par exemple lorsque vous rencontrez un problème tel que 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 rendra le contrôle au middleware de la 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 que cela est monté en premier dans la pile de middleware et res.send mettra fin au cycle.
Mais que se passe-t-il si nous ne voulons toujours pas 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 !!!!");
});
Que fait le next ici? Et oui vous pourriez avoir des guss. Si la condition est vraie, elle ignorera la première fonction de middleware et invoquera la fonction de middleware suivante pour obtenir la réponse "Hello Planet !!!!".
Donc, passez ensuite le contrôle à la fonction suivante dans la pile de middleware.
Que se passe-t-il si la première fonction middleware ne renvoie aucune réponse mais exécute un élément de logique et 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 avez besoin que les deux fonctions middleware soient appelées. Donc, la seule façon d’atteindre la deuxième fonction middleware est d’appeler next ();
Que faire si vous n'appelez pas à next. Ne vous attendez pas à ce que la seconde fonction middleware soit invoquée automatiquement. Après avoir appelé la première fonction, votre demande sera laissée en suspens. La seconde 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 middleware suivante dans l'application. La fonction next () ne fait pas partie de Node.js ou de l'API Express, mais constitue 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".