เมื่อใดจึงจะถือว่าเป็นปฏิปักษ์ต่อคำสัญญา?

ฉันได้ดูที่สัญญาคำถามที่พบบ่อยนกชนิดหนึ่งในสิ่งที่มันกล่าวว่า.then(success, fail)เป็น antipattern ฉันไม่ค่อยเข้าใจคำอธิบายสำหรับลองและจับ เกิดอะไรขึ้นกับสิ่งต่อไปนี้

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

ดูเหมือนว่าตัวอย่างจะแนะนำสิ่งต่อไปนี้เป็นวิธีที่ถูกต้อง

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

ความแตกต่างคืออะไร?

ความแตกต่างคืออะไร?

การ.then()โทรจะคืนสัญญาที่จะถูกปฏิเสธในกรณีที่การโทรกลับโยนข้อผิดพลาด ซึ่งหมายความว่าเมื่อคุณประสบความสำเร็จloggerล้มเหลวผิดพลาดจะถูกส่งผ่านไปดังต่อไปนี้.catch()การเรียกกลับ แต่ไม่ให้โทรกลับที่จะไปข้างด้วยfailsuccess

นี่คือแผนภาพการควบคุมการไหล :

ในการแสดงมันในรหัสซิงโครนัส:

// 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);
}

ที่สองlog(ซึ่งเป็นเหมือนอาร์กิวเมนต์แรก.then()) จะถูกดำเนินการเฉพาะในกรณีที่ไม่มีข้อยกเว้นเกิดขึ้น บล็อกที่มีป้ายกำกับและbreakคำสั่งรู้สึกแปลก ๆ นี่เป็นสิ่งที่หลามมีtry-except-elseให้ (แนะนำให้อ่าน!)

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

ตัวcatchบันทึกจะจัดการข้อยกเว้นจากการเรียกตัวบันทึกสำเร็จด้วย

มากสำหรับความแตกต่าง

ฉันไม่ค่อยเข้าใจคำอธิบายสำหรับลองและจับ

อาร์กิวเมนต์คือโดยปกติแล้วคุณต้องการตรวจจับข้อผิดพลาดในทุกขั้นตอนของการประมวลผลและคุณไม่ควรใช้มันในกลุ่ม ความคาดหวังคือคุณมีตัวจัดการขั้นสุดท้ายเพียงหนึ่งตัวเท่านั้นที่จัดการข้อผิดพลาดทั้งหมด - ในขณะที่เมื่อคุณใช้ "antipattern" ข้อผิดพลาดในการเรียกกลับบางส่วนนั้นจะไม่ได้รับการจัดการ

อย่างไรก็ตามรูปแบบนี้มีประโยชน์มากจริง ๆ : เมื่อคุณต้องการจัดการข้อผิดพลาดที่เกิดขึ้นในขั้นตอนนี้และคุณต้องการทำสิ่งที่แตกต่างอย่างสิ้นเชิงเมื่อไม่มีข้อผิดพลาดเกิดขึ้น - เช่นเมื่อข้อผิดพลาดไม่สามารถกู้คืนได้ โปรดทราบว่านี่เป็นการแยกการควบคุมของคุณออก แน่นอนว่าบางครั้งเป็นที่ต้องการ

เกิดอะไรขึ้นกับสิ่งต่อไปนี้

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

ว่าคุณต้องโทรกลับซ้ำ คุณค่อนข้างต้องการ

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

คุณอาจพิจารณาใช้.finally()สำหรับสิ่งนี้

ทั้งสองไม่เหมือนกันเลยทีเดียว ความแตกต่างคือตัวอย่างแรกจะไม่รับข้อยกเว้นที่อยู่ในsuccessตัวจัดการของคุณ ดังนั้นหากวิธีการของคุณควรกลับสัญญาที่ได้รับการแก้ไขซึ่งมักจะเป็นกรณีนี้คุณต้องมีcatchตัวจัดการต่อท้าย(หรืออีกวิธีหนึ่งthenด้วยsuccessพารามิเตอร์ว่าง) แน่นอนว่าอาจเป็นไปได้ว่าthenตัวจัดการของคุณไม่ได้ทำสิ่งใดที่อาจเกิดความล้มเหลวซึ่งในกรณีนี้การใช้ 2 พารามิเตอร์หนึ่งตัวthenอาจทำได้ดี

แต่ผมเชื่อว่าจุดข้อความที่คุณเชื่อมโยงกับการเป็นที่thenเป็นประโยชน์ส่วนใหญ่เมื่อเทียบกับการเรียกกลับในความสามารถในห่วงโซ่พวงของขั้นตอนที่ไม่ตรงกันและเมื่อคุณทำจริงในรูปแบบ 2 พารามิเตอร์ของthenอย่างละเอียดไม่ประพฤติค่อนข้างเป็นที่คาดว่า ด้วยเหตุผลข้างต้น มันตอบโต้โดยเฉพาะอย่างยิ่งเมื่อใช้โซ่กลาง

ในขณะที่คนที่ทำสิ่งต่าง ๆ ที่ซับซ้อนแบบอะซิงก์ส์และชนเข้ามุมเช่นนี้มากกว่าที่ฉันจะยอมรับฉันแนะนำให้หลีกเลี่ยงรูปแบบการต่อต้านนี้และดำเนินการตามวิธีการจัดการแยกต่างหาก

โดยการดูข้อดีและข้อเสียของทั้งคู่เราสามารถทำการเดาที่คำนวณได้ว่าเหมาะสมกับสถานการณ์อย่างไร นี่เป็นสองวิธีหลักในการปฏิบัติตามสัญญา ทั้งคู่มีทั้งบวกและลบ

จับวิธีการ

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

ข้อดี

1. ข้อผิดพลาดทั้งหมดได้รับการจัดการโดยหนึ่ง catch block
2. แม้กระทั่งจับข้อยกเว้นใด ๆ ในบล็อกนั้น
3. การผูกมัดการโทรกลับสำเร็จหลายครั้ง

ข้อเสีย

1. ในกรณีของการผูกมัดมันเป็นการยากที่จะแสดงข้อความผิดพลาดที่แตกต่างกัน

วิธีการสำเร็จ / ผิดพลาด

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

ข้อดี

1. คุณได้รับการควบคุมข้อผิดพลาดที่ละเอียด
2. คุณสามารถมีฟังก์ชันการจัดการข้อผิดพลาดทั่วไปสำหรับข้อผิดพลาดประเภทต่าง ๆ เช่นข้อผิดพลาด db, 500 ข้อผิดพลาด ฯลฯ

Disavantages

1. คุณจะยังคงต้องการอีกcatchหากคุณต้องการจัดการข้อผิดพลาดจากการโทรกลับสำเร็จ

คำอธิบายอย่างง่าย:

ใน ES2018

เมื่อเมธอด catch ถูกเรียกด้วยอาร์กิวเมนต์ onRejected จะมีการดำเนินการขั้นตอนต่อไปนี้:

1. ให้สัญญาเป็นค่านี้
2. กลับมา เรียกใช้ (สัญญา "จากนั้น", «ไม่ได้กำหนด, on ถูกปฏิเสธ»)

นั่นหมายความว่า:

promise.then(f1).catch(f2)

เท่ากับ

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

การใช้.then().catch()ช่วยให้คุณเปิดใช้งานการผูกมัดสัญญาซึ่งจำเป็นสำหรับการทำงานตามขั้นตอน คุณอาจต้องอ่านข้อมูลบางอย่างจากฐานข้อมูลจากนั้นคุณต้องการส่งผ่านไปยัง async API จากนั้นคุณต้องการจัดการการตอบสนอง คุณอาจต้องการที่จะผลักดันการตอบสนองกลับเข้าไปในฐานข้อมูล การจัดการเวิร์กโฟลว์เหล่านี้ทั้งหมดด้วยแนวคิดของคุณนั้นสามารถทำได้ แต่จัดการยากมาก ทางออกที่ดีกว่าคือการที่จะได้then().then().then().then().catch()รับข้อผิดพลาดทั้งหมดในการตรวจจับครั้งเดียวและช่วยให้คุณสามารถรักษารหัสไว้ได้

การใช้then()และcatch()ช่วยให้ประสบความสำเร็จในการจัดการความล้มเหลว ทำงานบนสัญญาส่งกลับโดยcatch() then()มันจัดการ

1. หากสัญญาถูกปฏิเสธ ดู # 3 ในภาพ
2. หากเกิดข้อผิดพลาดในตัวจัดการความสำเร็จของ then () ระหว่างหมายเลขบรรทัด 4 ถึง 7 ด้านล่าง ดู # 2.a ในภาพ (ความล้มเหลวในการโทรกลับthen()ไม่ได้จัดการสิ่งนี้)
3. หากเกิดข้อผิดพลาดในตัวจัดการความล้มเหลวของ then () ให้หมายเลขบรรทัด 8 ด้านล่าง ดู # 3.b ในภาพ

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. });

หมายเหตุ : หลายครั้งตัวจัดการความล้มเหลวอาจไม่ได้กำหนดถ้าcatch()เขียนไว้แล้ว แก้ไข: reject()ส่งผลในการเรียกใช้catch()เฉพาะในกรณีที่ผิดพลาดในการจัดการthen()จะไม่ได้กำหนดไว้ แจ้งให้ทราบcatch()ล่วงหน้า# 3 ในภาพเพื่อ มันถูกเรียกใช้เมื่อตัวจัดการในบรรทัด # 8 และ 9 ไม่ได้ถูกกำหนดไว้

มันสมเหตุสมผลเนื่องจากสัญญาที่ส่งคืนโดยthen()ไม่มีข้อผิดพลาดหากมีการติดต่อกลับ

แทนที่จะเป็นคำพูดเป็นตัวอย่างที่ดี รหัสต่อไปนี้ (หากสัญญาแรกได้รับการแก้ไข):

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

เหมือนกับ:

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

แต่ด้วยการปฏิเสธสัญญาแรกสิ่งนี้ไม่เหมือนกัน:

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'); }
)