Kapan. Kemudian (sukses, gagal) dianggap sebagai antipattern untuk janji?

Saya telah melihat FAQ tentang burung bluebird , yang menyebutkan bahwa itu .then(success, fail)adalah antipattern . Saya tidak begitu mengerti penjelasannya tentang mencoba dan menangkap. Apa yang salah dengan yang berikut ini?

some_promise_call()
.then(function(res) { logger.log(res) }, function(err) { logger.log(err) })

Tampaknya contoh ini menyarankan yang berikut ini sebagai cara yang benar.

some_promise_call()
.then(function(res) { logger.log(res) })
.catch(function(err) { logger.log(err) })

Apa bedanya?

Apa bedanya?

The .then()panggilan akan kembali janji yang akan ditolak dalam kasus panggil balik melempar kesalahan. Ini berarti, ketika kesuksesan Anda loggergagal, kesalahan akan diteruskan ke .catch()callback berikut , tetapi tidak ke failcallback yang menyertainya success.

Berikut diagram alir kontrol :

Untuk mengekspresikannya dalam kode sinkron:

// some_promise_call().then(logger.log, logger.log)
then: {
    try {
        var results = some_call();
    } catch(e) {
        logger.log(e);
        break then;
    } // else
        logger.log(results);
}

Yang kedua log(yang seperti argumen pertama .then()) hanya akan dieksekusi jika tidak ada pengecualian yang terjadi. Blok berlabel dan breakpernyataan merasa sedikit aneh, ini sebenarnya apa python memiliki try-except-elseuntuk (membaca direkomendasikan!).

// some_promise_call().then(logger.log).catch(logger.log)
try {
    var results = some_call();
    logger.log(results);
} catch(e) {
    logger.log(e);
}

The catchlogger juga akan menangani pengecualian dari panggilan sukses logger.

Begitu banyak perbedaannya.

Saya tidak begitu mengerti penjelasannya tentang mencoba dan menangkap

Argumennya adalah bahwa biasanya Anda ingin menangkap kesalahan di setiap langkah pemrosesan, dan Anda tidak boleh menggunakannya dalam rantai. Harapannya adalah bahwa Anda hanya memiliki satu penangan akhir yang menangani semua kesalahan - sementara, ketika Anda menggunakan "antipattern", kesalahan dalam beberapa panggilan balik saat itu tidak ditangani.

Namun, pola ini sebenarnya sangat berguna: Ketika Anda ingin menangani kesalahan yang terjadi pada langkah ini, dan Anda ingin melakukan sesuatu yang sama sekali berbeda ketika tidak ada kesalahan terjadi - yaitu ketika kesalahan tidak dapat dipulihkan. Ketahuilah bahwa ini adalah percabangan aliran kendali Anda. Tentu saja, ini kadang diinginkan.

Apa yang salah dengan yang berikut ini?

some_promise_call()
.then(function(res) { logger.log(res) }, function(err) { logger.log(err) })

Bahwa Anda harus mengulangi panggilan balik Anda. Anda lebih suka

some_promise_call()
   .catch(function(e) {
       return e; // it's OK, we'll just log it
   })
   .done(function(res) {
       logger.log(res);
   });

Anda juga dapat mempertimbangkan .finally()untuk menggunakan ini.

Keduanya tidak identik. Perbedaannya adalah bahwa contoh pertama tidak akan menangkap pengecualian yang ada pada successhandler Anda . Jadi, jika metode Anda hanya akan mengembalikan janji yang telah diselesaikan, seperti yang sering terjadi, Anda memerlukan trailing catchhandler (atau yang lainnya thendengan successparameter kosong ). Tentu, mungkin thenhandler Anda tidak melakukan apa pun yang berpotensi gagal, dalam hal ini menggunakan satu 2 parameterthen bisa baik-baik saja.

Tapi saya percaya inti dari teks yang Anda tautkan adalah yang thensebagian besar bermanfaat dibandingkan dengan panggilan balik dalam kemampuannya untuk mengaitkan beberapa langkah asinkron, dan ketika Anda benar-benar melakukan ini, bentuk 2-parameter dari thensubtly tidak berperilaku cukup seperti yang diharapkan , untuk alasan di atas. Ini terutama berlawanan dengan intuisi ketika digunakan rantai tengah.

Sebagai seseorang yang telah melakukan banyak hal async yang kompleks dan menabrak sudut-sudut seperti ini lebih dari yang saya akui, saya sangat merekomendasikan menghindari anti-pola ini dan menggunakan pendekatan penangan yang terpisah.

Dengan melihat kelebihan dan kekurangan dari keduanya, kita dapat membuat perkiraan yang tepat untuk situasi yang tepat. Ini adalah dua pendekatan utama untuk mengimplementasikan janji-janji. Keduanya memiliki kelebihan dan kekurangan

Tangkap Pendekatan

some_promise_call()
.then(function(res) { logger.log(res) })
.catch(function(err) { logger.log(err) })

Keuntungan

1. Semua kesalahan ditangani oleh satu blok tangkapan.
2. Bahkan menangkap pengecualian di blok itu.
3. Rantai beberapa panggilan balik sukses

Kekurangan

1. Dalam kasus chaining menjadi sulit untuk menampilkan pesan kesalahan yang berbeda.

Pendekatan Keberhasilan / Kesalahan

some_promise_call()
.then(function success(res) { logger.log(res) },
      function error(err) { logger.log(err) })

Keuntungan

1. Anda mendapatkan kontrol kesalahan berbutir halus.
2. Anda dapat memiliki fungsi penanganan kesalahan umum untuk berbagai kategori kesalahan seperti kesalahan db, 500 kesalahan dll.

Kerugian

1. Anda masih membutuhkan yang lain catchjika Anda ingin menangani kesalahan yang dilemparkan oleh keberhasilan panggilan balik

Penjelasan sederhana:

Dalam ES2018

Ketika metode catch disebut dengan argumen onRejected, langkah-langkah berikut diambil:

1. Biarkan janji menjadi nilai ini.
2. Kembali? Meminta (janji, "lalu", «tidak terdefinisi, pada Ditolak»).

itu berarti:

promise.then(f1).catch(f2)

sama dengan

promise.then(f1).then(undefiend, f2)

Menggunakan .then().catch()memungkinkan Anda mengaktifkan Promise Chaining yang diperlukan untuk memenuhi alur kerja. Anda mungkin perlu membaca beberapa informasi dari database kemudian Anda ingin meneruskannya ke API async kemudian Anda ingin memanipulasi respons. Anda mungkin ingin mendorong respons kembali ke database. Menangani semua alur kerja ini dengan konsep Anda bisa dilakukan tetapi sangat sulit untuk dikelola. Solusi yang lebih baik adalah then().then().then().then().catch()menerima semua kesalahan hanya dalam sekali penangkapan dan memungkinkan Anda menjaga kelestarian kode.

Menggunakan then()dan catch()membantu rantai kesuksesan dan kegagalan penangan pada janji. catch()bekerja dengan janji dikembalikan oleh then(). Itu menangani,

1. Jika janji ditolak. Lihat # 3 pada gambar
2. Jika kesalahan terjadi pada penangan sukses maka (), antara nomor baris 4 hingga 7 di bawah ini. Lihat # 2.a dalam gambar (Kegagalan panggilan balik then()tidak menangani hal ini.)
3. Jika kesalahan terjadi pada penangan kegagalan maka (), nomor baris 8 di bawah ini. Lihat # 3.b dalam gambar.

1. let promiseRef: Promise = this. aTimetakingTask (false); 2. promiseRef 3. .then( 4. (result) => { 5. /* successfully, resolved promise. 6. Work on data here */ 7. }, 8. (error) => console.log(error) 9. ) 10. .catch( (e) => { 11. /* successfully, resolved promise. 12. Work on data here */ 13. });

Catatan : Sering kali, penangan kegagalan mungkin tidak didefinisikan jika catch()sudah ditulis. EDIT: reject()Hasil di memohon catch()hanya jika penangan kesalahan dalam then()adalah tidak didefinisikan. Perhatikan # 3 pada gambar di sebelah catch(). Itu dipanggil ketika pawang di baris # 8 dan 9 tidak didefinisikan.

Masuk akal karena janji yang dikembalikan oleh then()tidak memiliki kesalahan jika panggilan balik menanganinya.

Alih-alih kata-kata, contoh yang bagus. Kode berikut (jika janji pertama terselesaikan):

Promise.resolve()
.then
(
  () => { throw new Error('Error occurs'); },
  err => console.log('This error is caught:', err)
);

identik dengan:

Promise.resolve()
.catch
(
  err => console.log('This error is caught:', err)
)
.then
(
  () => { throw new Error('Error occurs'); }
)

Tetapi dengan janji pertama yang ditolak, ini tidak identik:

Promise.reject()
.then
(
  () => { throw new Error('Error occurs'); },
  err => console.log('This error is caught:', err)
);

Promise.reject()
.catch
(
  err => console.log('This error is caught:', err)
)
.then
(
  () => { throw new Error('Error occurs'); }
)