Dalam proses membangunkan aplikasi Node.js, memahami dan bekerja dengan pengendalian acara dan pemprosesan tak segerak adalah penting. Node.js dibina pada model dipacu peristiwa dan tak segerak, membolehkan tugasan dilaksanakan tanpa menunggu selesai. Malah, memahami dan menggunakan pengendalian peristiwa dan pemprosesan tak segerak dengan betul adalah bahagian penting dalam mengoptimumkan prestasi aplikasi.
Peristiwa dan callback s dalam Node.js
Dalam Node.js, peristiwa dan callback s memainkan peranan penting dalam mengendalikan operasi tak segerak. Peristiwa ialah cara untuk mengendalikan dan bertindak balas terhadap tindakan atau kejadian tertentu yang berlaku dalam aplikasi. Callback s, sebaliknya, adalah fungsi yang dilaksanakan sebaik sahaja acara atau operasi tertentu selesai.
Node.js menyediakan seni bina dipacu peristiwa di mana bahagian aplikasi yang berlainan boleh memancarkan peristiwa dan mendengarnya. Ini membolehkan pemprosesan berbilang operasi yang cekap dan tidak menyekat secara serentak.
Callback s biasanya digunakan dalam Node.js untuk mengendalikan operasi tak segerak. Mereka diluluskan sebagai hujah kepada fungsi dan dilaksanakan sebaik sahaja operasi selesai. Callback s menyediakan cara untuk mengendalikan keputusan atau ralat yang berlaku semasa tugasan tak segerak.
Berikut ialah contoh penggunaan a callback dalam Node.js:
// A function that takes a callback
function fetchData(callback) {
// Simulate fetching data from an asynchronous operation
setTimeout(() => {
const data = { name: 'John', age: 30 };
callback(null, data); // Pass the data to the callback
}, 2000); // Simulate a 2-second delay
}
// Call the fetchData function and provide a callback
fetchData((error, data) => {
if(error) {
console.error('Error:', error);
} else {
console.log('Data:', data);
}
});
Dalam contoh ini, kami mempunyai fungsi yang dipanggil fetchData yang mensimulasikan pengambilan data daripada operasi tak segerak(cth, membuat panggilan API atau menanyakan pangkalan data). Ia memerlukan callback fungsi sebagai hujah.
Di dalam fetchData fungsi, kami gunakan setTimeout untuk mensimulasikan operasi tak segerak. Selepas kelewatan 2 saat, kami mencipta beberapa data sampel dan menyerahkannya kepada callback fungsi bersama-sama dengan ralat(yang ditetapkan kepada null dalam kes ini).
Di luar fetchData fungsi, kami memanggilnya dan menyediakan callback fungsi. Dalam callback, kami mengendalikan sebarang kemungkinan ralat dan memproses data yang diterima. Jika terdapat ralat, kami log masuk ke konsol. Jika tidak, kami log data.
Ini ialah contoh asas menggunakan a callback dalam Node.js untuk mengendalikan operasi tak segerak dan memastikan data diproses sebaik sahaja ia tersedia. Dalam senario dunia sebenar, callback s biasanya digunakan untuk mengendalikan pertanyaan pangkalan data, permintaan API dan tugas tak segerak yang lain.
Menggunakan Promise s dan untuk mengendalikan ketidaksegerakan async/await
"Menggunakan Promise dan mengendalikan operasi tak segerak" ialah pendekatan biasa dalam Node.js untuk mengendalikan tugas tak segerak dengan cara yang mudah dan cekap. ialah objek yang membantu kami mengurus dan mengendalikan operasi tak segerak, manakala sintaks yang membolehkan kami menulis kod tak segerak dengan cara yang serupa dengan kod segerak. async/await Promise JavaScript async/await
Dengan menggunakan Promise dan, kita boleh menulis kod tak segerak dengan lebih mudah dan intuitif. Kita tidak perlu lagi menggunakan fungsi dan berurusan dengan neraka(fungsi bersarang ) untuk mengendalikan operasi tak segerak. Sebaliknya, kita boleh menggunakan kata kunci await untuk menunggu sehingga selesai dan mengembalikan hasilnya. async/await callback callback callback Promise
Berikut ialah contoh penggunaan Promise dan dalam Node.js untuk mengendalikan operasi tak segerak: async/await
// A mock function to fetch data from an API
function fetchData() {
return new Promise((resolve, reject) => {
setTimeout(() => {
const data = { name: 'John', age: 30 };
resolve(data); // Return data within the Promise
}, 2000);
});
}
// Using async/await to handle asynchronous operations
async function getData() {
try {
const data = await fetchData(); // Wait for the Promise to complete and return the data
console.log('Data:', data);
} catch(error) {
console.error('Error:', error);
}
}
// Call the getData function
getData();
Dalam contoh ini, kami menggunakan fetchData fungsi untuk mensimulasikan pengambilan data daripada API(atau sebarang operasi tak segerak). Fungsi ini mengembalikan a Promise, di mana kita memanggil resolve fungsi untuk mengembalikan data.
Di luar fetchData fungsi, kami menggunakan try/catch blok untuk menangani ralat. Dalam getData fungsi, kami menggunakan await kata kunci untuk menunggu untuk Promise melengkapkan dan mengembalikan data. Jika terdapat ralat dalam Promise, ia akan membuang pengecualian dan kami mengendalikannya dalam catch blok.
Akhir sekali, kami memanggil getData fungsi untuk memulakan pemprosesan tak segerak. Hasilnya akan dilog ke konsol selepas Promise selesai dan mengembalikan data.
Menggunakan Promise dan menjadikan kod kami lebih mudah dibaca dan lebih mudah difahami apabila berurusan dengan operasi tak segerak. Ia membantu kita mengelakkan neraka dan membolehkan kita menulis kod secara berurutan, sama seperti menulis kod segerak. async/await callback
Kesimpulan: Pengendalian acara dan pemprosesan tak segerak ialah dua aspek penting dalam pembangunan aplikasi Node.js. Dengan memahami dan menggunakan konsep dan alatan yang berkaitan dengan betul, anda boleh membina aplikasi yang cekap, fleksibel dan boleh dipercayai pada platform Node.js.