Analisis mendalam NodeJs serentak dan pemprosesan panggilan balik tak segerak_node.js

Tidak tepat untuk mengatakan serentak dan tak segerak. Ciri asynchronous single-threaded NodeJs secara langsung menyebabkan panggilan balik tidak dapat menentukan hasil pelaksanaan akhir apabila berbilang operasi tak segerak dilakukan pada masa yang sama. Berikan contoh mudah:

for(var i = 0; i < 5; i++) {
  fs.readFile('file', 'utf-8', function(error, data){});
} 

Saya memulakan 5 operasi tak segerak untuk membaca fail berturut-turut. Jadi persoalannya, bagaimana saya boleh memastikan semua operasi tak segerak telah selesai. Kerana operasi seterusnya hanya boleh dijalankan selepas semuanya dilaksanakan. Saya percaya bahawa pelajar yang mempunyai sedikit pengalaman akan berfikir untuk menggunakan kaedah pengiraan, tetapi bagaimana untuk memastikan pengiraan yang betul adalah masalah lain. Fikirkan dengan teliti:

Panggil balik ialah fungsi yang menetapkan pembilang kepada 1 semasa setiap operasi tak segerak, dan menetapkan pembilang kepada -1 apabila setiap operasi tak segerak tamat Tentukan sama ada untuk melaksanakan panggilan balik dengan menilai sama ada pembilang adalah 0. Logik ini sangat mudah. ​​Ia memerlukan pembolehubah global berbanding masa pelaksanaan dan masa panggil balik sebagai pembilang, dan ia mesti melaksanakan operasi 1 apabila dihantar ke kaedah tak segerak, dan kemudian mengembalikan fungsi untuk panggilan balik, yang agak berbelit-belit , tetapi lihat penggunaan lanjutan fungsi Js:

var pending = (function() {
  var count = 0;
  return function() {
    count++;
    return function() {
      count--;
      if (count === 0) {
        // 全部执行完毕
      }
    }
  }
}); 

Apabila belum selesai dipanggil, ia belum selesai(), sebagai contoh:

var done = pending(); 

Pada masa ini, kiraan pembolehubah pengiraan dimulakan kepada 0, dan fungsi yang dikembalikan dilampirkan kepada selesai Jika done() dilaksanakan pada masa ini, apakah yang akan berlaku? Adakah untuk melaksanakan secara langsung fungsi pertama yang dikembalikan dengan menunggu, iaitu: pending()() Apakah pelaksanaan ini Mula-mula, pembolehubah pengiraan 1 dikembalikan, dan fungsi ini diteruskan sebagai panggilan balik kepada kaedah tak segerak Apabila melaksanakan panggilan balik ini, mula-mula tetapkan pembolehubah kiraan kiraan-1, dan kemudian tentukan sama ada kiraan itu ialah 0. Jika ia adalah 0, ini bermakna semua pelaksanaan tak segerak selesai, sekali gus mencapai operasi tak segerak berterusan dengan yang sama. panggil balik.

Kuncinya terletak pada dua pengembalian secara ringkas:

Fungsi pulangan pertama ialah mengira 1, dan kemudian mengembalikan fungsi yang memerlukan panggil balik

Fungsi pulangan kedua ialah fungsi yang memerlukan panggilan balik Jika ia dilaksanakan, ia akan mengira-1, dan kemudian menentukan sama ada semua pelaksanaan tak segerak selesai, ia akan memanggil semula

Lihat contoh praktikal, panggil balik tak segerak untuk membaca berbilang fail:

var fileName = ['1.html', '2.html', '3.html'];
var done = pending(function(fileData) {
  console.log('done');
  console.log(fielData);
});
for(var i = 0; i < fileName.lenght; i++) {
  fs.readFile(fileName[i], 'utf-8', done(fileName[i]));
}

Yang selesai menggunakan kaedah yang belum selesai untuk menyelesaikan kaedah yang kita mahu panggil balik dan laksanakan Apabila kaunter adalah 0, ia akan dilaksanakan Kemudian kita perlu memperbaiki kaedah yang belum selesai:

var pending = (function(callback) {
  var count = 0;
  var returns = {};
  console.log(count);
  return function(key) {
    count++;
    console.log(count);
    return function(error, data) {
      count--;
      console.log(count);
      returns[key] = data;
      if (count === 0) {
        callback(returns);
      }
    }
  }
}); 

panggilan balik ialah fungsi panggil balik kami Apabila var done = pending(callback), done sebenarnya adalah fungsi pulangan pertama Ia mempunyai parameter yang boleh digunakan sebagai subskrip nilai yang dikembalikan, jadi dalam badan gelung In done(. FileName[i]), nama fail dihantar masuk. Ini done() dilaksanakan secara langsung Selepas mengira 1, ia mengembalikan fungsi panggil balik untuk dihantar kepada kaedah tak segerak Seperti yang dinyatakan sebelum ini, fungsi panggil balik ini akan menentukan sama ada untuk melaksanakan fungsi panggil balik yang kita ingin laksanakan berdasarkan pembolehubah kira. Dan kandungan fail dihantar kepadanya, iaitu, kembali. Baiklah, mari kita jalankan, saya percaya kita boleh melihat hasilnya dengan tepat.

0
1
2
3
2
1
0
selesai
{"1.html": "xxx", "2.html": "xxx", "3.html": "xxx"}

Ia boleh dilihat dengan jelas daripada kiraan, dari 0-3 hingga 0, dan kemudian fungsi panggil balik kami selesai dan kandungan fail.

Masalah ini selesai, kita perlu memikirkan bagaimana untuk merangkum dan menggunakan semula kaedah sedemikian, bukankah tidak saintifik untuk menulis setiap masa?

Mari kita lihat kaedah pemprosesan UnJs (salah satu rangka kerja pembangunan web berasaskan NodeJs saya), digunakan pada operasi sub-templat dalam penghuraian templat:

unjs.asyncSeries = function(task, func, callback) {
  var taskLen = task.length;
  if (taskLen <= 0) {
    return;
  }
  var done = unjs.pending(callback);
  for(var i = 0; i < taskLen; i++) {
    func(task[i], done);
  }
} 

asyncSeries mempunyai tiga parameter, bermakna:

tugas: Objek yang perlu diproses, seperti fail yang perlu dibaca, ia adalah senarai, jika ia bukan senarai, atau panjang senarai ialah 0, ia tidak akan dilaksanakan

fungsi: Kaedah tak segerak, seperti fs.readFile, disalurkan melaluinya

panggil balik: Kaedah yang kami mahu panggil balik

dilakukan adalah sama seperti sebelumnya. Ia dihantar ke func, tetapi ia tidak dilaksanakan Kerana kami berharap pihak aplikasi dapat mengawal parameter, kami membiarkan bahagian aplikasi melaksanakannya.

Lihat operasi apabila berurusan dengan sub-templat:

var subTemplate = [];
var patt = /\{\% include \'(.+)\' \%\}/ig;
while(sub = patt.exec(data)) {
  var subs = sub;
  subTemplate.push([subs[0], subs[1]]);
}
unjs.asyncSeries(subTemplate, function(item, callback) {
  fs.readFile('./template/' + item[1], 'utf-8', callback(item[0]));
}, function(data) {
  for(var key in data) {
    html = html.replace(key, data[key]);
  }
}); 

Senarai subTemplat ialah data yang dijana berdasarkan analisis sub-templat Ia adalah tatasusunan dua dimensi Nilai pertama bagi setiap sub-item ialah teks panggilan sub-templat, iaitu: {%. sertakan 'header.html ' %} rentetan sedemikian, parameter kedua ialah nama fail subtemplat, iaitu: header.html

Parameter kedua asyncSeries ialah panggil balik, yang sebenarnya merupakan parameter ketiga, iaitu kaedah panggilan balik yang belum selesai yang ingin kami laksanakan seperti yang dinyatakan sebelum ini, di dalam asyncSeries, ia tidak dijalankan di sini, iaitu: panggil balik(item[0]), dengan parameter, kerana kemudian rentetan yang memanggil sub-templat dalam templat induk akan digantikan dengan kandungan sub-templat yang sepadan berdasarkan parameter ini.

Dengan cara ini, selagi asynchronous berterusan diperlukan, anda boleh menggunakan kaedah asyncSeries untuk mengendalikannya. Kerana hubungan tidak segerak, aliran program agak berbelit-belit, dan ia mungkin tidak mudah difahami pada mulanya Walaupun anda sudah biasa dengannya, anda mungkin tidak memahaminya , panggilan balik dalam parameter kedua sebenarnya dijana oleh parameter ketiga Anda mungkin tertanya-tanya, apakah sebenarnya panggilan balik ini? Terdapat juga dua pulangan dalam pending, yang tidak mudah difahami dan perlu difikirkan lebih lanjut.

Baiklah, panggilan balik tak segerak berterusan dilengkapkan menggunakan ciri lanjutan fungsi Js. Walau bagaimanapun, sifat tak segerak NodeJ benar-benar menjadikan kawalan program menjadi sangat bermasalah, seperti operasi tak segerak berterusan yang memerlukan pemindahan nilai, dll. Ini semua boleh dicapai melalui idea dan perubahan ini.

Kandungan di atas ialah pengetahuan tentang pemprosesan panggilan balik serentak dan tak segerak dalam NodeJs yang dikongsi oleh editor saya harap anda menyukainya.