3 เทคนิคการเขียนโค้ดที่ทรงพลังเพื่อกำจัดเงื่อนไขที่ยุ่งเหยิง

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

1. การเขียนโปรแกรมเชิงป้องกัน: การคืนค่าก่อนเวลา#

สมมติว่าเรากำลังพัฒนาระบบการตรวจสอบผู้ใช้ที่ต้องตรวจสอบสถานะผู้ใช้ต่างๆ ก่อนอนุญาตให้เข้าถึง:

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

เราสามารถปรับปรุงโค้ดนี้โดยใช้วิธีกลับก่อนเวลา:

เมื่อใช้กลยุทธ์ "การคืนค่าก่อนเวลา" เราประสบความสำเร็จในการเพิ่มประสิทธิภาพโครงสร้างโค้ดเดิม

วิธีนี้นำมาซึ่งการปรับปรุงหลายประการ:

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

2. วิธีการทำตารางค้นหา#

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

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

ในกรณีนี้ เราสามารถใช้วิธีการทำตารางค้นหาเพื่อเพิ่มประสิทธิภาพโค้ด:

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

3. การเขียนโปรแกรมเชิงส่วนต่อประสาน#

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

สมมติว่าเรากำลังพัฒนาระบบการแปลหลายภาษา ที่ต้องรองรับผู้ให้บริการการแปลหลายราย หากเราไม่พิจารณาการเขียนโปรแกรมเชิงส่วนต่อประสานจากขั้นตอนการออกแบบ การขยายในภายหลังจะยากมาก:

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

กระบวนการที่ใช้:

1. กำหนดอินเทอร์เฟซกลยุทธ์การแปล:

2. ใช้อินเทอร์เฟซนี้กับผู้ให้บริการการแปลแต่ละราย:

3. รีเฟรชคลาส TranslationService โดยส่งกลยุทธ์เป็นพารามิเตอร์:

4. ใช้โค้ดที่ปรับให้เหมาะสม:

ด้วยการกำหนดอินเทอร์เฟซ TranslationStrategy และนำการเขียนโปรแกรมเชิงเกี่ยวกับส่วนต่อประสานเข้ามา เราได้ประโยชน์ดังต่อไปนี้:

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

บทสรุป#

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

1. การเขียนโปรแกรมเชิงป้องกันเหมาะสำหรับจัดการการตรวจสอบเงื่อนไขที่แยกจากกันและสามารถลดการซ้อนโค้ดได้อย่างมีประสิทธิภาพ
2. วิธีการทำตารางค้นหาเหมาะสำหรับจัดการด้านที่ตอบสนองต่อต่างกัน ทำให้โค้ดกระชับและง่ายต่อการบำรุงรักษา
3. การเขียนโปรแกรมเชิงส่วนต่อประสานรวมกับการเปลี่ยนรูปแบบบางสิ่งบางอย่างเหมาะสำหรับการสร้างระบบที่ซับซ้อนแต่มีความยืดหยุ่นปรับปรุงความยืดหยุ่นและขยายโค้ดได้

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

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