เหตุใดจึงต้องลองใช้ ... ในที่สุดโดยไม่มีข้อห้าม?

try ... catchวิธีที่คลาสสิกในการเขียนโปรแกรมอยู่กับ เมื่อไรที่มันจะเหมาะสมที่จะใช้tryโดยไม่catch?

ใน Python ข้อมูลต่อไปนี้ถูกกฎหมายและสมเหตุสมผล:

try:
  #do work
finally:
  #do something unconditional

อย่างไรก็ตามรหัสไม่ได้catchอะไรเลย ในทำนองเดียวกันหนึ่งสามารถคิดใน Java มันจะเป็นดังนี้:

try {
    //for example try to get a database connection
}
finally {
  //closeConnection(connection)
}

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

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

ขึ้นอยู่กับว่าคุณสามารถจัดการกับข้อยกเว้นที่สามารถเลี้ยงดูได้ ณ จุดนี้หรือไม่

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

หากคุณไม่สามารถจัดการกับมันแบบโลคัลได้เพียงแค่มีtry / finallyบล็อกก็มีเหตุผลอย่างสมบูรณ์ - สมมติว่ามีโค้ดบางอย่างที่คุณต้องดำเนินการโดยไม่คำนึงถึงวิธีการที่สำเร็จหรือไม่ ตัวอย่างเช่น (จากความคิดเห็นของ Neil ) การเปิดสตรีมแล้วส่งสตรีมนั้นไปยังวิธีการภายในที่จะโหลดเป็นตัวอย่างที่ยอดเยี่ยมเมื่อคุณต้องการtry { } finally { }ใช้ประโยคสุดท้ายเพื่อให้แน่ใจว่าสตรีมนั้นถูกปิดโดยไม่คำนึงถึงความสำเร็จหรือ ความล้มเหลวของการอ่าน

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

finallyบล็อกจะใช้สำหรับรหัสที่ต้องเรียกใช้เสมอไม่ว่าจะเป็นเงื่อนไขข้อผิดพลาด (ยกเว้น) ที่เกิดขึ้นหรือไม่

รหัสในfinallyบล็อกจะทำงานหลังจากtryบล็อกเสร็จสมบูรณ์และหากมีข้อผิดพลาดเกิดขึ้นหลังจากcatchบล็อกที่เกี่ยวข้องนั้นเสร็จสมบูรณ์ มันทำงานอยู่เสมอแม้ว่าจะมีข้อยกเว้นที่ไม่ได้ตรวจสอบที่เกิดขึ้นในtryหรือcatchบล็อก

โดยfinallyทั่วไปบล็อกจะใช้สำหรับการปิดไฟล์การเชื่อมต่อเครือข่าย ฯลฯ ที่เปิดในtryบล็อก เหตุผลคือต้องปิดการเชื่อมต่อไฟล์หรือเครือข่ายไม่ว่าจะเป็นการดำเนินการโดยใช้ไฟล์หรือการเชื่อมต่อเครือข่ายสำเร็จหรือไม่ก็ตาม

ควรใช้ความระมัดระวังในfinallyบล็อกเพื่อให้แน่ใจว่ามันไม่ได้เป็นข้อยกเว้น ตัวอย่างเช่นให้แน่ใจว่าได้ตรวจสอบตัวแปรทั้งหมดnullเป็นต้น

ตัวอย่างที่ลอง ... ในที่สุดโดยไม่มี catch clauseนั้นเหมาะสม (และยิ่งกว่านั้นเป็นสำนวน ) ใน Java คือการใช้งานของLockในแพ็คเกจล็อคยูทิลิตี้พร้อมกัน

• นี่คือวิธีการอธิบายและจัดทำเอกสาร API (ตัวอักษรตัวหนาในเครื่องหมายคำพูดเป็นของฉัน):
  

  ... การขาดการล็อคโครงสร้างบล็อกจะเป็นการปลดล็อคการปล่อยอัตโนมัติที่เกิดขึ้นกับวิธีการและข้อความที่ตรงกัน ในกรณีส่วนใหญ่ควรใช้สำนวนต่อไปนี้ :

   Lock l = ...;
   l.lock();
   try {
       // access the resource protected by this lock
   } finally {
       l.unlock();
   }
  

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

ในระดับพื้นฐานcatchและfinallyแก้ปัญหาที่เกี่ยวข้อง แต่แตกต่างกันสองปัญหา:

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

ดังนั้นทั้งสองเกี่ยวข้องกับปัญหา (ข้อยกเว้น) แต่นั่นก็คือทั้งหมดที่พวกเขามีเหมือนกัน

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

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

@yfeldblum มีคำตอบที่ถูกต้อง: ลองโดยไม่ต้องมีคำสั่ง catch โดยปกติแล้วควรแทนที่ด้วยโครงสร้างภาษาที่เหมาะสม

ใน C ++ มันใช้ RAII และ constructors / destructors ใน Python มันเป็นwithคำสั่ง; และใน C # มันเป็นusingคำสั่ง

สิ่งเหล่านี้มักจะสวยงามกว่าเพราะการกำหนดค่าเริ่มต้นและรหัสการสรุปอยู่ในที่เดียว (วัตถุที่เป็นนามธรรม) แทนที่จะเป็นสองแห่ง

ในหลายภาษาfinallyคำสั่งจะทำงานหลังจากคำสั่ง return หมายความว่าคุณสามารถทำสิ่งต่อไปนี้

try {
  // Do processing
  return result;
} finally {
  // Release resources
}

ซึ่งเผยแพร่ทรัพยากรโดยไม่คำนึงถึงวิธีการที่สิ้นสุดลงด้วยข้อยกเว้นหรือคำสั่งส่งคืนปกติ

ไม่ว่าจะดีหรือไม่ดีขึ้นอยู่กับการถกเถียง แต่try {} finally {}ก็ไม่ได้ จำกัด อยู่แค่การจัดการข้อยกเว้นเสมอไป

ฉันอาจเรียกใช้ความโกรธเกรี้ยวของ Pythonistas (ไม่รู้ว่าฉันไม่ได้ใช้ Python มาก) หรือโปรแกรมเมอร์จากภาษาอื่นด้วยคำตอบนี้ แต่ในความเห็นของฉันฟังก์ชั่นส่วนใหญ่ไม่ควรมีcatchบล็อก เพื่อแสดงว่าทำไมให้ฉันเปรียบเทียบสิ่งนี้กับการเผยแพร่รหัสข้อผิดพลาดด้วยตนเองของชนิดที่ฉันต้องทำเมื่อทำงานกับ Turbo C ในช่วงปลายยุค 80 และต้นยุค 90

ดังนั้นสมมติว่าเรามีฟังก์ชั่นในการโหลดภาพหรืออะไรทำนองนั้นในการตอบสนองต่อผู้ใช้ที่เลือกไฟล์ภาพที่จะโหลดและนี่คือการเขียนใน C และการชุมนุม:

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

จุดล้มเหลวและการกู้คืน

ตอนนี้มันก็ไม่เคยยากที่จะเขียนประเภทของฟังก์ชั่นที่ผมเรียกว่า "จุดที่เป็นไปได้ของความล้มเหลว" (ที่คนที่throw, IE) และ "การกู้คืนข้อผิดพลาดและรายงาน" ฟังก์ชั่น (คนที่catchเช่น)

ฟังก์ชั่นเหล่านั้นมักจะน่ารำคาญที่จะเขียนอย่างถูกต้องก่อนการจัดการข้อยกเว้นที่สามารถใช้ได้ตั้งแต่ฟังก์ชั่นที่สามารถใช้เป็นความล้มเหลวภายนอกเช่นความล้มเหลวในการจัดสรรหน่วยความจำก็สามารถกลับมาNULLหรือ0หรือ-1หรือตั้งค่ารหัสข้อผิดพลาดในระดับโลกหรือสิ่งดังต่อไปนี้ และการกู้คืนข้อผิดพลาด / การรายงานเป็นเรื่องง่ายเสมอตั้งแต่เมื่อคุณทำงานลง call stack ไปยังจุดที่เหมาะสมในการกู้คืนและรายงานความล้มเหลวคุณเพียงแค่นำรหัสข้อผิดพลาดและ / หรือข้อความและรายงานไปยังผู้ใช้ และโดยธรรมชาติแล้วฟังก์ชั่นที่อยู่ในลำดับชั้นของสิ่งนี้ซึ่งไม่เคยล้มเหลวไม่ว่าจะมีการเปลี่ยนแปลงอย่างไรในอนาคต ( Convert Pixel) จะตายง่ายต่อการเขียนอย่างถูกต้อง (อย่างน้อยก็เกี่ยวกับการจัดการข้อผิดพลาด)

การแพร่กระจายข้อผิดพลาด

อย่างไรก็ตามฟังก์ชั่นที่น่าเบื่อนั้นมักจะเกิดจากความผิดพลาดของมนุษย์คือตัวกระจายข้อผิดพลาดซึ่งไม่ได้ทำงานโดยตรงกับความล้มเหลว แต่เรียกว่าฟังก์ชั่นที่อาจล้มเหลวได้ลึกลงไปในลำดับชั้น ณ จุดนั้นAllocate Scanlineอาจต้องจัดการกับความล้มเหลวจากmallocนั้นส่งคืนข้อผิดพลาดลงไปConvert Scanlinesจากนั้นConvert Scanlinesจะต้องตรวจสอบข้อผิดพลาดนั้นและส่งมันลงไปDecompress Imageแล้วจากนั้นDecompress Image->Parse ImageและParse Image->Load ImageและLoad Imageไปยังคำสั่งผู้ใช้ปลายทางที่มีการรายงานข้อผิดพลาด .

นี่คือที่มนุษย์จำนวนมากทำผิดเพราะใช้เวลาเพียงหนึ่งข้อผิดพลาดในการตรวจสอบและส่งผ่านข้อผิดพลาดสำหรับลำดับชั้นของฟังก์ชั่นทั้งหมดที่จะล้มลงเมื่อมันมาถึงการจัดการข้อผิดพลาดอย่างถูกต้อง

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

การลดข้อผิดพลาดของมนุษย์: รหัสข้อผิดพลาดทั่วโลก

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

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

การลดข้อผิดพลาดของมนุษย์: การจัดการข้อยกเว้น

อย่างไรก็ตามวิธีการแก้ปัญหาข้างต้นยังคงต้องใช้ฟังก์ชั่นมากมายในการจัดการด้านการควบคุมการแพร่กระจายข้อผิดพลาดด้วยตนเองแม้ว่ามันอาจจะลดจำนวนบรรทัดif error happened, return errorของรหัสประเภทคู่มือ มันจะไม่กำจัดมันอย่างสมบูรณ์เพราะมักจะต้องมีการตรวจสอบข้อผิดพลาดอย่างน้อยหนึ่งที่และส่งคืนเกือบทุกฟังก์ชันการเผยแพร่ข้อผิดพลาดเดียว ดังนั้นนี่คือเมื่อการจัดการข้อยกเว้นเข้ามาในรูปภาพเพื่อบันทึกวัน (sorta)

แต่คุณค่าของการจัดการข้อยกเว้นที่นี่คือการเพิ่มความจำเป็นในการจัดการกับลักษณะการไหลของการควบคุมของการเผยแพร่ข้อผิดพลาดด้วยตนเอง นั่นหมายความว่าคุณค่าของมันนั้นเชื่อมโยงกับความสามารถในการหลีกเลี่ยงการเขียนจำนวนcatchบล็อกในฐานโค้ดของคุณ ในแผนภาพด้านบนสถานที่เดียวที่ควรมีcatchบล็อกคือLoad Image User Commandที่ซึ่งรายงานข้อผิดพลาด ไม่มีอะไรที่ควรจะต้องทำcatchอย่างอื่นเพราะอย่างนั้นมันเริ่มที่จะได้รับเป็นที่น่าเบื่อและเป็นข้อผิดพลาดได้ง่ายเช่นเดียวกับการจัดการรหัสข้อผิดพลาด

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

การล้างทรัพยากร

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

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

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

ย้อนกลับผลข้างเคียงภายนอก

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

นี่finallyคือวิธีการแก้ปัญหาที่หรูหราที่สุดในภาษาที่หมุนรอบความแปรปรวนและผลข้างเคียงเพราะบ่อยครั้งที่ตรรกะประเภทนี้มีความเฉพาะเจาะจงกับฟังก์ชั่นหนึ่ง ๆ และไม่ได้แมปกับแนวคิดของ "การล้างทรัพยากร" " และฉันขอแนะนำให้ใช้finallyอย่างเสรีในกรณีเหล่านี้เพื่อให้แน่ใจว่าฟังก์ชั่นของคุณย้อนกลับผลข้างเคียงในภาษาที่สนับสนุนไม่ว่าคุณจะต้องการcatchบล็อกหรือไม่(และอีกครั้งหากคุณถามฉันรหัสที่เขียนดีควรมีจำนวนขั้นต่ำcatchบล็อกและcatchบล็อกทั้งหมดควรอยู่ในสถานที่ที่เหมาะสมที่สุดตามแผนภาพด้านบนLoad Image User Command)

ภาษาดรีม

อย่างไรก็ตาม IMO finallyนั้นใกล้เคียงกับอุดมคติสำหรับการกลับรายการผลข้างเคียง แต่ไม่มากนัก เราจำเป็นต้องแนะนำbooleanตัวแปรหนึ่งตัวเพื่อย้อนกลับผลข้างเคียงอย่างมีประสิทธิภาพในกรณีของการออกก่อนกำหนด (จากข้อยกเว้นที่ส่งออกไปหรืออย่างอื่น) เช่น:

bool finished = false;
try
{
    // Cause external side effects.
    ...

    // Indicate that all the external side effects were
    // made successfully.
    finished = true; 
}
finally
{
    // If the function prematurely exited before finishing
    // causing all of its side effects, whether as a result of
    // an early 'return' statement or an exception, undo the
    // side effects.
    if (!finished)
    {
        // Undo side effects.
        ...
    }
}

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

transaction
{
    // Cause external side effects.
    ...
}
rollback
{
    // This block is only executed if the above 'transaction'
    // block didn't reach its end, either as a result of a premature
    // 'return' or an exception.

    // Undo side effects.
    ...
}

... กับ destructors เพื่อทำให้การทำความสะอาดของทรัพยากรในท้องถิ่นทำให้มันดังนั้นเราจะต้องtransaction, rollbackและcatch(แม้ว่าฉันอาจยังคงต้องการที่จะเพิ่มfinallyสำหรับการพูด, การทำงานร่วมกับทรัพยากร C ที่ไม่ได้ทำความสะอาดตัวเองขึ้นไป) อย่างไรก็ตามfinallyด้วยbooleanตัวแปรเป็นสิ่งที่ใกล้เคียงที่สุดที่จะทำให้สิ่งนี้ตรงไปตรงมาที่ฉันพบว่ายังขาดภาษาในฝันของฉัน วิธีแก้ปัญหาที่ตรงไปตรงมามากที่สุดอันดับที่สองที่ฉันพบคือนี้เป็นขอบเขตของภาษาเช่น C ++ และ D แต่ฉันมักจะพบว่าขอบเขตของตัวป้องกันนั้นค่อนข้างน่าอึดอัดใจในทางแนวคิดเนื่องจากมันทำให้แนวคิดของ ในความคิดของฉันเหล่านั้นเป็นแนวคิดที่แตกต่างกันมากที่จะจัดการในวิธีที่แตกต่าง

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

ข้อสรุป

ฉันคิดว่าtry/finallyรหัสของคุณสำหรับการปิดซ็อกเก็ตนั้นดีและดีมากเพราะ Python ไม่มีตัวทำลาย C ++ เทียบเท่าและโดยส่วนตัวฉันคิดว่าคุณควรใช้สิ่งนี้อย่างอิสระสำหรับสถานที่ที่ต้องการผลข้างเคียง และลดจำนวนสถานที่ที่คุณต้องไปcatchยังสถานที่ที่เหมาะสมที่สุด

การจับข้อผิดพลาด / ข้อยกเว้นและการจัดการพวกเขาในลักษณะที่เรียบร้อยขอแนะนำอย่างยิ่งแม้ว่าจะไม่ได้รับคำสั่ง

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

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

กฎทอง: รับข้อยกเว้นเสมอเนื่องจากการเดาต้องใช้เวลา