Cara Mengatasi Kesalahan dan Janji dalam JavaScript Moden

Sentiasa gunakan .catch () untuk mengendalikan penolakan janji dan mencegah penolakan yang tidak diendahkan. 2. Gunakan async/menunggu dengan cuba/menangkap untuk pengendalian ralat yang boleh dibaca, memastikan semua janji ditunggu -tunggu di dalam blok percubaan. 3. Kesilapan dalam .then () panggil balik, termasuk pengecualian segerak, ditangkap oleh final .catch (), menghapuskan keperluan untuk mencuba/menangkap bersarang. 4. Memantau penolakan yang tidak diawasi secara global menggunakan 'tidak dapat dilepaskan' dalam pelayar atau 'tidak dapat dilepaskan' dalam node.js untuk debugging, tetapi selalu mengendalikan penolakan secara eksplisit. 5. Gunakan Janji.All () apabila semua janji mesti berjaya, dan janji. 6. Buang kesilapan deskriptif, kontekstual untuk meningkatkan debugging dan mengekalkan konteks kesilapan di seluruh lapisan. Secara konsisten memohon amalan ini memastikan kod JavaScript yang tidak dapat diselenggara dan tidak diselenggarakan.

Mengendalikan kesilapan dan janji dengan betul adalah penting dalam JavaScript moden, terutamanya ketika bekerja dengan operasi tak segerak seperti panggilan API, pengendalian fail, atau pemasa. Sekiranya tidak diuruskan dengan betul, penolakan yang tidak diketahui atau kegagalan senyap boleh menyebabkan pepijat yang sukar dikesan. Berikut adalah cara menangani kesilapan dan janji dengan berkesan menggunakan corak moden.

1. Gunakan .catch() untuk pengendalian penolakan janji

Setiap kali anda bekerja dengan janji-sama ada dikembalikan dari fetch , fungsi async , atau logik berasaskan janji tersuai-selalu mengendalikan penolakan yang berpotensi menggunakan .catch() .

 Ambil ('https://api.example.com/data')
  .then (response => response.json ())
  .THEN (data => console.log (data))
  .catch (error => {
    console.error ('Kesalahan berlaku:', ralat);
  });

Walaupun anda mengharapkan janji untuk menyelesaikan dengan jayanya, isu rangkaian, masalah CORS, atau JSON yang cacat boleh menyebabkan penolakan. Melangkau .catch() risiko penolakan janji yang tidak diandalkan, yang mungkin merosakkan aplikasi anda dalam persekitaran yang ketat.

? Petua: .catch() menangkap kesilapan dari mana -mana langkah terdahulu dalam rantai - sama ada kegagalan rangkaian, kesilapan parsing, atau pengecualian yang dilemparkan dalam panggilan balik .then() .

2. Gunakan async/await dengan try/catch

JavaScript moden nikmat async/await sintaks untuk kod asynchronous yang lebih bersih, lebih mudah dibaca. Tetapi dengan gaya ini, anda mesti menggunakan blok try/catch untuk mengendalikan kesilapan.

 fungsi async fetchData () {
  Cuba {
    Const Response = menunggu pengambilan ('https://api.example.com/data');
    const data = menunggu tindak balas.json ();
    console.log (data);
  } menangkap (ralat) {
    Console.error ('Ralat mengambil data:', ralat);
  }
}

Pendekatan ini mencerminkan pengendalian kesilapan segerak dan membuat debugging lebih mudah. Mana -mana janji yang ditolak di dalam blok try akan melompat ke blok catch .

Kesalahan umum: Melupakan await janji dalam fungsi async . Itu tidak akan dibuang dengan segera - ia akan mengembalikan janji yang ditolak, mungkin melangkaui try/catch anda. Sentiasa await janji di dalam try .

3. Sentiasa mengendalikan kesilapan dalam .then() panggil balik

Malah dalam .then() , kesilapan boleh berlaku - seperti logik parsing, transformasi data tidak sah, atau pernyataan throw manual. Ini secara automatik ditangkap oleh rantaian janji dan boleh dikendalikan ke hilir.

 Ambil ('/data.json')
  .THEN (res => res.json ())
  .THEN (data => {
    jika (! data.userid) {
      membuang ralat baru ('hilang userid');
    }
    pulangan data;
  })
  .catch (err => {
    Console.error ('Pengesahan atau parsing gagal:', err);
  });

Ini bermakna anda tidak perlu bersarang try/catch .then() Callbacks - hanya bergantung pada final .catch() untuk menangkap pengecualian segerak dan penolakan sama.

4. Elakkan penolakan yang tidak diasingkan

Penolakan yang tidak diendahkan berlaku apabila janji ditolak tetapi tidak .catch() dilampirkan. Pelayar moden dan Node.js amaran log untuk ini, dan versi masa depan boleh merawatnya sebagai kesilapan runtime.

Untuk memantau secara global penolakan yang tidak diasingkan (berguna dalam pembangunan atau pembalakan):

Dalam penyemak imbas:

 window.addeventListener ('Undandledrection', event => {
  Console.warn ('Penolakan Janji Tanpa Diraja:', Event.Reason);
  // secara opsyen mencegah lalai (menindas amaran)
});

Di node.js:

 Process.on ('Undandledrection', (alasan, janji) => {
  Console.error ('penolakan yang tidak ditandakan di:', janji, 'alasan:', alasan);
  // log atau hantar ke perkhidmatan penjejakan ralat
});

? Gunakan ini untuk menyahpepijat atau pemantauan, tetapi jangan bergantung kepadanya sebagai pengendalian ralat utama anda. Sentiasa mengendalikan penolakan secara eksplisit.

5. Gunakan Promise.all() dan Promise.allSettled() dengan bijak

Semasa berurusan dengan pelbagai janji:

• Promise.all() gagal dengan cepat - Satu penolakan menyebabkan semuanya ditolak.
• Promise.allSettled() menunggu semua selesai, tanpa mengira kejayaan atau kegagalan.

Pilih berdasarkan keperluan anda:

 // gagal atas kesalahan pertama
Cuba {
  Hasil const = menunggu janji.all ([[
    Ambil ('/API/User'),
    Ambil ('/API/POSTS'),
  ]);
} menangkap (ralat) {
  // Satu permintaan gagal gagal semuanya
}

 // Mengendalikan kegagalan separa dengan anggun
Hasil const = menanti janji.allsettled ([[
  Ambil ('/API/User'),
  Ambil ('/API/POSTS'),
]);

results.foreach ((hasil, indeks) => {
  jika (result.status === 'dipenuhi') {
    console.log ('Kejayaan:', result.value);
  } else {
    Console.error ('gagal:', result.Reason);
  }
});

Gunakan allSettled() apabila anda mahu daya tahan; Gunakan all() apabila semua operasi mesti berjaya.

6. Lemparkan kesilapan yang bermakna

Daripada mesej generik, berikan konteks supaya debugging lebih mudah.

 fungsi async getUser (id) {
  Cuba {
    const res = menunggu pengambilan (`/api/pengguna/$ {id}`);
    jika (! res.ok) {
      membuang ralat baru (`http $ {res.status}: $ {res.statustext}`);
    }
    kembali menunggu res.json ();
  } menangkap (ralat) {
    membuang ralat baru (`gagal mendapatkan pengguna $ {id}: $ {error.message}`);
  }
}

Ini mengekalkan rantaian apa yang salah dan di mana.

Pada asasnya, pengendalian kesilapan janji bersih datang ke konsistensi: sentiasa mengendalikan penolakan, lebih suka async/await dengan try/catch untuk dibaca, dan tidak pernah mengabaikan kemungkinan kegagalan. Ia tidak mencolok, tetapi ia menjadikan aplikasi anda stabil.

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