แนะนำสามเทคนิคการเขียนโค้ดที่ทรงพลังเพื่อเพิ่มประสิทธิภาพและลดความซับซ้อนของโครงสร้างเงื่อนไขที่ซับซ้อน ช่วยเพิ่มคุณภาพของโค้ดและความสามารถในการบำรุงรักษา
ในการพัฒนาซอฟต์แวร์ เรามักพบกับตรรกะของโค้ดที่ต้องจัดการกับหลายสถานการณ์ หากไม่ได้บริหารจัดการให้ดี ตรรกะเหล่านี้อาจกลายเป็นโซ่ if-else ที่ยาวหรือกรณี switch ที่ใหญ่ บทความนี้จะแนะนำเทคนิคที่มีประสิทธิภาพหลายประการเพื่อเพิ่มประสิทธิภาพโครงสร้างเหล่านี้ ปรับปรุงคุณภาพโค้ดและการบำรุงรักษา
สมมติว่าเรากำลังพัฒนาระบบการตรวจสอบผู้ใช้ที่ต้องตรวจสอบสถานะผู้ใช้ต่างๆ ก่อนอนุญาตให้เข้าถึง:
โค้ดนี้มีปัญหาด้านโครงสร้างที่ชัดเจน มันใช้โครงสร้าง if-else ที่ซ้อนลึก ซึ่งทำให้โค้ดอ่านยากและบำรุงรักษายาก เมื่อจำนวนการตรวจสอบเงื่อนไขเพิ่มขึ้น ระดับการเยื้องของโค้ดจะลึกขึ้น ซึ่งเป็นที่มาของคำว่าโค้ดแบบ "ลูกศร" การจัดการข้อผิดพลาดถูกกระจายออกไปในหลายระดับ การซ้อนซึ่งไม่สนับสนุนการจัดการแบบรวมศูนย์ที่ดี ที่สำคัญกว่านั้น ตรรกะหลักของโค้ด ซึ่งเป็นกรณีที่อนุญาตให้เข้าถึง ถูกฝังลึกในหลายชั้นของการตัดสินเงื่อนไข ขาดความชัดเจน รูปแบบการเขียนโปรแกรมนี้ไม่เพียงลดความอ่านง่ายของโค้ด แต่ยังเพิ่มความเสี่ยงของข้อผิดพลาดและทำให้การขยายโค้ดยาก
เราสามารถปรับปรุงโค้ดนี้โดยใช้วิธีกลับก่อนเวลา:
เมื่อใช้กลยุทธ์ "การคืนค่าก่อนเวลา" เราประสบความสำเร็จในการเพิ่มประสิทธิภาพโครงสร้างโค้ดเดิม
วิธีนี้นำมาซึ่งการปรับปรุงหลายประการ:
เรามักพบบทบาทที่ต้องคืนค่าผลลัพธ์ที่แตกต่างกันตามการป้อนข้อมูลที่ต่างกัน หากไม่ได้จัดการอย่างเหมาะสม ตรรกะเหล่านี้อาจกลายเป็นโซ่ if-else ที่ยาวหรือกรณี switch ที่ใหญ่ได้ ตัวอย่างเช่น ในแพลตฟอร์มอีคอมเมิร์ซ เราจำเป็นต้องคืนคำอธิบายในสถานะต่างๆ ตามสถานะคำสั่งที่แตกต่างกัน:
นี่เป็นสถานการณ์ทั่วไปของการคืนค่าผลลัพธ์ที่แตกต่างกันตามกรณีต่าง ๆ เมื่อจำนวนกรณีเพิ่มขึ้น การตัดสิน switch หรือ if-else จะยาวขึ้นและยาวขึ้น นอกจากนี้ ในสถานการณ์นี้ หากผู้ใช้จำเป็นต้องแปลเนื้อหาสถานะเหล่านี้เป็นภาษาอื่น ก็จำเป็นต้องแก้ไขร่างฟังก์ชันหรือเพิ่มฟังก์ชันใหม่ ซึ่งจะนำมาซึ่งค่าใช้จ่ายในการบำรุงรักษาอย่างมีนัยสำคัญ
ในกรณีนี้ เราสามารถใช้วิธีการทำตารางค้นหาเพื่อเพิ่มประสิทธิภาพโค้ด:
ประการแรก โดยใช้วัตถุ Map เพื่อเก็บความสัมพันธ์การจับคู่ระหว่างสถานะและคำอธิบาย โค้ดจะมีความกระชับมากขึ้นเราได้ให้ความสะดวกในการย้ายคำอธิบายสถานะไปยังไฟล์การกำหนดค่าให้มีความสะดวกในการทำงานระหว่างประเทศและการอัปเดตแบบไดนามิก เมื่อเพิ่มสถานะใหม่ เราไม่จำเป็นต้องแก้ไขรหัสตรรกะหลัก เพียงแค่เพิ่มคู่คีย์-ค่าในไฟล์การกำหนดค่า
เมื่อพัฒนาระบบซอฟต์แวร์ขนาดใหญ่ เรามักจะต้องรองรับผู้ให้บริการหลายรายหรือโมดูลฟังก์ชัน เราสามารถพิจารณาการเขียนโปรแกรมเชิงเมตตาในขั้นตอนการออกแบบซอฟต์แวร์เพื่ออำนวยความสะดวกในการขยายในภายหลัง โดยการกำจัดความซับซ้อนของการตัดสินเงื่อนไขหลายรายที่เกิดจากการเขียนรหัสอย่างหนักในระบบที่ซับซ้อน
สมมติว่าเรากำลังพัฒนาระบบการแปลหลายภาษา ที่ต้องรองรับผู้ให้บริการการแปลหลายราย หากเราไม่พิจารณาการเขียนโปรแกรมเชิงส่วนต่อประสานจากขั้นตอนการออกแบบ การขยายในภายหลังจะยากมาก:
การใช้โครงสร้าง if-else ที่เรียบง่ายและหยาบนี้เพื่อเลือกผู้ให้บริการการแปลทำให้โค้ดบำรุงรักษาได้ยากและขยายได้ยาก เมื่อเพิ่มผู้ให้บริการแปลใหม่ในอนาคต จำเป็นต้องมีการแก้ไขโค้ดที่มีอยู่ และเมื่อผู้ให้บริการแปลที่ต้องรับรองมากขึ้น โค้ดจะใหญ่และบำรุงรักษาได้ยาก ในขณะเดียวกันวิธีการนี้ยังทำให้การทดสอบหน่วยยากด้วย เพราะไม่สามารถจำลองผู้ให้บริการแปลต่าง ๆ ได้ง่ายเพื่อแก้ปัญหาเหล่านี้เราสามารถใช้การเขียนโปรแกรมเชิงส่วนต่อประสานเพื่อเพิ่มประสิทธิภาพโค้ด การเขียนโปรแกรมเชิงส่วนต่อประสานเป็นวิธีสำคัญในการใช้การแปลงแบบบางสิ่งบางอย่างที่อนุญาตให้วัตถุที่แตกต่างกันตอบสนองอย่างแตกต่างกันไปต่อข้อความเดียวกัน
กระบวนการที่ใช้:
ด้วยการกำหนดอินเทอร์เฟซ TranslationStrategy และนำการเขียนโปรแกรมเชิงเกี่ยวกับส่วนต่อประสานเข้ามา เราได้ประโยชน์ดังต่อไปนี้:
TranslationService สามารถใช้กลยุทธ์การแปลที่แตกต่างกันได้ในแต่ละครั้งที่เรียกใช้งานTranslationServiceTranslationService ทำให้บริการเป็นไม่มีสายและปลอดภัยมากขึ้นการเพิ่มประสิทธิภาพโครงสร้างคำสั่งเงื่อนไขเป็นมาตรการสำคัญในการปรับปรุงคุณภาพของโค้ด สามวิธีที่แนะนำในบทความนี้—การเขียนโปรแกรมเชิงป้องกัน, วิธีการทำตารางค้นหา, และการเขียนโปรแกรมเชิงส่วนต่อประสาน (รวมกับการเปลี่ยนรูปแบบโปริ吾)—มีสถานการณ์ที่เหมาะสมแต่ละอย่าง:
ในพัฒนาจริง เรามักจะต้องเลือกวิธีที่เหมาะสมตามสถานการณ์จริงและบางครั้งอาจต้องใช้เทคนิคหลายอย่างแบบรวมกัน สิ่งที่สำคัญคือการระดมความเรียบง่าย, การอ่านได้, และการบำรุงรักษาของโค้ด เลือกวิธีการที่เข้ากันได้ดีที่สุดกับปัญหาปัจจุบัน
โปรดจำไว้ว่า การเพิ่มประสิทธิภาพมากเกินไปอาจนำไปสู่โค้ดที่ซับซ้อนเกินไป การรักษาโค้ดให้ง่ายและอ่านได้เสมอเป็นหลักการสำคัญ เมื่อใช้เทคนิคเหล่านี้ ควรเลือกให้ชาญฉลาดตามความต้องการเฉพาะของโครงการและระดับเทคนิคของทีม