Kaedah pengendalian elegan Nodejs asynchronous callback_node.js

Kata Pengantar

Sorotan terbesar Nodejs ialah model I/O yang dipacu peristiwa dan tidak menyekat, yang menjadikan Nodejs mempunyai keupayaan pemprosesan serentak yang kukuh dan sangat sesuai untuk menulis aplikasi rangkaian. Kebanyakan operasi I/O dalam Nodej hampir tidak segerak, iaitu, hasil operasi I/O kami pada asasnya perlu diproses dalam fungsi panggil balik, seperti fungsi berikut yang membaca kandungan fail:

Salin kod Kod adalah seperti berikut:

fs.readFile('/etc/passwd', fungsi (err, data) {
jika (err) membuang err;
console.log(data);
});

Jadi, apakah yang perlu kita lakukan jika kita membaca dua fail dan menggabungkan kandungan kedua-dua fail bersama-sama untuk diproses Kebanyakan orang yang telah terdedah kepada js untuk masa yang singkat boleh melakukan ini:

Salin kod Kod adalah seperti berikut:

fs.readFile('/etc/passwd', fungsi (err, data) {
jika (err) membuang err;
fs.readFile('/etc/passwd2', fungsi (err, data2) {
Jika (err) membuang err;
// Proses data data dan data2 di sini
});
});

Jika anda berurusan dengan berbilang senario yang serupa, bukankah fungsi panggil balik bersarang lapisan demi lapisan Ini adalah perkara yang sering dipanggil oleh semua orang sebagai piramid panggil balik atau neraka panggil balik (http://callbackhell.com/ ) juga merupakan masalah yang paling menyusahkan bagi newbie js.

Kod bersarang jenis ini membawa banyak masalah kepada pembangunan, terutamanya ditunjukkan dalam:

1. Kemungkinan kod menjadi lebih teruk
2. Kesukaran dalam menyahpepijat
3. Sukar untuk menyelesaikan masalah apabila keabnormalan berlaku

Artikel ini terutamanya memperkenalkan cara mengendalikan isu panggil balik tak segerak di atas dengan anggun.

Penyelesaian asas: Kendalikan panggilan balik tak segerak secara rekursif

Kami boleh menggunakan rekursi sebagai alat kawalan pelaksanaan untuk kod kami. Merangkumkan operasi yang perlu dilakukan ke dalam fungsi, dan mengawal proses pelaksanaan kod melalui panggilan rekursif dalam fungsi panggil balik Tanpa berlengah lagi, mari pergi ke kod terakhir:

Salin kod Kod adalah seperti berikut:

var fs = memerlukan('fs');
// Senarai fail untuk diproses
var files = ['file1', 'file2', 'file3'];

fungsi parseFail () {
if (files.length == 0) {
Kembali;
}
var file = files.shift();
fs.readFile(fail, fungsi (err, data) {
// Data fail diproses di sini
ParseFile(); // Selepas pemprosesan, proses fail seterusnya melalui panggilan rekursif
});
}

//Mula memproses
parseFile();

Kod di atas telah memproses fail dalam tatasusunan secara berurutan sebagai contoh, memperkenalkan kaedah rekursif untuk mengawal aliran pelaksanaan kod.

Adalah baik untuk menerapkannya pada beberapa senario mudah Sebagai contoh, kita boleh menggunakan kaedah ini untuk menyimpan data dalam tatasusunan ke pangkalan data dalam urutan.

Sesetengah masalah panggil balik tak segerak mudah boleh diselesaikan melalui rekursi. Walau bagaimanapun, ia masih agak tidak berupaya untuk mengendalikan panggilan balik tak segerak yang kompleks (seperti keperluan untuk menyegerakkan hasil beberapa operasi tak segerak).

Titik cantik: Gunakan perpustakaan pihak ketiga seperti Async, Q dan Promise untuk mengendalikan panggilan balik tak segerak

Untuk menangani masalah panggilan balik bersarang dengan lebih baik, anda boleh mempertimbangkan untuk menggunakan beberapa pustaka pihak ketiga yang pakar dalam pemprosesan tak segerak Sudah tentu, jika anda mempunyai keupayaan, anda boleh menulis alat bantu anda sendiri untuk pemprosesan tak segerak.

Pustaka yang lebih biasa digunakan untuk mengendalikan pemprosesan tak segerak ialah: async, q dan promise. Berdasarkan laman web npmjs.org, async adalah yang paling popular. Saya telah menggunakan async sebelum ini, dan ia sememangnya sangat mudah Aliran kawalan pelbagai pemprosesan tak segerak juga dilaksanakan dengan baik.

Kami akan menggunakan async untuk memproses kod awal yang membaca dua fail pada masa yang sama Contohnya adalah seperti berikut:

Salin kod Kod adalah seperti berikut:

var async = memerlukan('async')
, fs = memerlukan('fs');

async.parallel([
fungsi(panggilan balik){
fs.readFile('/etc/passwd', fungsi (err, data) {
Jika (err) panggil balik(err);
panggilan balik(null, data);
});
},
fungsi(panggilan balik){
fs.readFile('/etc/passwd2', fungsi (err, data2) {
Jika (err) panggil balik(err);
       panggil balik(null, data2);
});
}
],
fungsi(err, hasil){
// Data data dan data2 diproses di sini, dan kandungan setiap fail diperoleh daripada hasil
});

Melalui modul async, proses pelaksanaan tak segerak boleh dikawal dengan baik, yang juga boleh dianggap sebagai menyelesaikan masalah panggilan balik pada semua peringkat Kod ini lebih jelas daripada sebelumnya, tetapi ia masih tidak boleh dipisahkan daripada fungsi panggil balik.

Fikirkan, bukankah bagus jika anda boleh mengendalikan pemprosesan tak segerak tanpa menggunakan fungsi panggil balik Seterusnya, mari bercakap tentang menggunakan ciri baharu ES6 untuk mencapai matlamat ini?

Jadilah elegan: terima ES6, gantikan fungsi panggil balik dan selesaikan masalah neraka panggil balik

Dikatakan bahawa EcmaScript Harmony (ES6) telah memperkenalkan banyak ciri baharu kepada js Pelajar yang tidak tahu banyak tentang ES6 boleh menyemaknya di Baidu.

Untuk menggunakan ciri baharu ES6 dalam nodejs, anda perlu menggunakan versi v0.11.x atau lebih tinggi.

Artikel ini memperkenalkan penggunaan ciri Penjana untuk menggantikan fungsi panggil balik Tidakkah anda tahu tentang Penjana? Anda boleh lihat di sini.

Dua modul bersama dan thunkify digunakan di sini Anda boleh memasangnya menggunakan arahan pemasangan npm.

Mari kita ambil masalah yang dinyatakan pada permulaan artikel ini sebagai contoh Kod contoh untuk menggunakan ciri penjana adalah seperti berikut:

Salin kod Kod adalah seperti berikut:

var fs = memerlukan('fs')
, co = memerlukan('co')
, thunkify = memerlukan('thunkify');

var readFile = thunkify(fs.readFile);

co(fungsi *() {
var test1 = hasil readFile('test1.txt');
var test2 = hasil readFile('test2.txt');
var test = test1.toString() test2.toString();
console.log(ujian);
})();

Mengendalikan pengecualian dalam kod juga sangat mudah, cuma lakukan ini:

Salin kod Kod adalah seperti berikut:

cuba {
var test1 = hasil readFile('test1.txt');
} tangkap (e) {
// Kendalikan pengecualian di sini
}

Bukankah kod ini lebih elegan? Bukankah bagus untuk mengendalikan kod tak segerak sama seperti menulis kod segerak?

Untuk pembangunan web dalam bidang nodejs, rangka kerja yang paling popular ialah ekspres Perlu dinyatakan bahawa TJ, ahli teras ekspres, telah mengetuai rangka kerja web-koa baharu, yang didakwa sebagai web generasi akan datang. rangka kerja pembangunan. , koa benar-benar memanfaatkan ciri penjana ES6, membolehkan kami mengelak daripada jatuh ke dalam lapisan panggilan balik semasa membangunkan sistem web.

Ringkasan

Memetik ayat daripada promosi projek fibjs: Kurang Panggilan Balik, Lebih Banyak Gadis - Kurang panggil balik, lebih ramai perempuan