A cosa serve il parametro "next" utilizzato in Express?

Supponiamo di avere un semplice blocco di codice come questo:

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

Questa funzione ha due parametri reqe res, che rappresentano rispettivamente gli oggetti richiesta e risposta.

D'altra parte, ci sono altre funzioni con un terzo parametro chiamato next. Ad esempio, diamo un'occhiata al seguente codice:

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

Non riesco a capire quale next()sia lo scopo o perché venga utilizzato. In questo esempio, se ID non esiste, cosa sta nextrealmente facendo?

Passa il controllo al prossimo percorso corrispondente . Nell'esempio fornito, ad esempio, è possibile cercare l'utente nel database se è idstato fornito e assegnarlo a req.user.

Di seguito, potresti avere un percorso come:

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

Poiché / users / 123 corrisponderà prima al percorso nel tuo esempio, ciò controllerà e troverà prima l'utente 123; quindi /userspuò fare qualcosa con il risultato di quello.

Il middleware di route è uno strumento più flessibile e potente, sebbene, a mio avviso, poiché non si basa su un particolare schema URI o su un ordinamento di route. Sarei propenso a modellare l'esempio mostrato in questo modo, assumendo un Usersmodello con un asincrono 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);
});

Essere in grado di controllare il flusso in questo modo è abbastanza utile. È possibile che alcune pagine siano disponibili solo per gli utenti con un flag di amministrazione:

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

Spero che questo ti abbia dato l'ispirazione!

Ho anche avuto problemi a capire il prossimo (), ma questo mi ha aiutato

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

Prima di capire next, devi avere una piccola idea del ciclo Richiesta-Risposta nel nodo, anche se non molto nei dettagli. Inizia con una richiesta HTTP per una particolare risorsa e termina quando rispedisci una risposta all'utente, ad esempio quando incontri qualcosa come res.send ('Hello World');

diamo un'occhiata a un esempio molto semplice.

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

Qui non è necessario next (), poiché resp.send termina il ciclo e restituisce il controllo al middleware di route.

Ora diamo un'occhiata a un altro esempio.

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

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

Qui abbiamo 2 funzioni middleware per lo stesso percorso. Ma otterrai sempre la risposta dal primo. Perché quello viene montato per primo nello stack del middleware e res.send terminerà il ciclo.

E se non volessimo sempre il "Hello World !!!!" risposta indietro. Per alcune condizioni potremmo volere il "Hello Planet !!!!" risposta. Modifichiamo il codice sopra e vediamo cosa succede.

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

Cosa ci nextfa qui. E sì, potresti avere dei problemi. Salterà la prima funzione middleware se la condizione è vera e invocherà la successiva funzione middleware e avrai la "Hello Planet !!!!"risposta.

Quindi, passa successivamente il controllo alla funzione successiva nello stack del middleware.

Che cosa succede se la prima funzione middleware non restituisce alcuna risposta ma esegue una parte logica e quindi si ottiene la risposta dalla seconda funzione middleware.

Qualcosa come sotto: -

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

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

In questo caso sono necessarie entrambe le funzioni del middleware per essere invocate. Quindi, l'unico modo per raggiungere la seconda funzione middleware è chiamare next ();

Che cosa succede se non si effettua una chiamata al prossimo. Non aspettatevi che la seconda funzione del middleware venga invocata automaticamente. Dopo aver richiamato la prima funzione, la tua richiesta verrà lasciata in sospeso. La seconda funzione non verrà mai invocata e non verrà restituita la risposta.

Next viene utilizzato per passare il controllo alla successiva funzione middleware. In caso contrario, la richiesta verrà lasciata sospesa o aperta.

La chiamata a questa funzione richiama la funzione middleware successiva nell'app. La funzione next () non fa parte di Node.js o Express API, ma è il terzo argomento che viene passato alla funzione middleware. La funzione next () può essere nominata in qualsiasi modo, ma per convenzione viene sempre chiamata "next".

L'esecuzione della nextfunzione notifica al server che è stato completato con questo passaggio del middleware e può eseguire il passaggio successivo nella catena.