Callback berbeda untuk kesalahan atau kesalahan sebagai argumen pertama?

Kami (dan ruang obrolan JS SO) telah berbicara dengan @rlemon beberapa hari yang lalu tentang perpustakaan Little-XHR-nya tentang penanganan kesalahan.

Pada dasarnya, kami ingin memutuskan pola penanganan kesalahan mana yang harus digunakan:

xhr.get({
    // Some parameters, and then
    success: function(data) {},
    failure: function(data) {}
})

Atau:

xhr.get({
    // Some parameters, and then
    callback: function(err, data) {}
})

Satu lebih seperti jQuery, sedangkan yang lainnya lebih seperti Node. Ada yang mengatakan bahwa pola pertama membuat Anda lebih memikirkan penanganan kesalahan. Saya pikir sebaliknya, karena Anda mungkin lupa fungsi panggilan balik lainnya, sementara argumen selalu ada pada pola kedua.

Adakah pendapat / keuntungan / kekurangan tentang kedua pola ini?

Fitur yang sangat penting adalah konsistensi gaya sehingga Anda dapat menulis kode dengan gaya yang sama dan Anda dapat membuat asumsi pemrograman meta tentang bagaimana situasi asinkron ditangani.

Saya pribadi lebih suka

(err, data)karena itu adalah cara standar dalam menangani berbagai hal. Ini memungkinkan untuk komposisi fungsi.

Misalnya after.mapmenggunakan pola ini. Jadi kode suka

after.map(["foo.js", "bar.js"], function (fileName, callback) {
    fs.readFile(fileName, function (err, file) {
        callback(err, file)
    })
}, function (err, files) {
    // handle files
})

dapat disederhanakan menjadi

after.map(["foo.js", "bar.js", fs.readFile, function (err, files) {
    // handle files
})

Keuntungan lain adalah Anda dapat meneruskan panggilan balik sebagai parameter terakhir

asyncOperation(options, function (err, data) {
    // not nested inside an object literal
})

Pendekatan terakhir panggilan balik adalah pendekatan keakraban API yang bagus.

Keuntungan lebih lanjut adalah bahwa Anda dapat dengan mudah lupa untuk mengatur errorpenangan dalam objek literal Anda, atau mengaturnya ke beberapa jenis penangan kesalahan default.

Ketika Anda menggunakannya (err, data)mengingatkan Anda untuk berpikir tentang cara efisien menangani kesalahan ini setiap kali.

Secara umum, saya suka mengingat bahwa eksplisit selalu lebih baik daripada implisit.

Dengan menggunakan ini, saya biasanya berpihak pada fungsi eksplisit successdan failure- Anda tahu persis apa yang Anda hadapi saat Anda membuka kode itu - panggilan sukses menangani yang selesai dengan sukses, sementara kesalahan berurusan dengan panggilan yang memiliki masalah.

Alternatifnya, menggunakan metode tunggal, akan membutuhkan waktu lebih lama untuk membaca ketika Anda mengubah kode itu. Selain itu, Anda mungkin berakhir dengan sesuatu seperti ini;

xhr.get({
    callback: function(err, data) {
        if (err) {
            // handle that error somehow
        }
        else {
            // deal with success somehow
        }
    }
})

Dan boilerplate semacam itu jadi membosankan, cepat.

Belum lagi, jika Anda lupa menambahkan boilerplate ini, dan misalnya, Anda hanya menangani kesuksesan, maka pengembang baru yang memasuki basis kode mungkin tidak melihat ada masalah dengannya. Tetapi memiliki kesalahan eksplisit / keberhasilan callback, mereka akan dapat melihat dengan cepat bahwa Anda kehilangan errorcallback dan mulai bekerja pada cara untuk menanganinya, atau setidaknya mencari tahu "well, ini hanya menangani kesuksesan - saya harus temukan cara untuk menangani kesalahan ". Itu membuat kodenya tampak kurang ajaib.

Pisahkan panggilan balik

Jika xhr.get()panggilan berhasil, maka errmubazir. Jika panggilan gagal. databerlebihan. Daripada memaksakan kode klien untuk memeriksa keadaan satu atau yang lain, jangan melewati keduanya.

Jika ternyata keberhasilan itu bisa mewakili keberhasilan parsial, tunjukkan secara terpisah. Kegagalan biasanya merupakan opsi bail-out.

Saya telah bekerja dengan pengembang yang hanya menangani kasus sukses dan dalam banyak skenario hanya menerapkan panggilan balik yang berhasil sudah cukup dalam kasus ini. Callback multi-negara akan menjadi pilihan bencana bagi gaya pemrograman seperti yang mereka anggap sukses.