คำถามติดแท็ก exceptions

เราใช้ข้อยกเว้นเพื่อให้ผู้ใช้รหัสสามารถจัดการกับพฤติกรรมที่ไม่คาดคิดในวิธีที่มีประโยชน์ โดยปกติแล้วข้อยกเว้นจะถูกสร้างขึ้นรอบ ๆ สถานการณ์ "เกิดอะไรขึ้น" เช่นFileNotFound(เราไม่พบไฟล์ที่คุณระบุ) หรือZeroDivisionError(เราไม่สามารถดำเนิน1/0การได้) เกิดอะไรขึ้นถ้ามีความเป็นไปได้ที่จะระบุพฤติกรรมที่คาดหวังของผู้บริโภค? ตัวอย่างเช่นสมมติว่าเรามีfetchทรัพยากรซึ่งดำเนินการคำขอ HTTP และส่งคืนข้อมูลที่ดึงมา และแทนที่จะมีข้อผิดพลาดเช่นServiceTemporaryUnavailableหรือRateLimitExceededเราจะยกระดับการRetryableErrorแนะนำผู้บริโภคว่าควรลองใหม่อีกครั้งและไม่สนใจความล้มเหลวที่เฉพาะเจาะจง ดังนั้นเราจึงแนะนำการกระทำให้กับผู้โทรโดยทั่วไป - "สิ่งที่ต้องทำ" เราไม่ได้ทำเช่นนี้บ่อยครั้งเพราะเราไม่รู้ว่าการใช้งานของผู้บริโภคทั้งหมดเป็นอย่างไร แต่ลองจินตนาการว่านี่เป็นส่วนประกอบเฉพาะที่เรารู้ดีที่สุดในการกระทำสำหรับผู้โทรดังนั้นเราควรใช้วิธีการ "ควรทำอย่างไร"?

19 exceptions 

การระบุคำต่อท้ายของข้อยกเว้นในคลาสข้อยกเว้นรู้สึกเหมือนมีกลิ่นรหัสให้ฉัน (ข้อมูลที่ซ้ำซ้อน - ส่วนที่เหลือของชื่อแสดงถึงสถานะข้อผิดพลาดและสืบทอดมาจากข้อยกเว้น) อย่างไรก็ตามมันก็ดูเหมือนว่าทุกคนทำและดูเหมือนว่าจะเป็นแนวปฏิบัติที่ดี ฉันกำลังมองหาที่จะเข้าใจว่าทำไมการปฏิบัติที่ดีนี้ ฉันเคยเห็นและอ่านคำถามแล้วว่าทำไมข้อยกเว้นมักจะมีข้อยกเว้นต่อท้ายในชื่อชั้นเรียน คำถามสำหรับ PHP และในขณะที่การตอบสนองอาจใช้ได้สำหรับ Java มีข้อโต้แย้งอื่น ๆ หรือว่าเป็นเรื่องง่ายเหมือนการแยกแยะพวกเขาอย่างชัดเจน? หากเรานำตัวอย่างจากคำถามก่อนหน้านี้ - อาจมีคลาสใน java ด้วยชื่อFileNoFoundที่ไม่มีข้อยกเว้นหรือไม่ หากมีอาจเป็นไปได้หรือไม่ที่รับประกันว่าจะได้รับการรับรองด้วยExceptionหรือไม่ การดูลำดับชั้นอย่างรวดเร็วในสุริยุปราคาExceptionนั่นเองส่วนใหญ่ของพวกเขามีส่วนต่อท้ายของข้อยกเว้น แต่มีข้อยกเว้นเล็กน้อย javassistเป็นตัวอย่างของห้องสมุดที่ดูเหมือนว่าจะมีข้อยกเว้นบางประการโดยไม่ต้องต่อท้ายด้วย - เช่นBadByteCode, BadHttpRequestฯลฯ BouncyCastle เป็น lib อื่นที่มีข้อยกเว้นเช่น CompileError ฉันไปรอบ ๆ ด้วยข้อมูลเล็กน้อยในเรื่อง

19 java  naming  exceptions 

ฉันสามารถดูโพสต์ได้หลายแห่งซึ่งมีความสำคัญของการจัดการข้อยกเว้นที่ตำแหน่งศูนย์กลางหรือที่ขอบเขตกระบวนการได้รับการเน้นว่าเป็นแนวปฏิบัติที่ดีแทนที่จะทิ้งขยะบล็อคโค้ดทุกอันรอบลอง / จับ ฉันเชื่ออย่างยิ่งว่าพวกเราส่วนใหญ่เข้าใจถึงความสำคัญของมัน แต่ฉันเห็นคนยังคงลงท้ายด้วยรูปแบบการป้องกัน catch-log-rethrow เป็นหลักเพราะเพื่อความสะดวกในการแก้ไขปัญหาในระหว่างการยกเว้นพวกเขาต้องการบันทึกข้อมูลเฉพาะบริบทเพิ่มเติม ผ่าน) และวิธีคือการห่อวิธีรอบลอง / catch / log / rethrow public static bool DoOperation(int num1, int num2) { try { /* do some work with num1 and num2 */ } catch (Exception ex) { logger.log("error occured while number 1 = {num1} and number 2 = …

19 c#  exceptions  patterns-and-practices  logging 

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

18 bug  debugging  issue-tracking  exceptions  exception-handling 

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

18 testing  unit-testing  exceptions 

ในฐานะโปรแกรมเมอร์ Java ฉันมีความสำคัญอย่างยิ่งต่อข้อยกเว้นที่ไม่ได้ตรวจสอบ โปรแกรมเมอร์ส่วนใหญ่ใช้เป็นเส้นทางในการเข้ารหัสความง่ายเท่านั้นเพื่อสร้างปัญหาในภายหลัง นอกจากนี้โปรแกรม (แม้ว่าจะไม่เป็นระเบียบ) ที่มีข้อยกเว้นที่ตรวจสอบนั้นมีความแข็งแกร่งมากเมื่อเปรียบเทียบกับโปรแกรมที่ไม่ได้ตรวจสอบ น่าแปลกที่ Scala ไม่มีสิ่งใดที่เรียกว่าข้อยกเว้นที่ตรวจสอบแล้ว Java ที่เลือกและไม่ถูกตรวจสอบทั้งหมดจะถูกตรวจสอบใน Scala แรงจูงใจในการตัดสินใจครั้งนี้คืออะไร? สำหรับฉันมันเปิดปัญหามากมายเมื่อใช้รหัสภายนอกใด ๆ และถ้าโดยบังเอิญเอกสารไม่ดีก็จะส่งผลให้ฆ่า

17 java  scala  exceptions  exception-handling 

เมื่อไม่นานมานี้ฉันเริ่มใช้ Scala แทน Java ส่วนหนึ่งของกระบวนการ "แปลง" ระหว่างภาษาสำหรับฉันได้เรียนรู้การใช้งานEitherอัตโนมัติแทน (ตรวจสอบ) Exceptions ฉันได้รับการเข้ารหัสด้วยวิธีนี้มาระยะหนึ่งแล้ว แต่เมื่อไม่นานมานี้ฉันเริ่มสงสัยว่าเป็นวิธีที่ดีกว่าหรือไม่ ข้อEitherได้เปรียบที่สำคัญอย่างหนึ่งที่มากกว่าExceptionคือประสิทธิภาพที่ดีกว่า Exceptionความต้องการที่จะสร้างสแต็คร่องรอยและจะถูกโยน เท่าที่ฉันเข้าใจการขว้างปาExceptionไม่ใช่ส่วนที่เรียกร้อง แต่การสร้างสแต็กติดตามคือ แต่แล้วหนึ่งสามารถสร้าง / สืบทอดExceptions พร้อมด้วยscala.util.control.NoStackTraceและมากยิ่งขึ้นดังนั้นผมเห็นความอุดมสมบูรณ์ของกรณีที่ด้านซ้ายของEitherในความเป็นจริงException(ละทิ้งการเพิ่มประสิทธิภาพการทำงาน) ข้อดีอีกข้อหนึ่งEitherก็คือคอมไพเลอร์ - ความปลอดภัย คอมไพเลอร์ Scala จะไม่บ่นเกี่ยวกับExceptions ที่ไม่ได้จัดการ(ต่างจากคอมไพเลอร์ของ Java) แต่ถ้าฉันไม่เข้าใจผิดการตัดสินใจครั้งนี้มีเหตุผลด้วยเหตุผลเดียวกับที่กำลังคุยกันในหัวข้อนี้ดังนั้น ... ในแง่ของไวยากรณ์ฉันรู้สึกว่าExceptionสไตล์นั้นชัดเจนกว่า ตรวจสอบบล็อคโค้ดต่อไปนี้ (ทั้งการใช้ฟังก์ชันเดียวกัน): Either รูปแบบ: def compute(): Either[String, Int] = { val aEither: Either[String, String] = if (someCondition) Right("good") else Left("bad") …

17 coding-style  exceptions  scala  either 

isocpp.org ข้อยกเว้น FAQระบุสถานะ อย่าใช้ Throw เพื่อระบุข้อผิดพลาดในการใช้งานฟังก์ชั่น ใช้ assert หรือกลไกอื่น ๆ เพื่อส่งกระบวนการไปยังดีบักเกอร์หรือเพื่อทำให้กระบวนการทำงานผิดพลาดและเก็บรวบรวมดัมพ์ของข้อผิดพลาดเพื่อให้นักพัฒนาทำการดีบัก ในทางกลับกันไลบรารีมาตรฐานจะกำหนด std :: logic_error และทั้งหมดเป็นอนุพันธ์ซึ่งดูเหมือนว่าฉันควรจะจัดการนอกเหนือจากสิ่งอื่น ๆ ข้อผิดพลาดในการเขียนโปรแกรม กำลังส่งสตริงว่างไปยัง std :: stof (จะโยน invalid_argument) ไม่ใช่ข้อผิดพลาดในการเขียนโปรแกรมหรือไม่? การส่งสตริงที่มีอักขระที่แตกต่างจาก '1' / '0' ถึง std :: bitset (จะส่ง invalid__chument) ไม่ใช่ข้อผิดพลาดในการเขียนโปรแกรมหรือไม่? กำลังเรียก std :: bitset :: set ด้วยดัชนีที่ไม่ถูกต้อง (จะโยน out_of_range) ไม่ใช่ข้อผิดพลาดในการเขียนโปรแกรมหรือไม่? หากสิ่งเหล่านี้ไม่ใช่ข้อผิดพลาดในการเขียนโปรแกรมที่จะทดสอบคืออะไร ตัวสร้างสตริงที่ใช้ std :: …

16 design  c++  exceptions 

ประการที่สองฉันสงสัยว่าถ้าใครรู้ว่าอะไรคือความแตกต่างระหว่างข้อยกเว้น (ในขอบเขตของโฟลว์การควบคุมข้อยกเว้น) และข้อยกเว้น (เช่นที่ใช้ใน Java) แต่พวกเขาอยู่ที่นั่นโดยทั่วไปเพื่อปกป้องระบบจากการหยุดทำงานโดยการยกเลิกโปรแกรมผู้ใช้?

16 exceptions  exception-handling 

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

16 exceptions  methods  state 

ฉันกำลังสร้างแอปพลิเคชันอยู่สองสามเดือนและฉันก็ตระหนักถึงรูปแบบที่ปรากฏ: logger.error(ERROR_MSG); throw new Exception(ERROR_MSG); หรือเมื่อจับ: try { // ...block that can throw something } catch (Exception e) { logger.error(ERROR_MSG, e); throw new MyException(ERROR_MSG, e); } ดังนั้นเมื่อใดก็ตามที่ฉันโยนหรือจับข้อยกเว้นฉันจะเข้าสู่ระบบ อันที่จริงแล้วนั่นเป็นการบันทึกเกือบทั้งหมดที่ฉันทำในแอปพลิเคชัน ดังนั้นในฐานะโปรแกรมเมอร์ฉันหลีกเลี่ยงการทำซ้ำ ดังนั้นฉันตัดสินใจย้ายตัวบันทึกไปยังการสร้างข้อยกเว้นดังนั้นเมื่อใดก็ตามที่ฉันกำลังสร้างข้อยกเว้นสิ่งต่าง ๆ จะถูกบันทึกไว้ แน่นอนฉันสามารถสร้าง ExceptionHelper ซึ่งทำให้เกิดข้อยกเว้นสำหรับฉันได้ แต่นั่นจะทำให้รหัสของฉันยากต่อการตีความและยิ่งกว่านั้นคอมไพเลอร์ก็ไม่สามารถจัดการกับมันได้โดยไม่เข้าใจว่าจะมีการโทรหาสมาชิกคนนั้น โยนทันที ดังนั้นนี่เป็นรูปแบบการต่อต้านหรือไม่ ถ้าเป็นเช่นนั้นทำไม

15 exceptions  logging 

ในขณะที่ออกแบบไลบรารี C ++ 'จริงจัง' ครั้งแรกของฉันฉันถามตัวเอง: มันเป็นสไตล์ที่ดีหรือไม่ที่จะได้รับการยกเว้นจากสิ่งstd::exceptionนั้น แม้หลังจากอ่านเสร็จ การออกแบบคลาสยกเว้น ข้อยกเว้น 'จำนวนที่ดี' ที่จะนำไปใช้กับห้องสมุดของฉันคืออะไร ฉันยังไม่แน่ใจ เพราะนอกเหนือจากการปฏิบัติทั่วไป (แต่อาจจะไม่ดี) ฉันจะถือว่าในฐานะผู้ใช้ห้องสมุดว่าฟังก์ชั่นห้องสมุดจะstd::exceptionแสดงเฉพาะเมื่อฟังก์ชั่นไลบรารีมาตรฐานล้มเหลวในการใช้งานไลบรารีและมันไม่สามารถทำอะไรได้เลย แต่ยังคงเมื่อเขียนรหัสโปรแกรมสำหรับฉันมันสะดวกมากและยัง IMHO std::runtime_errorดูดีเพียงแค่โยน ผู้ใช้ของฉันยังสามารถพึ่งพาส่วนต่อประสานขั้นต่ำที่กำหนดเช่นwhat()รหัสหรือ และตัวอย่างเช่นผู้ใช้ของฉันให้ข้อโต้แย้งที่ผิดพลาดสิ่งที่จะสะดวกกว่าการโยน a std::invalid_argumentใช่มั้ย ดังนั้นรวมกับการใช้งานยังร่วมกันของมาตรฐาน :: ข้อยกเว้นที่ฉันเห็นในรหัสผู้อื่น: ทำไมไม่ไปให้ดียิ่งขึ้นและได้รับมาจากชั้นยกเว้นของคุณเอง (เช่น lib_foo_exception) std::exceptionและจาก คิด?

15 c++  exceptions 

อ้างจากMSDN เกี่ยวกับ StackOverflowException : ข้อยกเว้นที่ถูกส่งออกมาเมื่อการดำเนินการสแต็คล้นเพราะมันมีการเรียกวิธีการซ้อนกันมากเกินไป Too manyที่นี่ค่อนข้างคลุมเครือ ฉันจะรู้ได้อย่างไรว่าเมื่อใดมากเกินไปมากเกินไปจริง ๆ ? การเรียกใช้ฟังก์ชันหลายพันครั้ง? ล้าน? ฉันคิดว่ามันต้องเกี่ยวข้องกับปริมาณของหน่วยความจำในคอมพิวเตอร์ แต่เป็นไปได้ไหมที่จะมีขนาดของลำดับความแม่นยำที่ถูกต้อง? ฉันกังวลเกี่ยวกับเรื่องนี้เพราะฉันกำลังพัฒนาโครงการที่เกี่ยวข้องกับการใช้โครงสร้างแบบเรียกซ้ำและการเรียกใช้ฟังก์ชันแบบเรียกซ้ำ ฉันไม่ต้องการให้แอปพลิเคชันล้มเหลวเมื่อฉันเริ่มใช้งานมากกว่าการทดสอบเล็กน้อย

15 .net  exceptions  recursion  stackoverflow 

ถือว่าเป็นวิธีปฏิบัติที่ไม่เหมาะสมในการโยนNotImplementedExceptionรหัสที่คุณยังไม่ได้เขียนหรือยัง ความเห็นของสิ่งที่ต้องทำอาจจะถือว่าปลอดภัยกว่า

15 .net  comments  coding  exceptions 

ฉันอยู่ระหว่างการเปลี่ยนโครงสร้างแอปพลิเคชันเว็บที่ค่อนข้างใหญ่ หนึ่งในปัญหาที่สำคัญคือการจัดการข้อผิดพลาดที่ไม่สอดคล้องกันและฉันกำลังพยายามหากลยุทธ์ที่เหมาะสม ฉันได้สร้างตัวจัดการข้อผิดพลาดที่กำหนดเองผ่านset_error_handlerซึ่งจะเปลี่ยนข้อผิดพลาดของ PHP ในErrorExceptionsและคลาสยกเว้นฐานที่กำหนดเองซึ่งสืบทอดจากExceptionโดยตรง ในการผลิตฉันใช้ catch-all exception ทั่วไปผ่านset_exception_handlerและฉันกำลังจะเพิ่มการบันทึก exception *ให้กับ mix ขึ้นเขียงของฉันคือที่ที่จะทำการบันทึกที่แท้จริงในคลาสยกเว้นฐานหรือใน catch-all ฉันคิดถึงเหตุผลสองสามข้อในการเข้าสู่ระบบทั้งหมด: มีข้อยกเว้นเล็กน้อยในโค้ดที่ต้องแปลงเป็นชายด์ที่เหมาะสมของคลาส exception พื้นฐาน จนกว่าสิ่งนั้นจะเกิดขึ้นจะไม่มีการบันทึกข้อยกเว้นทั้งหมด มันรู้สึกเป็นธรรมชาติมากขึ้นที่จะทำใน catch-all คลาสยกเว้นฐานไม่ควรทำมากกว่าแค่นั้น (อาจเป็นสิ่งที่หลักการความรับผิดชอบเดียว แต่มันอาจเป็นความรู้สึกที่เข้าใจผิด) และเหตุผลหนึ่งในการเข้าสู่คลาสยกเว้นฐาน: ปัจจุบัน catch-all ใช้กับการผลิตเท่านั้น มันจะง่ายต่อการแนะนำในสภาพแวดล้อมอื่น ๆ ของเรา (การพัฒนาการทดสอบ) แต่ที่จะเรียกร้องให้มีการปรับเปลี่ยนเล็กน้อยเนื่องจากข้อผิดพลาดจะได้รับการจัดการแตกต่างกันไปตามสภาพแวดล้อมเช่นเดียวกับการผลิต มีวิธีปฏิบัติที่ยอมรับได้สำหรับการบันทึกข้อยกเว้นหรือไม่ * การบันทึกจะเกี่ยวข้องกับการเขียนไปยังไฟล์ข้อความในตอนแรกและมันอาจพัฒนาไปสู่การส่งอีเมลสำหรับข้อยกเว้นบางประเภท คำอธิบายบางอย่างได้รับแจ้งจากคำตอบของ @ unholysampler : ฉันกำลังเผชิญกับโค้ดเบส sloc ขนาด 2 * 10 ^ 6 พร้อมสิ่งต่าง ๆ …

15 php  exceptions  logging