Apa parameter "selanjutnya" yang digunakan untuk di Express?

Misalkan Anda memiliki blok kode sederhana seperti ini:

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

Fungsi ini memiliki dua parameter, reqdan res, yang masing-masing mewakili objek permintaan dan respons.

Di sisi lain, ada fungsi lain dengan parameter ketiga yang disebut next. Sebagai contoh, mari kita lihat kode berikut:

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

Saya tidak mengerti apa gunanya next()atau mengapa ini digunakan. Dalam contoh itu, jika id tidak ada, apa yang nextsebenarnya dilakukan?

Ini melewati kontrol ke rute yang cocok berikutnya . Dalam contoh yang Anda berikan, misalnya, Anda mungkin mencari pengguna di database jika iddiberikan, dan menugaskannya req.user.

Di bawah, Anda dapat memiliki rute seperti:

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

Karena / users / 123 akan cocok dengan rute dalam contoh Anda terlebih dahulu, yang pertama akan memeriksa dan menemukan pengguna 123; maka /usersdapat melakukan sesuatu dengan hasil itu.

Route middleware adalah alat yang lebih fleksibel dan kuat, menurut saya, karena itu tidak bergantung pada skema URI tertentu atau pemesanan rute. Saya akan cenderung untuk memodelkan contoh yang ditampilkan seperti ini, dengan asumsi Usersmodel dengan async 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);
});

Mampu mengendalikan aliran seperti ini cukup berguna. Anda mungkin ingin memiliki halaman tertentu hanya tersedia untuk pengguna dengan bendera admin:

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

Semoga ini memberi Anda beberapa inspirasi!

Saya juga memiliki masalah dalam memahami next (), tetapi ini membantu

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

Sebelum memahami next, Anda perlu memiliki sedikit gagasan tentang siklus Request-Response dalam simpul meskipun tidak banyak detail. Itu dimulai dengan Anda membuat permintaan HTTP untuk sumber daya tertentu dan berakhir ketika Anda mengirim respons kembali ke pengguna yaitu ketika Anda menemukan sesuatu seperti res.send ('Hello World');

mari kita lihat contoh yang sangat sederhana.

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

Di sini kita tidak perlu next (), karena resp.send akan mengakhiri siklus dan menyerahkan kontrol kembali ke rute middleware.

Sekarang mari kita lihat contoh lain.

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

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

Di sini kita memiliki 2 fungsi middleware untuk jalur yang sama. Tapi Anda akan selalu mendapat respons dari yang pertama. Karena yang dipasang pertama kali di tumpukan middleware dan kirim ulang akan mengakhiri siklus.

Tetapi bagaimana jika kita selalu tidak menginginkan "Hello World !!!!" respon balik. Untuk beberapa kondisi kita mungkin menginginkan "Hello Planet !!!!" tanggapan. Mari kita modifikasi kode di atas dan lihat apa yang terjadi.

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

Apa yang nextdilakukan di sini. Dan ya, Anda mungkin memiliki gusses. Ini akan melewati fungsi middleware pertama jika kondisinya benar dan memanggil fungsi middleware berikutnya dan Anda akan mendapat "Hello Planet !!!!"respons.

Jadi, selanjutnya lewati kontrol ke fungsi selanjutnya di tumpukan middleware.

Bagaimana jika fungsi middleware pertama tidak mengirim kembali respons apa pun tetapi jalankan logika dan kemudian Anda mendapatkan respons kembali dari fungsi middleware kedua.

Sesuatu seperti di bawah ini: -

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

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

Dalam hal ini Anda membutuhkan kedua fungsi middleware untuk dipanggil. Jadi, satu-satunya cara Anda mencapai fungsi middleware kedua adalah dengan memanggil next ();

Bagaimana jika Anda tidak melakukan panggilan ke berikutnya. Jangan berharap fungsi middleware kedua dipanggil secara otomatis. Setelah menjalankan fungsi pertama, permintaan Anda akan dibiarkan menggantung. Fungsi kedua tidak akan pernah dipanggil dan Anda tidak akan mendapatkan kembali responsnya.

Selanjutnya digunakan untuk meneruskan kontrol ke fungsi middleware berikutnya. Jika tidak, permintaan akan dibiarkan menggantung atau terbuka.

Memanggil fungsi ini memanggil fungsi middleware berikutnya dalam aplikasi. Fungsi () berikutnya bukan bagian dari Node.js atau Express API, tetapi argumen ketiga yang diteruskan ke fungsi middleware. Fungsi next () bisa dinamai apa saja, tetapi dengan konvensi itu selalu dinamai “next”.

Menjalankan nextfungsi memberitahu server bahwa Anda sudah selesai dengan langkah middleware ini dan dapat menjalankan langkah selanjutnya dalam rantai.