Question sur la fonction next () dans expressjs

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 l'API Node.js ou Express mais est le troisième argument qui est passé à la fonction middleware.

Avec Express (et d'autres systèmes similaires), chaque requête passe par une série de fonctions middleware (comme votre cb0 ). Chacun de ceux-ci a une chance de faire quelque chose avec la requête.

Comme la fonction d'une fonction middleware peut être asynchrone (par exemple, lire un fichier, interroger une base de données, etc.), Express ne peut pas simplement appeler directement le prochain bit de middleware après avoir appelé le précédent. Donc, à la place, il transmet à la fonction middleware une fonction, next , que ce middleware utilise pour dire «J'ai terminé, lancez l'étape suivante». (Dans la version Express, vous pouvez également passer un argument à next , comme Aikon Mogwai fait remarquer : Si vous lui transmettez une Erreur , cela déclenche le traitement des erreurs pour l'itinéraire. Si vous le transmettez "route" , il passe au routeur suivant, etc.).

Le concept de fonction next n'est donc pas spécifique à Express, mais le L'utilisation spécifique dans cet exemple est.

Voici un exemple très simplifié n'utilisant pas Express, mais démontrant le genre de chose qu'il fait avec les fonctions middleware lors du traitement d'une requête:

const app = {
  middleware: [],
  use(callback) {
    this.middleware.push(callback);
  }
};

app.use((req, res, next) => {
  console.log("First handler synchronous part");
  setTimeout(() => {
    console.log("First handler async part finished");
    next();
  }, 800);
});

app.use((req, res, next) => {
  console.log("Second handler is entirely synchronous");
  next();
});

app.use((req, res, next) => {
  console.log("Third handler synchronous part");
  setTimeout(() => {
    console.log("Third handler async part finished");
    next();
  }, 800);
});

// Code handling an incoming request
function handleRequest(req, app) {
  // Copy the handlers
  const middleware = app.middleware.slice();
  // Create a "response"
  const res = {};
  // Call the handlers
  let index = 0;
  next();
  function next() {
    if (index < middleware.length) {
      // Call the handler, have it call `next` when it's done
      middleware[index++](req, res, next);
    } else {
      console.log("Request completed");
    }
  }
}

handleRequest({}, app);

Il est probablement intéressant de mentionner que ce style manuel de gestion de middleware asynchrone a été remplacé par des promesses dans Koa.js , qui est un nouveau (er) framework des mêmes personnes qui ont fait Express.js. Avec Koa, vous effectuez vos fonctions de rappel async , et les internes de Koa attendent la promesse que la fonction async retourne pour se stabiliser puis agit sur le résultat de son paramétrage (par exemple, rejet ou exécution, la valeur avec laquelle il remplit, etc.).

La fonction next () demande la fonction middleware suivante dans l'application. La fonction next () ne fait pas partie de Node.js ou de l'API Express, mais c'est le troisième cas / argument qui passe à la fonction middleware. La fonction next () peut être nommée n'importe quoi, mais par convention, elle est toujours nommée "next". Pour éviter toute confusion, utilisez toujours cette convention.

Pour plus d'informations, vous pouvez consulter le didacticiel officiel de express < / p>

var express = require('express')
var app = express()

var CB0 = function (req, res, next) {
  console.log('CB0')
  next()
}

app.use(CB0)

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

app.listen(3000)
Each and Every time app receives a request and prints the message "CB0" console in terminal window.The middleware functions that are loaded first are also executed first.The middleware function CB0 simply prints a message, then passes on the request to the next middleware function in the stack by calling the next() function.