Quand utiliser next() et return next() en Node.js ?

Question

Scénario : Considérez que ce qui suit est la partie du code d'une application web node.

app.get('/users/:id?', function(req, res, next){
    var id = req.params.id;
    if (id) {
        // do something
    } else {
        next(); //or return next();
    }
});

Numéro : Je suis en train de vérifier lequel choisir. next() o return next() . L'exemple de code ci-dessus fonctionne exactement de la même manière pour les deux et ne montre aucune différence dans l'exécution.

Question : Quelqu'un peut-il m'éclairer sur ce point, quand utiliser next() et quand utiliser return next() et une différence importante ?

Answer 1

Comme la réponse de @Laurent Perrin :

Si vous ne le faites pas, vous risquez de déclencher le callback une deuxième fois plus tard, ce qui a généralement des résultats dévastateurs

Je donne un exemple ici si vous écrivez un intergiciel comme celui-ci :

app.use((req, res, next) => {
  console.log('This is a middleware')
  next()
  console.log('This is first-half middleware')
})

app.use((req, res, next) => {
  console.log('This is second middleware')
  next()
})

app.use((req, res, next) => {
  console.log('This is third middleware')
  next()
})

Vous constaterez que la sortie dans la console est :

This is a middleware
This is second middleware
This is third middleware
This is first-half middleware

C'est-à-dire qu'il exécute le code sous next() une fois que toutes les fonctions de l'intergiciel sont terminées.

Cependant, si vous utilisez return next() il va sauter le callback immédiatement et le code ci-dessous return next() dans le callback sera inaccessible.

Answer 2

Certaines personnes écrivent toujours return next() est de s'assurer que l'exécution s'arrête après le déclenchement du callback.

Si vous ne le faites pas, vous risquez de déclencher le rappel une deuxième fois par la suite, ce qui a généralement des résultats dévastateurs. Votre code est très bien comme il est, mais je le réécrirais comme :

app.get('/users/:id?', function(req, res, next){
    var id = req.params.id;

    if(!id)
        return next();

    // do something
});

Cela me permet d'économiser un niveau d'indentation, et lorsque je relis le code plus tard, je suis sûr qu'il n'y a aucun moyen de next est appelé deux fois.

Answer 3

next() fait partie de connecter le middleware . Les callbacks pour le flux de routeur ne se soucient pas de savoir si vous retournez quelque chose de vos fonctions, donc return next() y next(); return; est fondamentalement la même.

Si vous voulez arrêter le flux des fonctions, vous pouvez utiliser next(err) comme les suivantes

app.get('/user/:id?', 
    function(req, res, next) { 
        console.log('function one');
        if ( !req.params.id ) 
            next('No ID'); // This will return error
        else   
            next(); // This will continue to function 2
    },
    function(req, res) { 
        console.log('function two'); 
    }
);

A peu près next() est utilisé pour étendre le middleware de vos demandes.

Answer 4

La différence entre next() et return next() est très simple comme un autre principe de programmation. Quelques lignes de code sont expliquées ci-dessous :

    app.use((req, res, next) => {
       console.log('Calling first middleware');
       next();
       console.log('Calling after the next() function');
    });

    app.use((req, res, next) => {
       console.log('Calling second middleware');
       return next(); // It returns the function block immediately and call next() function so the return next(); and next(); return; are the same
       console.log('After calling return next()');
    });

La sortie est

Appel du premier middleware
Appel après la fonction next()
Appeler le deuxième middleware

Answer 5

import express from "express"

const app = express()
// API for the testing of next() 
app.get(
  '/next', function (req,res,next) { 
    console.log('hi there ');
    next();
    console.log('you are still here');
  }
)

// API for the testing of return next() 
app.get(
  '/return-next', function (req,res,next) { 
    console.log('hi there');
    return next(); 
    console.log('you are still here');
  }
)

app.listen(5000,()=> {
  console.log("App is running on port 5000")
})

next() en /**next** la route appellera les middlewares et après l'exécution des middlewares, elle reviendra à l'endroit où elle a été appelée (comme un appel de fonction) et exécutera le reste des codes.

sortie :

hi there

you are still here

Sur /**return-next** route, il y a un retour devant next() qui renvoie le contrôleur

sortie :

hi there 

si vous considérez next() comme un appel de fonction, vous pourriez le comprendre correctement