13 แนวทาง ในการเขียน Quality Code

1. เขียน Orthogonal Code
เมื่อสองสิ่งไม่มีความเกี่ยวข้องกัน การเปลี่ยนแปลงของสิ่งหนึ่งจะไม่ส่งผลกระทบต่อสิ่งอื่น เมื่อคุณเขียน Code จงลดการพึ่งพาซึ่งกันและกันระหว่าง Module ต่างๆ หลีกเลี่ยง Global Variables และพยายามทำให้ Code ของคุณไม่พึ่งพากัน ซึ่งการทำสิ่งนี้ มีประโยชน์คือ:
- เพิ่มในเรื่อง Portability
- Code ของคุณง่ายต่อการ Test
- มีความเสี่ยงน้อยลง เมื่อเปลี่ยนแปลงส่วนหนึ่งส่วนใดของ System
2. จัดการกับ Exceptions ทั้งหมด
อย่าปล่อยให้ Catch clause เป็นค่า Empty พยายามเขียน Code ให้แต่ละ Event เกิดขึ้นได้เสมอ เพราะไม่เช่นนั้นอาจเป็นสาเหตุสำคัญที่ทำให้เกิด Bug ในระบบของคุณ ควรหลีกเลี่ยงการเกิด Exceptions ให้มากที่สุดเท่าที่จะทำได้ หากคุณไม่สามารถจัดการกับ Exceptions ได้ บางทีอาจเป็นการดีกว่าที่จะ Rethrow มันกลับไป
3. แต่ละ Functions ควรทำแค่สิ่งเดียว
Function ควรจะสั้นและมีหน้าที่ทำสิ่งใดสิ่งหนึ่งเฉพาะเจาะจง รวมทั้งตั้งชื่อให้สื่อว่า Function หากพบว่า Function ของคุณทำสิ่งใดมากกว่าหนึ่งอย่าง ก็ควรจะแบ่งมันออกเป็นส่วนๆ เพื่อให้ Code ของคุณอ่านง่ายขึ้น รวมทั้งง่ายต่อการ Test และ Debug อีกด้วย
4. ทำให้สอดคล้องกัน (Consistent)
หาก Frameworks ที่คุณกำลังสร้างเพื่อใช้กับ Code styles บางอย่าง ก็จงยึดถือ Frameworks เหล่านั้นอยู่เสมอและใช้ Style ทั้งหมดเหล่านั้นกับ Code ของคุณ หากคุณตัดสินใจว่าจะตั้งชื่อตัวแปรและ Function ด้วยแนวทางใด ก็จงยึดถือแบบนั้นไปตลอด สิ่งนี้มีความสำคัญมากเมื่อคุณต้องทำงานร่วมกับ Developer คนอื่น เนื่องจากจะทำให้คนอื่น สามารถสรุปและเข้าใจใน Code ที่มีอยู่ได้อย่างง่ายดาย รวมทั้งช่วยลดความสับสนและเพิ่มความคุ้นเคยมากขึ้นอีกด้วย
5. อย่าทำอะไรซ้ำๆ (DRY- Don’t Repeat Yourself)
การทำซ้ำ (Duplication) ถือเป็นต้นเหตุของเรื่องแย่ๆ หลายอย่างใน Software ลองนึกภาพว่า คุณได้ทำ URL เดียวกันซ้ำๆ ในCode ของคุณ 4 ครั้ง นั่นหมายถึงการที่คุณต้องทำการ Update ตัวแปรทั้ง 4 ในกรณีที่ URL มีการเปลี่ยนแปลง ซึ่งอาจทำให้เกิด Errors ขึ้นได้ในกรณีที่คุณลืมเปลี่ยนตัวแปรดังกล่าว นี่เป็นเพียงตัวอย่างง่ายๆ ที่บางครั้งก็อาจส่งผลร้ายแรง และนั่นก็เป็นเหตุผลว่า ทำไมต้องมีการสร้างกฏระเบียบ(Principles) และวิธีปฏิบัติ(Practices) ต่างๆ ขึ้นมาเพื่อควบคุมหรือกำจัดสิ่งเหล่านี้ออกไป
6. เขียน Comment ใน Code ด้วย
คงไม่มีอะไรที่จะเป็นตัวช่วยอย่างดีเท่ากับการ Comment ลงใน Code อีกแล้ว คุณควรทำมันอย่างสม่ำเสมอ ลองมาดูเคล็ดลับการเขียน Comment ที่ดีกัน:
- การ Comment จะช่วยลดการเกิด Code ที่แย่ๆ
- Comment แค่เฉพาะส่วนที่จำเป็นก็พอ
- หลีกเลี่ยงการ Comment อะไรนอกเหนือ Code มันอาจมีประโยชน์ในระยะสั้นเท่านั้น แต่ในระยะยาวอาจทำให้เกิดความยุ่งเหยิงได้
- ไม่ต้องระบุว่าทำโดยใคร เพราะ Version Control จะช่วยจัดการเอง
7. ใช้ชื่อที่มีความหมายเข้าใจได้
ในการเขียน Code เราต้องตั้งชื่อในหลายๆ ส่วน ไม่ว่าจะเป็น Functions, Variables, Classes เป็นต้น ดังนั้นจึงเป็นความคิดที่ดีที่จะเลือกชื่อที่เหมาะสมและเข้าใจง่าย ลองมาดูเคล็ดลับการตั้งชื่อกัน:
- ใช้ชื่อที่สื่อความหมายชัดเจน
- หลีกเลี่ยงการตั้งชื่อที่ไม่ตรงกับความเป็นจริง
- ใช้ชื่อที่คนอื่นสามารถอ่านออก
- ใช้ชื่อที่สามารถค้นหาได้ง่าย
- อย่าใช้ชื่อที่ต้องแปลความหมายให้ยุ่งยาก ผู้ที่อ่าน Code ไม่ควรต้องแปลชื่อที่คุณตั้ง เป็นชื่ออื่นที่พวกเขารู้จัก
8. จัด Format ของ Code ให้เหมาะสม
ควรตั้งกฏเกณฑ์ที่สามารถควบคุม Format ของ Code ได้ง่ายและสะดวก และควรใช้ Format นั้นกับ Code ทั้งหมด หากคุณต้องทำงานกันเป็นทีม ภายในทีมเองก็ควรมีข้อตกลงให้ชัดเจนเกี่ยวกับ Format ที่จะใช้และสมาชิกทุกคนในทีมก็ควรปฏิบัติตามด้วย คุณสามารถใช้ Automated Tool ในการช่วยจัด Format Code ของคุณก้ได้ เช่น EditorConfig ซึ่งมันช่วยให้ Developers เกิดความชัดเจนและสามารถ Maintain Coding Styles ให้สอดคล้องกันระหว่าง Editors และ IDEs ต่างๆ ได้
9. Test Code ของคุณ
Programmer Test Codeด้วยการ Test คุณจะสามารถเปลี่ยนแปลงแก้ไข Code ของคุณได้โดยไม่ต้องกังวลว่าจะเกิดความเสียหายอะไร เนื่องจากการ Test จะช่วยพิสูจน์ว่าทุกอย่างทำงานได้ดี ข้อดีอีกอย่างของการ Test ก็คือ ถ้าคุณเจอ Bugม ก็จงเขียน Unit Test และทำการแก้ไขมัน, Bug เหล่านั้นก็จะไม่น่าปรากฏขึ้นอีก และคุณสามารถพิสูจน์ได้ด้วยการ Test ของคุณ
10. รู้จัก Editor ที่คุณใช้เป็นอย่างดี
การที่จะเลือกใช้ Editor สำหรับงานที่ต้องแก้ไข คุณควรรู้จักมันเป็นอย่างดีเสียก่อน และคุณควรสามารถใช้งาน Editor เหล่านั้นได้อย่างคล่องแคล่วอย่างเป็นธรรมชาติ
11. พยายามใช้ Source Code Control อยู่เสมอ
แนะนำให้ใช้ Version Control ในทุกสิ่งที่คุณทำ ไม่ว่าจะเป็น SVN, Git หรือแม้แต่ CVS ก็ควรใช้งานมันให้คล่อง นี่เป็นกรณีตัวอย่างส่วนหนึ่ง ที่ Version Control เป็นคำตอบที่สามารถช่วยคุณได้
- เมื่อทำการแก้ไข Code แล้วพบว่ามันเกิดผิดพลาด แล้วต้องการจะย้อนกลับไปก่อนหน้านั้นใหม่
- ต้องการจะ Review History ของ Code ในส่วนที่ต้องการ
- ต้องการที่จะ Share Code ของคุณ หรือสามารถให้คนอื่นๆ มาทำงานใน Code ของคุณได้
- ต้องการทดลองใช้ Feature ใหม่ โดยที่ไม่ต้องไปรบกวน Code ตัวหลักที่กำลังใช้งานอยู่
12. หมั่น Refactor อยู่เสมอ
พยายาม Refactor Code ของคุณอยู่เสมอ เมื่อใดก็ตามที่คุณสังเกตเห็นว่า มีชื่อตัวแปรที่ผิด, มี Code ที่ Duplicate กัน หรือมี Code บางส่วนที่มี Format ผิดปกติไป ก็จงรีบแก้ไขมันให้ถูกต้องซะ ไม่มี Code ใดที่สมบูรณ์แบบ แต่คุณสามารถทำให้มันดีขึ้นกว่าเดิมได้
13. อย่าเขียน Program หละหลวม
จงรู้ถึงผลกระทบของ Code ในแต่ละบรรทัดที่คุณเขียนอยู่เสมอ หากคุณกำลังใช้งาน Library หรือ Framework ก่อนที่จะใช้ Function หรือ Class ใดๆ จงให้สนใจ Code ที่อยู่เบื้องหลังด้วย โดยทั่วไป Code ส่วนใหญ่มี Side Effect ที่คุณอาจไม่รู้ นี่เป็นวิธีที่ Bug อาจเกิดขึ้นใน System ของคุณและมันก็คงไม่ใช่เรื่องง่ายนักที่จะ Debug Error ดังกล่าวเหล่านั้น การที่คุณยอมสละเวลาในการอ่าน Document จะช่วยให้คุณประหยัดเวลาได้มาก
ISM Technology Recruitment Ltd. (#1 Tech Recruiter in Thailand) เราเชี่ยวชาญในธุรกิจ IT Recruitment & IT Outsourcing โดยเฉพาะ เปิดทำการกว่า 28 ปี มีพนักงานทุกสายและทุกระดับทางด้าน IT ที่ได้ร่วมงานกับลูกค้าองค์กรใหญ่ที่มีชื่อเสียงและบริษัทข้ามชาติมากมาย หากคุณเป็นคน IT ที่อยากทำงานท้าทายและร่วมงานกับองค์กรชั้นนำ สามารถฝากประวัติการทำงาน (Resume) ของคุณไว้กับ ISM ได้ที่ https://www.ismtech.net/submit-your-resume แล้วคุณจะพบว่าอนาคตและโอกาสก้าวหน้ากำลังรอคุณอยู่ Source: https://felixmagani.medium.com/5 เทคนิคง่าย ๆ เพื่อปรับปรุง Code ให้ดีขึ้น
Programmer มักจะก็ถูกสอนให้เขียน Code เพื่อทำให้สิ่งต่าง ๆ ทำงานได้ มือใหม่ส่วนใหญ่ก็มักจะเน้นที่ Output และหาก Code ของพวกเขาทำงานได้ดีก็ถือว่างานเสร็จสิ้น ซึ่งมักจะคิดและทำแบบนี้จนติดเป็นนิสัยและลืมคำนึงถึงประสิทธิของมัน และบทความนี้คุณ Shubham Pathania จะมาแนะนำ 5 เทคนิคง่าย ๆ เพื่อปรับปรุง Code ให้ดีขึ้น1. ใช้เวลาให้เต็มที่กับการวิเคราะห์
Programmer ส่วนใหญ่มักจะรีบเขียน Code หลังจากดู Requirements เสร็จ พฤติกรรมแบบนี้พบได้บ่อยในมือใหม่ที่เพิ่งเข้ามาใน Software Industry
พวกเขามักเชื่อว่าการเขียน Code เป็นส่วนสำคัญของการแก้ปัญหา ซึ่งนั่นไม่เป็นความจริงทั้งหมด ดังที่ Senior Developer คนหนึ่งของของคุณ Shubham เคยบอกว่า “จงใช้เวลา 70% ในการวิเคราะห์แล้วค่อยใช้เวลาที่เหลือในการเขียน Code”
วิธีนี้จะช่วยให้คุณไม่ต้องเสียเวลาในการแก้ Bugs และเพิ่มประสิทธิภาพของ Code อีกด้วย คนส่วนใหญ่สามารถเขียน Code ด้วยการหาข้อมูงจาก Google แต่ Programmer ตัวจริงจะรู้วิธีทำการวิเคราะห์ที่เหมาะสมก่อนที่จะรีบเขียน Code
แนวทางปรับปรุง Code:
เมื่อใดก็ตามที่คุณเริ่มทำงานอะไรก็ตาม ให้วิเคราะห์ Code ที่มีอยู่ก่อน ไล่ดู Code และ Debug Function การทำงานที่มีอยู่
จากนั้นให้คุณนึกถึง Solution ที่คุณจะสามารถเพิ่ม Features ของคุณโดยไม่ไปทำลาย Flow ของ Application เมื่อคุณทำเสร็จแล้ว ถึงจะเริ่มเขียน Code
2. มองหาวิธีที่หลากหลายในการแก้ปัญหา
Programmer ส่วนใหญ่มองหาวิธีแก้ปัญหา เมื่อพวกเขาเจอ Solution แล้ว พวกเขาจะย้ายไปสู่ปัญหาอื่น ๆ อย่างไรก็ตามการใช้เวลามากขึ้นในการหาวิธีที่หลากหลายในการแก้ปัญหา มีประโยชน์หลายอย่าง:
- ความคิดเชิงเชิงตรรกะของคุณ จะดีขึ้นเมื่อเวลาผ่านไป
- คุณมีตัวเลือกที่หลากหลายเพื่อเลือกทางออกที่ดีที่สุด
- แนวทางของคุณในการแก้ปัญหาจะดีขึ้น
วิธีนี้จะช่วยให้คุณพัฒนา Critical Thinking ในขั้นตอนของการเขียน Program และ Programmer ที่ดีจะมี Solution ที่หลากหลายเพื่อให้สามารถเลือกสิ่งที่ดีที่สุดได้โดยพิจารณาจาก Speed, Memory และปัจจัยอื่น ๆ
แนวทางปรับปรุง Code:
หากคุณไม่สามารถหาได้มากกว่า 1 Solution ก็ให้ค้นหาผ่านทาง Online แน่นอนว่า คุณจะได้พบแนวทางอื่น ๆ สำหรับปัญหาของคุณบน Platforms ต่าง ๆ เช่น StackOverflow และ CodeProject
ด้วยวิธีนี้ คุณจะพัฒนานิสัยในการมองหาวิธีที่หลากหลายสำหรับแก้ไขแต่ละปัญหาได้ดีขึ้น
3. อย่าสนใจแต่ Code ของตัวเองเพียงอย่างเดียว
เรื่องนี้เป็นจริงในกรณีของการเขียน Code คุณควรอ่าน Code ของคนอื่น และควรทำอย่างนั้นอยู่เสมอ
เราทุกคนมีสไตล์การเขียน Code ที่เป็นเอกลักษณ์ การอ่าน Code ของคนอื่นจะทำให้คุณได้รับข้อมูลในเชิงลึกที่เป็นประโยชน์มากขึ้น
สิ่งนี้จะช่วยให้คุณเข้าใจภาพรวมที่ใหญ่ขึ้นด้วย หากคุณเขียน Code ด้วยตัวเองอยู่เรื่อย ๆ คุณจะไม่คุ้นเคยกับส่วนอื่น ๆ ของ Application ที่คุณไม่ได้ใช้งาน
แนวทางปรับปรุง Code:
เมื่อคุณทำงานเสร็จแล้วให้เริ่มอ่าน Code ที่เขียนโดย Developer คนอื่น ซึ่งจะช่วยให้คุณเข้าใจกระบวนการคิดของพวกเขาและคุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับ Product ของคุณ
4. อย่าลืมที่จะ Test Code ของคุณ
Unit Test ถือเป็นสิ่งสำคัญกว่าที่ Developer จะคิด Programmer มักคิดว่าจุดประสงค์หลักของ Unit Test ก็คือ Code Coverage แต่นั่นไม่เป็นความจริง
Unit Test จะช่วยให้คุณสามารถกำจัด Code ในบรรทัดที่ไม่จำเป็นได้ มันจะช่วยปรับปรุง Code และประสิทธิภาพ Application โดยรวมของคุณ
แนวทางปรับปรุง Code:
ให้เขียน Unit Test Cases สำหรับ Module ของคุณอยู่เสมอ และพยายามทำให้มันครอบคลุม Code ให้มากถึง 90% และลบในส่วนที่ไม่จำเป็นออกในระหว่าง Process หากเป็นไปได้ ก็ให้พูดคุยกับ Developer คนอื่น ๆ เกี่ยวกับ Scenario ต่าง ๆ เพื่อที่คุณจะได้ไม่พลาดในสิ่งที่สำคัญ ๆ ไป
5. Update ตัวเองก่อนจะ Update Code
หากคุณไม่ได้ Update Features เกี่ยวกับเทคโนโลยีล่าสุดอยู่เสมอ คุณจะแน่ใจได้อย่างไรว่า Code ของคุณเป็นข้อมูลที่ Update ล่าสุด
สาเหตุที่ Software ส่วนใหญ่ใช้งานไม่ได้เมื่อเวลาผ่านไป ก็เป็นเพราะ Developer มักจะละเลยที่จะ Update Code เพื่อเพิ่มประสิทธิภาพ ตัวอย่างเช่น ลองดู C# Code ที่ด้านล่างนี้:
ถ้าเป็นแนวทางเดิม เราจะตรวจสอบก่อนว่า Object นั้นเป็น Null หรือไม่ จากนั้นเราจะตรวจสอบว่า มีค่าอยู่ภายใน Object นั้นหรือไม่ หลังจากนั้นเราก็ Assign ค่านั้นให้กับตัวแปร
แต่หากเป็นแนวทางใหม่ เรากำลังใช้ C# Feature ใหม่ ซึ่งมีอยู่ใน Version 6.0 สิ่งนี้จะช่วยให้เราสืบค้น Object Properties ได้โดยตรง และในกรณีที่ Property เป็น Null แทนที่มันจะ Throw Null Reference Exception มันจะ Return ค่า Null กลับมาให้
นี่เป็นตัวอย่างหนึ่งของวิธีที่เราสามารถลดความซับซ้อนและเพิ่มประสิทธิภาพ Code ของเราด้วย Features ใหม่ในภาษา Programming
แนวทางปรับปรุง Code:
ให้ติดตาม Blogs ต่าง ๆ เกี่ยวกับเทคโนโลยี และอ่าน Documentation เกี่ยวกับ Features ใหม่ ๆ จากนั้นลองใช้ใน Project ส่วนตัวของคุณและถ้าเป็นไปได้ให้นำไปใช้ใน Project งานของคุณด้วย
ด้วยวิธีการนี้จะช่วยให้คุณ Update อยู่เสมอ และคุณสามารถทำให้ Code ของคุณมีประสิทธิภาพและทันสมัยอยู่เสมอ