coba-tangkap dalam javascript ... bukankah itu praktik yang baik?

Ada ketentuan untuk blok try-catch dalam javascript . Sementara di java atau bahasa lain itu wajib untuk memiliki penanganan kesalahan, saya tidak melihat siapa pun menggunakannya dalam javascript untuk tingkat yang lebih besar. Bukankah ini praktik yang baik atau kita tidak membutuhkannya dalam javascript?

Orang harus menghindari throwkesalahan sebagai cara untuk melewati kondisi kesalahan di dalam aplikasi.

The throwpernyataan seharusnya hanya digunakan "Untuk ini seharusnya tidak pernah terjadi, kecelakaan dan terbakar. Jangan pulih elegan dengan cara apapun"

try catch Namun digunakan dalam situasi di mana objek host atau ECMAScript dapat melempar kesalahan.

Contoh:

var json
try {
    json = JSON.parse(input)
} catch (e) {
    // invalid json input, set to null
    json = null
}

Rekomendasi dalam komunitas node.js adalah agar Anda meneruskan kesalahan dalam panggilan balik (Karena kesalahan hanya terjadi untuk operasi asinkron) sebagai argumen pertama

fs.readFile(uri, function (err, fileData) {
    if (err) {
        // handle
        // A. give the error to someone else
        return callback(err)
        // B. recover logic
        return recoverElegantly(err)
        // C. Crash and burn
        throw err
    }
    // success case, handle nicely
})

Ada juga masalah lain seperti try / catch yang sangat mahal dan jelek dan tidak bekerja dengan operasi asinkron.

Jadi karena operasi sinkron tidak boleh melempar kesalahan dan tidak bekerja dengan operasi asinkron, tidak ada yang menggunakan try catch kecuali untuk kesalahan yang dilemparkan oleh objek host atau ECMAScript

Coba / tangkap dalam Javascript tidak semudah peluru di bahasa lain, karena sifat asinkron Javascript. Pertimbangkan cuplikan ini:

try {
    setTimeout(function() {
        do_something_that_throws();
    }, 1000);
}
catch (e) {
    alert("You won't see this!");
}

Masalahnya adalah bahwa aliran kontrol meninggalkan tryblok sebelum do_something_that_throws()dieksekusi, sehingga kesalahan yang dilemparkan ke dalam callback tidak pernah tertangkap.

Jadi coba / tangkap pada dasarnya tidak sesuai dalam banyak kasus, dan tidak selalu jelas apakah sesuatu mengeksekusi kode secara tidak sinkron atau tidak. Untungnya, javascript dengan idiom single-threaded-asynchronous-callback yang aneh dan dukungannya untuk penutupan aktual memberikan alternatif yang elegan: penanganan kesalahan gaya kelanjutan-lewat. Cukup berikan respons yang tepat untuk kesalahan apa pun sebagai fungsi, misalnya:

setTimeout(function () {
    do_something_that_calls_err(function(err) {
        alert("Something went wrong, namely this: " + err);
    }),
    1000);

Banyak dari jawaban ini agak lama dan tidak memperhitungkan fitur ES7 baru asyncdan await.

Menggunakan async/ awaitAnda sekarang bisa mendapatkan aliran kontrol asinkron seperti yang Anda inginkan:

async function email(address) {
  try {
    // Do something asynchronous that may throw...
    await sendEmail({ to: address, from: 'noreply@domain.com`, subject: 'Hello' })
  } catch(err) {
    if (err instanceof SomeCustomError) {
      elegantlyHandleError(err)
    } else {
      throw err
    } 
  }
})

Pelajari lebih lanjut tentang async/ di awaitsini . Anda dapat menggunakan async/ awaitsekarang menggunakan babel .

try-catch dalam javascript sama valid dan bermanfaatnya dengan bahasa lain yang mengimplementasikannya. Ada satu alasan utama mengapa tidak banyak digunakan dalam javascript seperti dalam bahasa lain. Itu alasan yang sama javascript dilihat sebagai bahasa skrip yang jelek, itu alasan yang sama mengapa orang berpikir programmer javascript bukan programmer nyata:

• Javascript adalah bahasa yang sangat mudah diakses dan meresap

Fakta bahwa begitu banyak orang terkena javascript (berdasarkan satu-satunya bahasa yang didukung oleh browser) berarti Anda memiliki banyak kode tidak profesional di luar sana. Tentu saja ada juga banyak alasan kecil:

• beberapa hal dalam javascript asinkron dan karenanya tidak catchdapat (asinkron)
• ada banyak pembicaraan berlebihan tentang bagaimana try-catch memiliki kinerja yang luar biasa. Ini memiliki sedikit hit kinerja , tetapi untuk sebagian besar kode, itu sangat berharga.
• javascript (sayangnya) diimplementasikan dengan cara yang sering mengabaikan kesalahan secara diam-diam (misalnya mengubah string ke angka secara otomatis)

Apapun, try-catch harus digunakan, tetapi tentu saja Anda harus belajar bagaimana menggunakannya dengan benar - seperti yang lainnya dalam pemrograman.

Saya percaya bahwa banyak alasan yang try..catchjarang ada dalam JavaScript adalah karena bahasa tersebut memiliki toleransi yang cukup tinggi untuk kesalahan. Sebagian besar situasi dapat ditangani dengan menggunakan pemeriksaan kode, default yang baik, dan peristiwa asinkron. Dalam beberapa kasus, hanya menggunakan pola akan mencegah masalah:

function Foo() {
    //this may or may not be called as a constructor!!
    //could accidentally overwrite properties on window
}

function Bar() {
    if (!(this instanceof Bar)) {
        return new Bar();
    }
    //this will only work on Bar objects, and wont impact window
}

Beberapa masalah utama dalam bahasa lain yang menyebabkan pengecualian hanya tidak ada di JS. Pengecoran tipe tidak diperlukan sebagian besar waktu. Alih-alih, metode yang lebih disukai biasanya untuk memeriksa fitur (menjalankan antarmuka tertentu):

function doFoo(arg) {
    if (arg.foo) {
        arg.foo();
    } else {
        Bar.prototype.foo.call(arg);
    }
}

Dengan penambahan async/ awaitke bahasa, try..catchmenjadi lebih lazim. Menjanjikan sebagai bentuk asinkron try..catch, masuk akal bahwa seseorang harus mengharapkan:

doSomething().then(
  doSomethingWithResult,
  doSomethingWithError
)

alih-alih ditulis sebagai:

try {
  const result = await doSomething()
  doSomethingWithResult(result)
} catch (e) {
  doSomethingWithError(e)
}

Mungkin alasan lain mencoba / menangkap tidak banyak digunakan dalam Javascript adalah konstruk tidak tersedia dalam versi pertama Javascript ... ditambahkan kemudian.

Akibatnya, beberapa browser lama tidak mendukungnya. (Faktanya, ini dapat menyebabkan kesalahan parser / sintaksis di beberapa browser lama, sesuatu yang lebih sulit untuk "diprogram secara defensif" dibandingkan dengan kebanyakan jenis kesalahan lainnya.)

Lebih penting lagi, karena awalnya tidak tersedia, fungsi built-in Javascript yang awalnya dirilis (apa yang disebut fungsi "perpustakaan" dalam banyak bahasa) tidak memanfaatkannya. (Tidak berfungsi dengan baik untuk "menangkap" kesalahan dari someobject.somefunction () jika tidak "melempar" tetapi sebaliknya hanya mengembalikan "null" ketika mengalami masalah.)

Namun alasan lain yang mungkin adalah mekanisme coba / tangkap tampaknya tidak diperlukan pada awalnya (dan masih tampak tidak terlalu berguna). Ini benar-benar diperlukan hanya ketika panggilan secara rutin bersarang beberapa level; hanya mengembalikan semacam ERRNO akan berfungsi dengan baik untuk panggilan langsung (walaupun untuk membuatnya sangat berguna kapan pun itu tersedia, praktik terbaik dalam kebanyakan bahasa adalah menggunakannya di mana - mana daripada hanya pada panggilan yang sangat bersarang). Karena logika Javascript pada awalnya diharapkan kecil dan sederhana (setelah semua, itu hanya tambahan untuk halaman web :-), panggilan fungsi tidak diharapkan untuk bersarang secara mendalam, dan mekanisme mencoba / menangkap sepertinya tidak diperlukan.

Saya percaya mereka tidak banyak digunakan karena melemparkan pengecualian dalam kode sisi klien Javascript membuatnya lebih sulit untuk men-debug halaman.

Daripada melemparkan pengecualian, saya biasanya lebih suka menampilkan kotak al alert, (yaitu alert("Error, invalid...");)

Ini mungkin terdengar aneh, tetapi kesalahan Javascript terjadi di sisi klien, jika pelanggan menggunakan halaman yang Anda buat dan halaman melempar pengecualian, kecuali jika pelanggan adalah seorang tech-savvy-coder tidak ada cara dia akan pernah bisa memberitahu apa masalahnya.

Dia hanya akan memanggil Anda dengan mengatakan: "Hei, halaman X tidak bekerja!", Dan kemudian terserah kepada Anda untuk menemukan apa yang salah dan di mana dalam kode.

Dengan menggunakan kotak peringatan sebagai gantinya, lebih mungkin dia menelepon dan mengatakan sesuatu seperti: "Hei, ketika saya mengklik tombol A halaman X itu menunjukkan kotak yang mengatakan ..." , percayalah, akan lebih mudah untuk menemukan serangga.