เหตุใดการจัดการข้อยกเว้นจึงไม่ดี

ภาษา Go ของ Google ไม่มีข้อยกเว้นเป็นตัวเลือกในการออกแบบและ Linus of Linux ชื่อเสียงเรียกว่าข้อยกเว้น ทำไม?

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

ลองพิจารณาสิ่งนี้เป็นตัวอย่างง่ายๆ:

class Frobber
{
    int m_NumberOfFrobs;
    FrobManager m_FrobManager;

public:
    void Frob()
    {
        m_NumberOfFrobs++;

        m_FrobManager.HandleFrob(new FrobObject());
    }
};

สมมติว่าFrobManagerจะนี้รูปลักษณ์ที่ตกลงใช่มั้ย? หรืออาจจะไม่ ... ลองนึกดูว่าถ้าอย่างใดอย่างหนึ่งหรือมีข้อยกเว้น ในตัวอย่างนี้การเพิ่มขึ้นของจะไม่ย้อนกลับ ดังนั้นใครก็ตามที่ใช้อินสแตนซ์นี้จะมีวัตถุที่เสียหายdeleteFrobObjectFrobManager::HandleFrob()operator newm_NumberOfFrobsFrobber

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

ตัวอย่างเช่นคุณสามารถคิดเช่นคุณคิดว่า mutexes ในส่วนที่สำคัญคุณต้องอาศัยคำสั่งต่างๆเพื่อให้แน่ใจว่าโครงสร้างข้อมูลจะไม่เสียหายและเธรดอื่น ๆ ไม่สามารถมองเห็นค่ากลางของคุณได้ หากข้อความใดข้อความหนึ่งไม่ดำเนินไปแบบสุ่มคุณจะต้องอยู่ในโลกแห่งความเจ็บปวด ตอนนี้นำการล็อกและการทำงานพร้อมกันออกไปและคิดเกี่ยวกับแต่ละวิธีเช่นนั้น คิดว่าแต่ละวิธีเป็นธุรกรรมของการเรียงสับเปลี่ยนสถานะวัตถุถ้าคุณต้องการ เมื่อเริ่มต้นการเรียกใช้เมธอดของคุณวัตถุควรอยู่ในสถานะสะอาดและในตอนท้ายควรมีสถานะที่สะอาดด้วย ในระหว่างนี้ตัวแปรfooอาจไม่สอดคล้องกับbarแต่ในที่สุดโค้ดของคุณจะแก้ไขได้ ข้อยกเว้นหมายความว่าข้อความใด ๆ ของคุณสามารถขัดจังหวะคุณได้ตลอดเวลา ความรับผิดชอบอยู่ที่คุณในแต่ละวิธีเพื่อทำให้ถูกต้องและย้อนกลับเมื่อเกิดเหตุการณ์นั้นขึ้นหรือสั่งการดำเนินการของคุณดังนั้นการพ่นจะไม่ส่งผลต่อสถานะวัตถุ หากคุณเข้าใจผิด (และง่ายต่อการทำผิดประเภทนี้) ผู้โทรจะเห็นค่ากลางของคุณ

วิธีการเช่น RAII ซึ่งโปรแกรมเมอร์ C ++ ชอบพูดถึงว่าเป็นวิธีแก้ปัญหาที่ดีที่สุดในการป้องกันปัญหานี้ แต่มันไม่ใช่กระสุนเงิน จะช่วยให้แน่ใจว่าคุณได้ปล่อยทรัพยากรในทันที แต่ไม่ได้ทำให้คุณไม่ต้องคิดเกี่ยวกับความเสียหายของสถานะวัตถุและผู้โทรเห็นค่ากลาง ดังนั้นสำหรับคนจำนวนมากก็ง่ายที่จะพูดโดย fiat ของการเข้ารหัสรูปแบบไม่มีข้อยกเว้น หากคุณ จำกัด ประเภทของโค้ดที่คุณเขียนการแนะนำจุดบกพร่องเหล่านี้ทำได้ยากขึ้น ถ้าคุณไม่ทำมันก็ค่อนข้างง่ายที่จะทำผิด

หนังสือทั้งเล่มเขียนเกี่ยวกับการเข้ารหัสที่ปลอดภัยใน C ++ ผู้เชี่ยวชาญหลายคนเข้าใจผิด ถ้ามันซับซ้อนและมีความแตกต่างมากมายนั่นอาจเป็นสัญญาณที่ดีที่คุณต้องเพิกเฉยต่อคุณสมบัตินั้น :-)

เหตุผลที่ Go ไม่มีข้อยกเว้นอธิบายไว้ในคำถามที่พบบ่อยเกี่ยวกับการออกแบบภาษา Go:

ข้อยกเว้นเป็นเรื่องราวที่คล้ายกัน มีการเสนอแบบจำลองสำหรับข้อยกเว้นจำนวนมาก แต่แต่ละแบบจะเพิ่มความซับซ้อนให้กับภาษาและเวลาทำงาน โดยธรรมชาติของพวกเขาข้อยกเว้นช่วงการทำงานและบางทีแม้แต่ goroutines พวกเขามีผลกระทบมากมาย นอกจากนี้ยังมีความกังวลเกี่ยวกับผลกระทบที่จะมีต่อห้องสมุด ตามคำจำกัดความแล้วยังมีประสบการณ์ที่ยอดเยี่ยมกับภาษาอื่น ๆ ที่สนับสนุนแสดงว่ามีผลอย่างมากต่อข้อกำหนดของไลบรารีและอินเตอร์เฟส คงจะดีไม่น้อยหากพบการออกแบบที่ช่วยให้พวกเขามีความพิเศษอย่างแท้จริงโดยไม่ต้องกระตุ้นให้ข้อผิดพลาดทั่วไปกลายเป็นขั้นตอนการควบคุมพิเศษที่ต้องให้โปรแกรมเมอร์ทุกคนชดเชย

เช่นเดียวกับยาชื่อสามัญข้อยกเว้นยังคงเป็นปัญหาที่เปิดเผย

กล่าวอีกนัยหนึ่งก็คือพวกเขายังไม่ได้หาวิธีรองรับข้อยกเว้นใน Go ในแบบที่พวกเขาคิดว่าน่าพอใจ พวกเขาไม่ได้บอกว่าข้อยกเว้นนั้นไม่ดีต่อตัวเอง

อัพเดท - พ.ค. 2555

ตอนนี้นักออกแบบ Go ได้ปีนลงจากรั้วแล้ว คำถามที่พบบ่อยของพวกเขาตอนนี้กล่าวว่า:

เราเชื่อว่าข้อยกเว้นการมีเพศสัมพันธ์กับโครงสร้างการควบคุมเช่นเดียวกับในสำนวน try-catch-ในที่สุดส่งผลให้เกิดรหัสที่ซับซ้อน นอกจากนี้ยังมีแนวโน้มที่จะสนับสนุนให้โปรแกรมเมอร์ติดป้ายกำกับข้อผิดพลาดทั่วไปมากเกินไปเช่นไม่สามารถเปิดไฟล์ได้เป็นพิเศษ

Go ใช้แนวทางที่แตกต่างออกไป สำหรับการจัดการข้อผิดพลาดธรรมดาการส่งคืนหลายค่าของ Go ทำให้ง่ายต่อการรายงานข้อผิดพลาดโดยไม่ต้องส่งคืนค่ามากเกินไป ประเภทข้อผิดพลาดที่ยอมรับร่วมกับคุณสมบัติอื่น ๆ ของ Go ทำให้การจัดการข้อผิดพลาดน่าพอใจ แต่ค่อนข้างแตกต่างจากในภาษาอื่น ๆ

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

ดูบทความ Defer, Panic และ Recover สำหรับรายละเอียด

ดังนั้นคำตอบสั้น ๆ ก็คือพวกเขาสามารถทำได้แตกต่างกันโดยใช้การคืนค่าหลายค่า (และพวกเขาก็มีรูปแบบของการจัดการข้อยกเว้นอยู่ดี)

... และ Linus แห่งชื่อเสียงของ Linux เรียกข้อยกเว้นว่าอึ

หากคุณต้องการทราบว่าเหตุใด Linus จึงคิดว่าข้อยกเว้นเป็นเรื่องไร้สาระสิ่งที่ดีที่สุดคือมองหางานเขียนของเขาในหัวข้อนี้ สิ่งเดียวที่ฉันติดตามจนถึงตอนนี้คือคำพูดนี้ที่ฝังอยู่ในอีเมลสองสามฉบับใน C ++ :

"สิ่งที่จัดการข้อยกเว้น C ++ ทั้งหมดเสียโดยพื้นฐานโดยเฉพาะอย่างยิ่งสำหรับเมล็ดพืช"

คุณจะทราบว่าเขากำลังพูดถึงข้อยกเว้นของ C ++ โดยเฉพาะไม่ใช่ข้อยกเว้นโดยทั่วไป (และข้อยกเว้น C ++ ทำเห็นได้ชัดว่ามีปัญหาบางอย่างที่ทำให้พวกเขาที่ยุ่งยากในการใช้งานได้อย่างถูกต้อง.)

ข้อสรุปของฉันคือ Linus ไม่ได้เรียกข้อยกเว้น (โดยทั่วไป) ว่า "อึ" เลย!

ข้อยกเว้นไม่ใช่เรื่องเลวร้าย แต่ถ้าคุณรู้ว่ามันจะเกิดขึ้นมากมายมันอาจมีราคาแพงในแง่ของประสิทธิภาพ

หลักทั่วไปคือข้อยกเว้นควรตั้งค่าสถานะเงื่อนไขพิเศษและคุณไม่ควรใช้เพื่อควบคุมผังงานโปรแกรม

ฉันไม่เห็นด้วยกับ "โยนข้อยกเว้นในสถานการณ์พิเศษเท่านั้น" แม้ว่าโดยทั่วไปจะเป็นความจริง แต่ก็ทำให้เข้าใจผิด ข้อยกเว้นสำหรับข้อผิดพลาดเงื่อนไข (การดำเนินการล้มเหลว)

ไม่ว่าคุณจะใช้ภาษาใดให้เลือกสำเนาของFramework Design Guidelines : Conventions, Idioms, and Patterns for Reusable .NET Libraries (2nd Edition) บทที่ว่าด้วยการโยนข้อยกเว้นจะไม่มีเพื่อน คำพูดบางส่วนจากฉบับพิมพ์ครั้งแรก (ฉบับที่ 2 ในที่ทำงานของฉัน):

• อย่าส่งคืนรหัสข้อผิดพลาด
• รหัสข้อผิดพลาดสามารถละเลยได้ง่ายและมักจะเป็น
• ข้อยกเว้นเป็นวิธีหลักในการรายงานข้อผิดพลาดในกรอบงาน
• หลักการง่ายๆก็คือถ้าวิธีการไม่ทำตามที่ชื่อของมันแนะนำควรถือว่าเป็นความล้มเหลวในระดับวิธีการซึ่งส่งผลให้เกิดข้อยกเว้น
• อย่าใช้ข้อยกเว้นสำหรับขั้นตอนการควบคุมปกติถ้าเป็นไปได้

มีหน้าหมายเหตุเกี่ยวกับประโยชน์ของข้อยกเว้น (ความสอดคล้องของ API, การเลือกตำแหน่งของรหัสการจัดการข้อผิดพลาด, ความทนทานที่ดีขึ้น ฯลฯ ) มีส่วนเกี่ยวกับประสิทธิภาพที่มีหลายรูปแบบ (Tester-Doer, Try-Parse)

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

จากมุมมองของ golang ฉันเดาว่าไม่มีการจัดการข้อยกเว้นทำให้กระบวนการรวบรวมง่ายและปลอดภัย

จากมุมมองของ Linus ฉันเข้าใจว่ารหัสเคอร์เนลนั้นเกี่ยวกับกรณีมุม ดังนั้นจึงสมเหตุสมผลที่จะปฏิเสธข้อยกเว้น

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

ตัวอย่างเช่นใช้ได้ดีในโค้ดระดับสูงส่วนใหญ่ที่ผู้ใช้หันหน้าเข้าหาเช่นโค้ดแอปพลิเคชันบนเว็บและเดสก์ท็อป

ข้อยกเว้นในตัวมันเองไม่ได้ "เลว" แต่เป็นวิธีที่บางครั้งมีการจัดการข้อยกเว้นที่มีแนวโน้มที่จะไม่ดี มีแนวทางหลายประการที่สามารถนำไปใช้ในการจัดการข้อยกเว้นเพื่อช่วยบรรเทาปัญหาเหล่านี้ได้ บางส่วน ได้แก่ (แต่ไม่ จำกัด เฉพาะ):

1. อย่าใช้ข้อยกเว้นในการควบคุมโฟลว์โปรแกรมนั่นคืออย่าพึ่งพาคำสั่ง "catch" เพื่อเปลี่ยนโฟลว์ของตรรกะ สิ่งนี้ไม่เพียง แต่จะซ่อนรายละเอียดต่างๆรอบ ๆ ตรรกะเท่านั้น แต่ยังสามารถนำไปสู่ประสิทธิภาพที่ไม่ดีได้อีกด้วย
2. อย่าโยนข้อยกเว้นจากภายในฟังก์ชันเมื่อ "สถานะ" ที่ส่งคืนจะมีความหมายมากขึ้นให้โยนข้อยกเว้นในสถานการณ์พิเศษเท่านั้น การสร้างข้อยกเว้นเป็นการดำเนินการที่มีราคาแพงและต้องใช้ประสิทธิภาพสูง ตัวอย่างเช่นหากคุณเรียกใช้เมธอดเพื่อเปิดไฟล์และไฟล์นั้นไม่มีอยู่ให้โยนข้อยกเว้น "FileNotFound" หากคุณเรียกใช้เมธอดที่กำหนดว่ามีบัญชีลูกค้าหรือไม่ให้ส่งคืนค่าบูลีนอย่าส่งคืนข้อยกเว้น "CustomerNotFound"
3. เมื่อพิจารณาว่าจะจัดการกับข้อยกเว้นหรือไม่อย่าใช้ประโยค "try ... catch" เว้นแต่คุณจะทำสิ่งที่เป็นประโยชน์ได้โดยมีข้อยกเว้น หากคุณไม่สามารถจัดการกับข้อยกเว้นได้คุณควรปล่อยให้เกิดฟองในกลุ่มการโทร มิฉะนั้นตัวจัดการอาจ "กลืน" ข้อยกเว้นและรายละเอียดจะสูญหายไป (เว้นแต่คุณจะเปลี่ยนข้อยกเว้นใหม่)

อาร์กิวเมนต์ทั่วไปคือไม่มีทางที่จะบอกได้ว่าข้อยกเว้นใดบ้างที่จะออกมาจากโค้ดบางส่วน (ขึ้นอยู่กับภาษา) และมีลักษณะคล้ายกับgotos มากเกินไปทำให้ยากต่อการติดตามการดำเนินการทางจิตใจ

http://www.joelonsoftware.com/items/2003/10/13.html

ไม่มีความเห็นพ้องต้องกันในประเด็นนี้อย่างแน่นอน ฉันจะบอกว่าจากมุมมองของโปรแกรมเมอร์ C ระดับฮาร์ดคอร์อย่าง Linus ข้อยกเว้นเป็นความคิดที่ไม่ดีอย่างแน่นอน โปรแกรมเมอร์ Java ทั่วไปอยู่ในสถานการณ์ที่แตกต่างกันอย่างมาก

ข้อยกเว้นไม่เลว เข้ากันได้ดีกับโมเดล RAII ของ C ++ ซึ่งเป็นสิ่งที่สวยงามที่สุดเกี่ยวกับ C ++ หากคุณมีรหัสจำนวนมากอยู่แล้วก็ไม่ปลอดภัยข้อยกเว้นแสดงว่าไม่ดีในบริบทนั้น หากคุณกำลังเขียนซอฟต์แวร์ระดับต่ำเช่น linux OS แสดงว่าไม่ดี หากคุณชอบทิ้งรหัสของคุณด้วยการตรวจสอบการส่งคืนข้อผิดพลาดจำนวนมากแสดงว่าไม่เป็นประโยชน์ หากคุณไม่มีแผนสำหรับการควบคุมทรัพยากรเมื่อเกิดข้อยกเว้น (ที่ตัวทำลาย C ++ มีให้) แสดงว่าไม่ดี

กรณีการใช้งานที่ดีสำหรับข้อยกเว้นคือ ....

สมมติว่าคุณอยู่ในโปรเจ็กต์และคอนโทรลเลอร์ทุกตัว (ประมาณ 20 ตัวควบคุมหลักที่แตกต่างกัน) ขยายคอนโทรลเลอร์ซูเปอร์คลาสตัวเดียวด้วยวิธีการดำเนินการ จากนั้นคอนโทรลเลอร์ทุกตัวจะทำสิ่งต่าง ๆ ที่แตกต่างจากกันที่เรียกอ็อบเจ็กต์ B, C, D ในกรณีเดียวและ F, G, D ในอีกกรณีหนึ่ง มีข้อยกเว้นในการช่วยเหลือที่นี่ในหลาย ๆ กรณีที่มีรหัสส่งคืนจำนวนมากและตัวควบคุมทุกตัวก็จัดการแตกต่างกัน ฉันตีรหัสทั้งหมดนั้นโยนข้อยกเว้นที่เหมาะสมจาก "D" จับมันในวิธีการดำเนินการของตัวควบคุมระดับสูงและตอนนี้ตัวควบคุมทั้งหมดของเราสอดคล้องกัน ก่อนหน้านี้ D ส่งคืนค่าว่างสำหรับกรณีข้อผิดพลาดที่แตกต่างกันหลายกรณีที่เราต้องการบอกผู้ใช้ปลายทาง แต่ทำไม่ได้และฉันไม่ได้ '

ใช่เราต้องกังวลเกี่ยวกับแต่ละระดับและการล้าง / การรั่วไหลของทรัพยากรใด ๆ แต่โดยทั่วไปแล้วตัวควบคุมของเราไม่มีทรัพยากรใดที่จะทำความสะอาดหลังจากนั้น

ขอบคุณพระเจ้าที่เรามีข้อยกเว้นไม่เช่นนั้นฉันจะได้รับการปรับเปลี่ยนขนาดใหญ่และเสียเวลามากเกินไปกับบางสิ่งที่น่าจะเป็นปัญหาการเขียนโปรแกรมง่ายๆ

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

แต่ความเป็นจริงก็เป็นอีกเรื่องหนึ่ง เรามักมีสถานการณ์ที่ "คาดไม่ถึง" เสมอ นี่คือเหตุผลที่เราต้องการข้อยกเว้น

ฉันคิดว่าเราสามารถนึกถึงข้อยกเว้นของน้ำตาลไวยากรณ์สำหรับ ExceptionSituationObserver คุณเพิ่งได้รับการแจ้งเตือนข้อยกเว้น ไม่มีอะไรมาก.

ด้วย Go ฉันคิดว่าพวกเขาจะแนะนำบางสิ่งที่จะรับมือกับสถานการณ์ที่ "ไม่คาดคิด" ฉันเดาได้ว่าพวกเขาจะพยายามทำให้มันฟังดูเป็นการทำลายล้างน้อยลงเป็นข้อยกเว้นและอื่น ๆ ตามตรรกะของแอปพลิเคชัน แต่นี่เป็นเพียงการคาดเดาของฉัน

กระบวนทัศน์การจัดการข้อยกเว้นของ C ++ ซึ่งเป็นพื้นฐานบางส่วนสำหรับ Java นั้นและในทางกลับกัน. net ก็แนะนำแนวคิดที่ดีบางประการ แต่ก็มีข้อ จำกัด ที่รุนแรงเช่นกัน ความตั้งใจในการออกแบบที่สำคัญประการหนึ่งของการจัดการข้อยกเว้นคือการอนุญาตให้ใช้วิธีการต่างๆเพื่อให้แน่ใจว่าพวกเขาจะตอบสนองเงื่อนไขหลังการใช้งานหรือยกเลิกข้อยกเว้นและตรวจสอบให้แน่ใจว่าการล้างข้อมูลใด ๆ ที่จำเป็นต้องเกิดขึ้นก่อนที่เมธอดจะสามารถออกได้จะเกิดขึ้น น่าเสียดายที่กระบวนทัศน์การจัดการข้อยกเว้นของ C ++, Java และ. net ทั้งหมดไม่สามารถให้วิธีการที่ดีในการจัดการสถานการณ์ที่ปัจจัยที่ไม่คาดคิดขัดขวางไม่ให้ดำเนินการล้างข้อมูลที่คาดไว้ ในทางกลับกันหมายความว่าเราต้องเสี่ยงที่ทุกอย่างจะหยุดชะงักหากมีสิ่งที่ไม่คาดคิดเกิดขึ้น (วิธีการ C ++ ในการจัดการข้อยกเว้นเกิดขึ้นระหว่างการคลายสแต็ก)

แม้ว่าโดยทั่วไปการจัดการข้อยกเว้นจะเป็นเรื่องที่ดี แต่ก็ไม่สมเหตุสมผลที่จะถือว่ากระบวนทัศน์การจัดการข้อยกเว้นที่ไม่สามารถยอมรับได้ซึ่งไม่สามารถให้วิธีการที่ดีในการจัดการปัญหาที่เกิดขึ้นเมื่อทำความสะอาดหลังจากปัญหาอื่น ๆ นั่นไม่ได้หมายความว่าเฟรมเวิร์กไม่สามารถออกแบบด้วยกระบวนทัศน์การจัดการข้อยกเว้นที่สามารถทำให้มั่นใจได้ถึงพฤติกรรมที่สมเหตุสมผลแม้ในสถานการณ์ที่เกิดความล้มเหลวหลายครั้ง แต่ไม่มีภาษาหรือเฟรมเวิร์กยอดนิยมเท่าที่จะทำได้

ฉันไม่ได้อ่านคำตอบอื่น ๆ ทั้งหมดดังนั้นจึงมีการกล่าวถึงสิ่งนี้แล้ว แต่คำวิจารณ์อย่างหนึ่งคือพวกเขาทำให้โปรแกรมแตกเป็นเครือยาวทำให้ยากต่อการติดตามข้อผิดพลาดเมื่อทำการดีบักโค้ด ตัวอย่างเช่นถ้า Foo () เรียก Bar () ซึ่งเรียก Wah () ซึ่งเรียก ToString () จากนั้นดันข้อมูลผิดไปยัง ToString () โดยไม่ได้ตั้งใจจะดูเหมือนข้อผิดพลาดใน Foo () ซึ่งเป็นฟังก์ชันที่ไม่เกี่ยวข้องกันเกือบทั้งหมด

• โดยทั่วไปข้อยกเว้นที่ไม่ได้รับการจัดการนั้นไม่ดี
• จัดการข้อยกเว้นไม่ดีไม่ดี (แน่นอน)
• 'ความดี / ความเลว' ของการจัดการข้อยกเว้นขึ้นอยู่กับบริบท / ขอบเขตและความเหมาะสมไม่ใช่เพื่อประโยชน์ในการทำ

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

สำหรับการส่งสัญญาณข้อผิดพลาดโดยทั่วไปฉันชอบสัญญาณข้อผิดพลาด ทั้งหมดขึ้นอยู่กับ API กรณีการใช้งานและความรุนแรงหรือหากการบันทึกเพียงพอ นอกจากนี้ฉันกำลังพยายามกำหนดพฤติกรรมใหม่throw Phonebooks()แทน แนวคิดที่ว่า "ข้อยกเว้น" มักจะเป็นทางตัน แต่ "สมุดโทรศัพท์" มีข้อมูลที่เป็นประโยชน์เกี่ยวกับการกู้คืนข้อผิดพลาดหรือเส้นทางการดำเนินการทางเลือกอื่น (ยังไม่พบกรณีการใช้งานที่ดี แต่พยายามต่อไป)

สำหรับฉันปัญหานั้นง่ายมาก โปรแกรมเมอร์หลายคนใช้ตัวจัดการข้อยกเว้นอย่างไม่เหมาะสม แหล่งข้อมูลภาษาเพิ่มเติมดีกว่า สามารถจัดการกับข้อยกเว้นได้ดี ตัวอย่างหนึ่งของการใช้งานที่ไม่ดีคือค่าที่ต้องเป็นจำนวนเต็มไม่ได้รับการตรวจสอบหรืออินพุตอื่นที่อาจหารและไม่ได้รับการตรวจสอบการหารศูนย์ ... การจัดการข้อยกเว้นอาจเป็นวิธีที่ง่ายในการหลีกเลี่ยงการทำงานและการคิดมากขึ้นโปรแกรมเมอร์ อาจต้องการทำทางลัดสกปรกและใช้การจัดการข้อยกเว้น ... คำสั่ง: "รหัสมืออาชีพไม่เคยล้มเหลว" อาจเป็นภาพลวงตาหากปัญหาบางอย่างที่ประมวลผลโดยอัลกอริทึมไม่แน่นอนตามธรรมชาติของมันเอง บางทีในสถานการณ์ที่ไม่รู้จักโดยธรรมชาติเป็นสิ่งที่ดีที่จะเข้ามามีบทบาทในการจัดการข้อยกเว้น แนวทางการเขียนโปรแกรมที่ดีเป็นเรื่องที่ต้องถกเถียงกัน