Memahami Janji dan Janji Rantai dalam JavaScript

Apa itu Janji?

Janji dalam JavaScript adalah seperti "janji" yang anda buat untuk melakukan sesuatu pada masa hadapan. Ia ialah objek yang mewakili penyiapan (atau kegagalan) tugas tak segerak dan nilai yang terhasil. Ringkasnya, Janji bertindak sebagai pemegang tempat untuk nilai yang belum tersedia tetapi akan ada pada masa hadapan.

Negara Janji

Janji boleh wujud dalam satu daripada tiga negeri:

1. Belum selesai: Keadaan awal Janji, di mana ia masih menunggu tugas async untuk diselesaikan.
2. Ditepati: Keadaan di mana Janji berjaya diselesaikan, dan nilai yang terhasil tersedia.
3. Ditolak: Keadaan di mana Janji gagal dan ralat dikembalikan dan bukannya nilai yang dijangkakan.

Bagaimana Janji Berfungsi?

Janji dibuat menggunakan pembina Promise, yang mengambil dua parameter: selesaikan dan tolak—kedua-duanya adalah fungsi.

Jika operasi async berjaya, anda memanggil fungsi menyelesaikan untuk memenuhi janji.
Jika berlaku kesilapan, anda memanggil fungsi tolak untuk menunjukkan bahawa janji telah ditolak kerana ralat.
Anda boleh mengendalikan hasil Janji menggunakan .then() untuk kejayaan dan .catch() untuk pengendalian ralat.

Contoh: Mencipta dan Menepati Janji

const fetchData = new Promise((resolve, reject) => {
  // Simulate an asynchronous task like fetching data from a server
  setTimeout(() => {
    const data = "Some data from the server";

    // Simulate success and resolve the promise
    resolve(data);

    // You can also simulate an error by rejecting the promise
    // reject(new Error("Failed to fetch data"));
  }, 1000);
});

// Consuming the Promise
fetchData
  .then((data) => {
    console.log("Data fetched:", data);
  })
  .catch((error) => {
    console.error("Error fetching data:", error);
  });

Azam(data) akan mengembalikan data yang berjaya apabila Janji ditepati.
Jika berlaku kesilapan, reject(error) akan membuang ralat yang boleh dikendalikan dengan .catch().

Apa itu Janji Chaining?

Janji Janji ialah proses melaksanakan urutan tugas tak segerak, satu demi satu, menggunakan Janji. Setiap kaedah .then() dalam rantaian dijalankan selepas yang sebelumnya telah dipenuhi.

Mengapa Menggunakan Janji Chaining?

Ia membolehkan anda menulis kod yang bersih dan boleh dibaca untuk mengendalikan berbilang operasi tak segerak dalam susunan tertentu. Setiap .then() boleh mengembalikan nilai yang dihantar ke .then() seterusnya dalam rantaian, membolehkan anda mengendalikan tugasan langkah demi langkah.

Contoh: Merangkai Pelbagai Janji

new Promise((resolve, reject) => {
  setTimeout(() => resolve(1), 1000); // Initial async task resolves with 1
})
  .then((result) => {
    console.log(result); // Logs: 1
    return result * 2;   // Returns 2 to the next .then()
  })
  .then((result) => {
    console.log(result); // Logs: 2
    return result * 3;   // Returns 6 to the next .then()
  })
  .then((result) => {
    console.log(result); // Logs: 6
    return result * 4;   // Returns 24 to the next .then()
  });

Dalam contoh ini:

Janji bermula dengan menyelesaikan dengan 1 selepas 1 saat.
Setiap .then() yang berikutnya menerima hasil daripada yang sebelumnya, menggandakan atau menggandakannya dan menghantarnya ke .then() seterusnya.
Hasilnya direkodkan langkah demi langkah: 1, 2, 6.
Ralat Pengendalian dalam Rangkaian
Anda boleh menangkap sebarang ralat dalam rantai Promise menggunakan .catch(). Jika mana-mana .then() gagal, rantai berhenti dan ralat dihantar ke blok .catch().

new Promise((resolve, reject) => {
  setTimeout(() => resolve(1), 1000);
})
  .then((result) => {
    console.log(result); // Logs: 1
    return result * 2;
  })
  .then((result) => {
    throw new Error("Oops, something went wrong!");
  })
  .catch((error) => {
    console.error("Caught error:", error.message); // Catches the error
  });

Faedah Utama Janji

• Mengelakkan Neraka Panggilan Balik: Janji memudahkan pengurusan berbilang operasi async, yang sebaliknya membawa kepada panggilan balik bersarang dalam (juga dikenali sebagai neraka panggil balik).
• Pengendalian Ralat: Anda boleh mengendalikan semua ralat dalam rantai dengan satu .catch() pada penghujungnya.
• Pelaksanaan Berjujukan: Janji merantai memastikan tugas tak segerak dilaksanakan mengikut tertib, menjadikan kod lebih mudah untuk difikirkan.

Kesimpulan

Promises ialah alat yang berkuasa dalam JavaScript untuk mengendalikan tugas tak segerak. Dengan Promise Chaining, anda boleh mengurus berbilang operasi async dengan cara yang bersih, boleh dibaca dan berurutan. Dengan memahami cara membuat dan menggunakan Promises, dan merantainya bersama-sama, anda akan berjaya menguasai pengaturcaraan tak segerak dalam JavaScript!

Atas ialah kandungan terperinci Memahami Janji dan Janji Rantai dalam JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!