Mari analisa kaedah pengendalian pengecualian JavaScript bersama-sama

Artikel ini membawakan anda pengetahuan yang berkaitan tentang JavaScript, yang terutamanya memperkenalkan isu yang berkaitan dengan pengendalian pengecualian pada situasi ini dan bagaimana untuk melakukan yang lebih baik pada masa akan datang, saya harap ia akan membantu semua orang.

[Cadangan berkaitan: tutorial video javascript, bahagian hadapan web]

Ralat adalah sebahagian daripada proses pengaturcaraan. Tidak dapat dielakkan terdapat beberapa kesilapan dalam proses menulis program Melalui kesilapan ini, kita boleh belajar bagaimana untuk mengelakkan situasi sedemikian dan bagaimana untuk melakukan yang lebih baik pada masa akan datang.

Dalam JavaScript, apabila penyataan kod digandingkan dengan ketat dan menghasilkan ralat, tidak masuk akal untuk terus menggunakan penyataan kod yang tinggal. Sebaliknya, kami cuba pulih daripada kesilapan dengan sebaik mungkin. Jurubahasa JavaScript menyemak kod pengendalian pengecualian apabila ralat sedemikian berlaku, dan jika tiada pengendali pengecualian, atur cara kembali kepada apa-apa fungsi yang menyebabkan ralat itu.

Ulangi ini untuk setiap fungsi pada tindanan panggilan sehingga pengendali pengecualian ditemui atau fungsi peringkat teratas dicapai, menyebabkan atur cara ditamatkan dengan ralat, menyebabkan atur cara ranap.

Secara umumnya, terdapat dua cara untuk mengendalikannya:

• Lemparkan pengecualian —jika ia berlaku pada masa jalan Masalahnya tidak dapat ditangani dengan bermakna, lebih baik membuangnya

function openFile(fileName) {
  if (!exists(fileName)) {
    throw new Error('找不到文件 ' + fileName)
  }
  // ...
}

• Tangkap pengecualian—pengecualian yang dilemparkan dilaksanakan pada masa jalankan Di mana ia lebih masuk akal ditangkap dan diproses

try {
  openFile('../test.js')
} catch(e) {
  // 优雅地处理抛出的期望
}

Mari kita lihat operasi ini dengan lebih terperinci.

Melemparkan pengecualian

Anda mungkin melihat sesuatu seperti ReferenceError: spesifikasi tidak ditakrifkan. Ini mewakili pengecualian yang dilemparkan melalui pernyataan lontaran.

Sintaks

throw «value»
// 不要这样做
if (somethingBadHappened) {
  throw 'Something bad happened'
}

Tiada sekatan pada jenis data yang boleh dilemparkan sebagai pengecualian, tetapi JavaScript mempunyai jenis pengecualian terbina dalam khas. Salah satunya ialah Ralat, seperti yang anda lihat dalam contoh sebelumnya. Jenis pengecualian terbina dalam ini memberikan kami lebih banyak butiran daripada mesej pengecualian.

Ralat

Jenis Ralat digunakan untuk mewakili pengecualian umum. Jenis pengecualian ini paling biasa digunakan untuk melaksanakan pengecualian yang ditentukan pengguna. Ia mempunyai dua sifat terbina dalam yang tersedia.

• mesej — Kandungan dihantar sebagai parameter kepada pembina Ralat. Contohnya, Ralat baharu('Ini adalah mesej ralat'). Anda boleh mengakses mesej melalui sifat mesej.

const myError = new Error('Error!!!')
console.log(myError.message) // Error!!!

• tindanan — Sifat ini mengembalikan sejarah (tindanan panggilan) fail yang menyebabkan ralat. Bahagian atas timbunan juga termasuk mesej, diikuti dengan timbunan sebenar, bermula dari titik ralat terkini/terpencil ke fail paling bertanggungjawab terluar.

Error: Error!!!
    at <anonymous>:1:1

Nota: new Error('...') tidak akan melakukan apa-apa sebelum melontar, iaitu throw new Error('error msg') akan digunakan dalam JavaScript Creates an Contoh ralat dan menghentikan pelaksanaan skrip melainkan anda melakukan beberapa tindakan pada ralat Ralat, seperti menangkapnya.

Menangkap Pengecualian

Sekarang setelah kita tahu apa itu pengecualian dan cara membuangnya, mari kita bincangkan cara untuk menghalangnya daripada melanggar program kita dengan menangkapnya.

cuba-tangkap-akhirnya ialah cara paling mudah untuk mengendalikan pengecualian.

try {
  // 要运行的代码
} catch (e) {
  // 发生异常时要运行的代码
}
  
[ // 可选
  finally {
    // 无论发生异常都始终执行的代码
  }
]

Dalam klausa cuba, kami menambah kod yang mungkin menjana pengecualian. Jika pengecualian berlaku, klausa tangkapan dilaksanakan.

Kadangkala, kod perlu dilaksanakan tidak kira sama ada kod tersebut menghasilkan pengecualian Dalam kes ini, kita boleh menggunakan blok akhirnya pilihan.

Blok akhirnya akan dilaksanakan walaupun klausa try or catch melaksanakan pernyataan pulangan. Sebagai contoh, fungsi berikut mengembalikan 'Laksanakan akhirnya' kerana klausa akhirnya ialah perkara terakhir yang dilaksanakan.

function foo() {
  try {
    return true
  } finally {
    console.log('Execute finally')
  }
}

Kami menggunakan try-catch di mana ketepatan kod tidak boleh disemak terlebih dahulu.

const user = '{"name": "D.O", "age": 18}'
try {
  // 代码运行
  JSON.parse(params)
  // 在出现错误的情况下，其余的代码将永远无法运行
  console.log(params)
} catch (err) {
  // 在异常情况下运行的代码
  console.log(err.message) // params is not defined
}

Seperti yang ditunjukkan di atas, adalah tidak mungkin untuk menyemak JSON.parse untuk objek atau rentetan rentetan sebelum melaksanakan kod.

Nota: Anda boleh menangkap pengecualian yang dijana program dan pengecualian masa jalan, tetapi anda tidak dapat menangkap ralat sintaks JavaScript.

cuba-tangkap-akhirnya hanya dapat menangkap ralat penyegerakan. Jika kita cuba menggunakannya dengan kod tak segerak, try-catch-finally mungkin telah dilaksanakan sebelum kod tak segerak menyelesaikan pelaksanaannya.

Cara mengendalikan pengecualian dalam blok kod tak segerak

Fungsi panggil balik

Gunakan fungsi panggil balik (tidak disyorkan), kami biasanya Anda akan menerima dua parameter seperti yang ditunjukkan di bawah:

async function(code, (err, result) => {
  if (err) return console.error(err)
  console.log(result)
})

Kita dapat melihat bahawa terdapat dua parameter: err dan result. Jika terdapat ralat, parameter err akan sama dengan ralat dan kita boleh membuangnya untuk pengendalian pengecualian.

在 if (err) 块中返回某些内容或将其他指令包装在 else 块中都很重要。否则，您可能会遇到另一个错误。例如，当您尝试访问 result.data 时，result 可能未定义。

Promises

使用 promises 的 then 或者 catch，我们可以通过将错误处理程序传递给 then 方法或使用 catch 子句来处理错误。

promise.then(onFulfilled, onRejected)

也可以使用 .catch(onRejected) 而不是 .then(null, onRejected) 添加错误处理程序，其工作方式相同。

让我们看一个 .catch 拒绝 Promise 的例子。

Promise.resolve('1')
  .then(res => {
    console.log(res) // 1
    throw new Error('go wrong') // 抛出异常
})
.then(res => {
  console.log(res) // 不会被执行
})
.catch(err => { 
  console.error(err) // 捕获并处理异常 ——> Error: go wrong
})

使用 async/await 和 try-catch

使用 async/await 和 try-catch-finally，处理异常是轻而易举的事。

async function func() {
  try {
    await nonExistentFunction()
  } catch (err) {
    console.error(err) // ReferenceError: nonExistentFunction is not defined 
  }
}

如何处理未捕获的异常

现在我们已经很好地理解了如何在同步和异步代码块中执行异常处理，让我们回答本文最后一个待解决的问题 ：我们如何处理未捕获的异常？

在浏览器中

我们可以使用 window.onerror() 方法来处理未捕获的异常。每当运行时发生错误时，该方法会在 window 对象上触发 error 事件。

onerror() 的另一个实用做法是：当站点中的图片或视频等数据加载出错时，可以用该方法触发某些操作。例如，提供一张加载出错时的图片，或显示一条消息。

<img src="logo.png" onerror="alert(&#39;Error loading picture.&#39;)" />

在 Node.js 中

EventEmitter 模块派生的 process 对象可以订阅事件 uncaughtException。

process.on('uncaughtException', () => {})`

我们可以传递一个回调来处理异常。如果我们尝试捕获这个未捕获的异常，进程将不会终止，因此我们必须手动完成。

uncaughtException 仅适用于同步代码。对于异步代码，还有另一个称为 unhandledRejection 的事件。

process.on('unhandledRejection', () => {})

决不要尝试为基本 Error 类型实现 “捕获所有” 处理程序。这将混淆所发生的一切，并损害代码的可维护性和可扩展性。

关键要点

throw 语句用于生成用户定义的异常。在运行时，当 throw 遇到语句时，当前函数的执行将停止，控制权将传递给 catch 调用堆栈中的第一个子句。如果没有 catch 子句，程序将终止

JavaScript 有一些内置的异常类型，最值得注意的是 Error，它返回 Error 中的两个重要属性：stack 和 message。

try 子句将包含可能产生异常的代码，catch 子句会在发生异常时执行。

对于异步代码，最好使用 async/await 配合 try-catch 语句。

可以捕获未处理的异常，这可以防止应用程序崩溃。

不要觉得麻烦，异常处理可以帮助您提高代码的可维护性、可扩展性和可读性。

【相关推荐：javascript视频教程、web前端】

Atas ialah kandungan terperinci Mari analisa kaedah pengendalian pengecualian JavaScript bersama-sama. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!