Perbezaan antara Ralat dan Pengecualian dalam JavaScript

https://github.com/Ray-D-Song

Ralat dan pengecualian ialah konsep yang lahir daripada amalan, bertujuan untuk mengendalikan "ralat boleh atur cara".

ralat

Dari perspektif kod, ralat cenderung dikendalikan secara manual dengan tepat.

Contohnya, fnA memanggil fnB dan fnC. Kedua-dua kaedah mungkin menghadapi ralat dan kod pemprosesan adalah kira-kira seperti berikut:

function fnA() {
  const { err: bErr, res: bRes } = fnB()
  if (bErr) {
    // ...
    // error handling
  }

  const { err: cErr, res: cRes } = fnC()
  if (cErr) {
    // ...
    // error handling
  }
  // normal logic
}

Kunci kepada "ralat" adalah untuk mengembalikan objek atau tatasusunan daripada fungsi, dengan satu medan mewakili "ralat berlaku". Selagi medan ini tidak kosong, pengaturcara tahu bahawa aliran biasa telah terganggu.

JavaScript mempunyai objek Ralat dalaman dan pembina, tetapi medan yang mewakili ralat tidak diperlukan untuk menjadi objek Ralat. Sebaliknya, objek Ralat lebih kerap digunakan dalam pengendalian pengecualian.

Pengecualian

Kami sudah mempunyai pengendalian ralat, mengapa kami memerlukan pengecualian?

Bayangkan senario di mana anda mempunyai butang. Apabila butang diklik, ia mencetuskan fungsi A. Selepas melalui berbilang lapisan panggilan (mungkin 10 lapisan), ralat berlaku dalam fungsi X. Anda tidak mahu memberitahu pengguna "ralat tidak diketahui", sebaliknya ingin memberikan maklumat khusus tentang perkara yang salah.

Anda boleh mencapai kesan ini dengan ralat, tetapi anda perlu menulis sepuluh kali kod ini:

function fnA() {
  const { err, res } = fnB()
  if (err) {
    // display error to user
    showErr(err)
  }
}

function fnB() {
  const { err, res } = fnC()
  if (err)
    // propagate error
    return { err, null }
}

// ... 10 similar passes

function fnY() {
  const { err, res } = fnX()
  if (err)
    // propagate error
    return { err, null }
}

Kod boilerplate seperti ini sangat tidak cekap. Kaedah yang lebih baik ialah menggunakan pengecualian.

Anda hanya perlu membuang pengecualian apabila ralat berlaku dalam fnY. Di peringkat atas, anda boleh menangkapnya.

function fnA() {
  try {
    fnB()
  } catch (e) {
    showErr(e)
  }
}

// ...

function fnY() {
  const { err, res } = fnX()
  if (err)
    // 抛出
    throw err
}

Dengan cara ini, tidak kira di mana ralat berlaku, ia boleh ditangkap di peringkat teratas dan kod dalam lapisan lain tidak terjejas.

Elakkan mencemarkan keseluruhan struktur kod dengan ralat di satu tempat.

Mengapa membezakan antara keduanya?

Kami telah menjelaskan mengapa kami memerlukan pengecualian, tetapi mengapa kami perlu membezakan antara ralat dan pengecualian?

Amalan terbaik adalah dengan tegas membezakan antara keduanya. Jika ralat tidak perlu diteruskan lapisan demi lapisan, ia harus dikendalikan terus dalam lapisan semasa. Sebagai contoh, ralat fnC tidak perlu digunakan dalam fnA, jadi ia harus dikendalikan sebagai ralat secara langsung dalam B.

Anggap semua ralat dikendalikan di peringkat atas, maka semua logik dilonggokkan di blok tangkapan di peringkat atas, yang sukar untuk dikekalkan.

function main() {
  try {
    task1()
    task2()
    task3()
  } catch(e) {
    switch(e) {
      case "type A":
        //...
        break;
      case "type B":
        //...
        break;
      case "type C":
        //...
        break;
    }
  }
}

Atas ialah kandungan terperinci Perbezaan antara Ralat dan Pengecualian dalam JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!