Wofür wird der Parameter "next" in Express verwendet?

Angenommen, Sie haben einen einfachen Codeblock wie diesen:

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

Diese Funktion hat zwei Parameter reqund res, die die Anforderungs- bzw. Antwortobjekte darstellen.

Andererseits gibt es andere Funktionen, bei denen ein dritter Parameter aufgerufen wird next. Schauen wir uns zum Beispiel den folgenden Code an:

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

Ich kann nicht verstehen, worum es next()geht oder warum es verwendet wird. Wenn in diesem Beispiel keine ID vorhanden ist, was wird dann nexttatsächlich ausgeführt?

Es übergibt die Kontrolle an die nächste passende Route. In dem Beispiel, das Sie beispielsweise idangeben, können Sie den Benutzer in der Datenbank nachschlagen, wenn ein angegeben wurde, und ihn zuweisen req.user.

Unten könnten Sie eine Route haben wie:

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

Da / users / 123 zuerst mit der Route in Ihrem Beispiel übereinstimmt, wird zuerst der Benutzer überprüft und gefunden 123. dann /userskann man etwas daraus machen.

Die Route Middleware ist meiner Meinung nach ein flexibleres und leistungsfähigeres Tool, da sie nicht auf einem bestimmten URI-Schema oder einer bestimmten Routenreihenfolge basiert. Ich würde das gezeigte Beispiel gerne Usersmodellieren , wenn ich ein asynchrones Modell annehme 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);
});

In der Lage zu sein, den Fluss so zu steuern, ist ziemlich praktisch. Möglicherweise möchten Sie, dass bestimmte Seiten nur Benutzern mit einem Admin-Flag zur Verfügung stehen:

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

Hoffe das hat dich inspiriert!

Ich hatte auch Probleme beim Verstehen von next (), aber das half

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

Bevor Sie verstehen next, müssen Sie eine kleine Vorstellung vom Anforderungs-Antwort-Zyklus im Knoten haben, wenn auch nicht sehr detailliert. Es beginnt damit, dass Sie eine HTTP-Anfrage für eine bestimmte Ressource stellen, und endet, wenn Sie eine Antwort an den Benutzer zurücksenden, dh wenn Sie auf etwas wie res.send ('Hello World') stoßen.

Schauen wir uns ein sehr einfaches Beispiel an.

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

Hier brauchen wir next () nicht, da resp.send den Zyklus beendet und die Steuerung an die Route Middleware zurückgibt.

Schauen wir uns nun ein anderes Beispiel an.

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

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

Hier haben wir 2 Middleware-Funktionen für den gleichen Pfad. Aber Sie werden immer die Antwort vom ersten bekommen. Da dies zuerst im Middleware-Stack bereitgestellt wird und res.send den Zyklus beendet.

Aber was ist, wenn wir immer nicht die "Hallo Welt !!!!" wollen? Antwort zurück. Für einige Bedingungen möchten wir vielleicht den "Hallo Planeten !!!!" Antwort. Lassen Sie uns den obigen Code ändern und sehen, was passiert.

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

Was ist nexthier los ? Und ja, Sie könnten Gusses haben. Wenn die Bedingung erfüllt ist, wird die erste Middleware-Funktion übersprungen und die nächste Middleware-Funktion aufgerufen, und Sie erhalten die "Hello Planet !!!!"Antwort.

Übergeben Sie das Steuerelement als Nächstes an die nächste Funktion im Middleware-Stack.

Was ist, wenn die erste Middleware-Funktion keine Antwort zurücksendet, sondern eine Logik ausführt und Sie die Antwort von der zweiten Middleware-Funktion zurückerhalten.

So etwas wie unten: -

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

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

In diesem Fall müssen beide Middleware-Funktionen aufgerufen werden. Der einzige Weg, um zur zweiten Middleware-Funktion zu gelangen, ist der Aufruf von next ().

Was ist, wenn Sie nicht den nächsten Anruf tätigen? Erwarten Sie nicht, dass die zweite Middleware-Funktion automatisch aufgerufen wird. Nach dem Aufrufen der ersten Funktion bleibt Ihre Anfrage hängen. Die zweite Funktion wird niemals aufgerufen und Sie erhalten keine Antwort zurück.

Mit Next wird die Steuerung an die nächste Middleware-Funktion übergeben. Wenn nicht, bleibt die Anfrage hängen oder offen.

Durch Aufrufen dieser Funktion wird die nächste Middleware-Funktion in der App aufgerufen. Die next () -Funktion ist kein Teil der Node.js- oder Express-API, sondern das dritte Argument, das an die Middleware-Funktion übergeben wird. Die next () -Funktion kann beliebig benannt werden, wird jedoch konventionell immer als "next" bezeichnet.

Durch Ausführen der nextFunktion wird der Server benachrichtigt, dass Sie mit diesem Middleware-Schritt fertig sind, und er kann den nächsten Schritt in der Kette ausführen.