การเขียนโค้ดไม่เพียงแค่ต้องทำให้มันทำงานได้เท่านั้น แต่การเขียนโค้ดที่ดี คือการทำให้มันสะอาด (Clean) อ่านง่าย และสามารถบำรุงรักษาได้ในระยะยาว ซึ่งเป็นสิ่งที่โปรแกรมเมอร์ทุกคนควรเรียนรู้และปฏิบัติตาม

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

ทำไม Clean Code ถึงสำคัญ?

การเขียน Clean Code คือการสร้างโค้ดที่ไม่เพียงแค่ทำให้มันทำงานได้ตามที่คาดหวังในตอนนี้ แต่ยังต้องคำนึงถึงการใช้งานในอนาคตด้วย โดยเฉพาะเมื่อโปรเจกต์ของเรามีการขยายตัว หรือหากคนอื่นต้องมาทำงานร่วมกับเรา การที่โค้ดสะอาดและเข้าใจง่ายจะทำให้การปรับปรุงหรือการแก้ไขในอนาคตเป็นไปได้อย่างรวดเร็วและไม่มีปัญหาซับซ้อน

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

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

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

1. ใช้ชื่อที่มีความหมาย

หนึ่งในหลักการสำคัญของการเขียน Clean Code คือการใช้ชื่อที่มีความหมายและสามารถเข้าใจได้ง่าย การตั้งชื่อให้กับตัวแปร ฟังก์ชัน หรือคลาส ควรมีความชัดเจนในตัวเองและสะท้อนถึงบทบาทหรือฟังก์ชันการทำงานของมัน ซึ่งจะช่วยให้คนที่อ่านโค้ด (ไม่ว่าจะเป็นตัวคุณเองหรือคนอื่นในทีม) สามารถเข้าใจได้อย่างรวดเร็วว่ามันทำงานอะไร

ตัวอย่าง: ถ้าคุณกำลังสร้างฟังก์ชันที่ใช้ในการคำนวณราคาสินค้า ฟังก์ชันที่ชื่อว่า calculate() อาจดูไม่ชัดเจนพอว่า "คำนวณอะไร?" ดังนั้น ฟังก์ชันที่ชื่อว่า calculatePrice() หรือ calculateTotalPrice() จะช่วยให้ผู้ที่อ่านโค้ดเข้าใจได้ทันทีว่า ฟังก์ชันนี้มีหน้าที่คำนวณราคาสินค้า หรือราคาทั้งหมด

การตั้งชื่อที่ดีช่วยให้โค้ดของคุณอ่านง่ายขึ้น และทำให้การบำรุงรักษาโค้ดในอนาคตสะดวกขึ้นด้วย เพราะมันลดการสับสนเกี่ยวกับบทบาทและการใช้งานของแต่ละส่วนของโค้ด

ข้อแนะนำ

• ใช้ชื่อที่บอกถึงสิ่งที่ตัวแปรหรือฟังก์ชันนั้น ๆ ทำหรือเก็บข้อมูล เช่น userName แทน name หรือ getTotalAmount() แทน calculate()
• หลีกเลี่ยงการใช้ชื่อที่ไม่เกี่ยวข้องหรือกว้างเกินไป เช่น data , info , หรือ temp เพราะมันไม่บอกว่าใช้งานอะไร
• ถ้าฟังก์ชันทำหลายสิ่งมากเกินไป ควรพิจารณาแยกออกเป็นฟังก์ชันย่อยเพื่อให้ง่ายต่อการเข้าใจและการทดสอบ

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

2. ทำให้ฟังก์ชันสั้นและกระชับ

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

หลักการที่ควรทำ

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

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

python

# ฟังก์ชันที่ทำหลายอย่าง
def calculatePrice(item):
   discount = item['price'] * 0.1
   price_after_discount = item['price'] - discount
   tax = price_after_discount * 0.07
   total_price = price_after_discount + tax
   return total_price
   
# ฟังก์ชันที่แยกออกมาให้สั้นและเข้าใจง่าย
def calculateDiscount(price):
   return price * 0.1
   
def calculateTax(price):
   return price * 0.07
   
def calculatePrice(item):
   discount = calculateDiscount(item['price'])
   price_after_discount = item['price'] - discount
   tax = calculateTax(price_after_discount)
   total_price = price_after_discount + tax
   return total_price

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

3. หลีกเลี่ยงการซ้ำซ้อน

การซ้ำซ้อนในโค้ด (Code Duplication) คือหนึ่งในสิ่งที่ควรหลีกเลี่ยงอย่างยิ่งในการเขียน Clean Code หากพบว่าโค้ดที่ทำงานเหมือนกันถูกเขียนซ้ำในหลายๆ ส่วนของโปรแกรม สิ่งนี้จะทำให้โค้ดยากต่อการบำรุงรักษาและอาจนำไปสู่ข้อผิดพลาดได้ง่ายเมื่อมีการเปลี่ยนแปลงหรืออัปเดตโค้ดในอนาคต

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

หลักการที่ควรทำ

• แยกโค้ดที่ซ้ำออกเป็นฟังก์ชันหรือคลาส: หากคุณพบว่ามีการคำนวณหรือประมวลผลเหมือนกันในหลายๆ ที่ ควรแยกโค้ดเหล่านั้นออกมาเป็นฟังก์ชันหรือคลาสที่ทำงานเดียวกันได้อย่างชัดเจน
• ใช้เครื่องมือช่วย: เครื่องมืออย่าง IDE (Integrated Development Environment) หรือแม้แต่เครื่องมือค้นหาหรือการค้นหาคำที่ซ้ำกันในโค้ดจะช่วยให้คุณสามารถหาส่วนที่ซ้ำซ้อนได้เร็วขึ้น

ตัวอย่าง: สมมุติว่าเรามีโค้ดที่คำนวณส่วนลดและค่าภาษีในหลายๆ จุดของโปรเจกต์ ซึ่งทำให้เกิดการซ้ำซ้อนในโค้ด หากเราปล่อยให้โค้ดแบบนี้มีอยู่ โค้ดจะยากต่อการปรับปรุงและบำรุงรักษาในระยะยาว

โค้ดที่มีการซ้ำซ้อน:

python

# คำนวณส่วนลด
discount1 = price * 0.1
# คำนวณภาษี
tax1 = price * 0.07

# โค้ดซ้ำอีกที่หนึ่ง
discount2 = price2 * 0.1
tax2 = price2 * 0.07

การหลีกเลี่ยงการซ้ำซ้อน:

python

def calculate_discount(price):
   return price * 0.1
   
def calculate_tax(price):
   return price * 0.07
   
# ใช้ฟังก์ชันในการคำนวณที่ซ้ำซ้อน
discount1 = calculate_discount(price)
tax1 = calculate_tax(price)

discount2 = calculate_discount(price2)
tax2 = calculate_tax(price2)

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

4. การใช้คอมเมนต์ที่ชัดเจน

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

หลักการที่ควรทำ

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

ตัวอย่าง:

โค้ดที่ไม่มีคอมเมนต์:

python

def calculate_area(radius):
   return 3.14 * radius * radius

โค้ดที่มีคอมเมนต์:

python

def calculate_area(radius):
   # การใช้ค่า π ประมาณ 3.14 ในการคำนวณพื้นที่วงกลม
   return 3.14 * radius * radius

ในกรณีนี้ โค้ดนั้นค่อนข้างเข้าใจได้ง่าย และการคอมเมนต์ที่อธิบายว่าเรากำลังใช้ค่าประมาณของ π นั้นเป็นสิ่งที่จำเป็น เพราะในอนาคตอาจมีคนมาแก้ไขโค้ดและอาจไม่ทราบว่าเลือกใช้ค่าคงที่ 3.14 เป็นการประมาณ π

ตัวอย่างที่เหมาะสมในการใช้คอมเมนต์เพิ่มเติม:

python

def parse_data(data):
   # เช็คว่า data เป็นข้อมูลที่เป็น JSON หรือไม่
   if not isinstance(data, dict):
       raise ValueError("Input data must be a dictionary")
   return data

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

5. ทดสอบโค้ดอย่างสม่ำเสมอ

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

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

หลักการที่ควรทำ

• เขียนเทสสำหรับฟังก์ชันทุกฟังก์ชัน: ฟังก์ชันทุกตัวที่คุณเขียนควรจะมีการทดสอบที่ชัดเจน โดยเฉพาะฟังก์ชันที่มีลอจิกหรือคำนวณข้อมูลที่สำคัญ
• ทดสอบแบบอัตโนมัติ (Automated Testing): การใช้เครื่องมือในการทดสอบอัตโนมัติ เช่น JUnit หรือ PyTest จะช่วยให้คุณสามารถทดสอบโค้ดได้ทุกครั้งที่มีการเปลี่ยนแปลง และมั่นใจได้ว่าไม่มีข้อผิดพลาด
• ทดสอบในหลายกรณี (Edge Cases): อย่าลืมทดสอบโค้ดในกรณีที่คาดไม่ถึง เช่น ข้อมูลที่เป็นค่าผิดปกติ หรือข้อมูลที่ไม่คาดคิดว่าจะได้รับเข้ามา ซึ่งจะช่วยให้โค้ดของคุณแข็งแรงขึ้น

ตัวอย่าง:

python

def add_numbers(a, b):
   return a + b
   
# ทดสอบการเพิ่มตัวเลขสองตัว
def test_add_numbers():
   assert add_numbers(3, 5) == 8
   assert add_numbers(-1, 1) == 0
   assert add_numbers(0, 0) == 0
   print("All tests passed!")
   
# เรียกใช้ฟังก์ชันทดสอบ
test_add_numbers()

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

6. ทำให้โค้ดง่ายต่อการขยาย (Extensibility)

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

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

แนวทางการทำให้โค้ดขยายได้ง่าย

• ใช้หลักการ SOLID: การใช้หลักการ SOLID (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) จะช่วยให้โค้ดของคุณมีความยืดหยุ่นและสามารถขยายได้ง่าย
• แยกฟังก์ชันที่ทำงานต่างกันออกจากกัน: หากโค้ดทำหลายสิ่งในฟังก์ชันเดียว การแยกฟังก์ชันออกมาให้รับผิดชอบเพียงอย่างเดียว จะทำให้การขยายฟังก์ชันในอนาคตง่ายขึ้น
• ใช้ OOP (Object-Oriented Programming): หลักการเขียนโปรแกรมเชิงวัตถุจะช่วยให้การขยายโค้ดในอนาคตเป็นไปได้ง่ายขึ้น เพราะคุณสามารถสร้างคลาสใหม่ที่สืบทอดคุณสมบัติจากคลาสเดิมได้
• หลีกเลี่ยงการเขียนโค้ดที่แข็งตัว (Hardcoding): การเขียนโค้ดที่ไม่ยืดหยุ่นทำให้การขยายและการปรับปรุงเป็นเรื่องยาก เช่น การระบุค่าคงที่ในโค้ดโดยตรง การใช้ตัวแปรที่สามารถกำหนดค่าใหม่ได้จะทำให้โค้ดขยายได้ง่ายกว่า

ตัวอย่างการใช้ OOP ในการขยายโค้ด:

python

# คลาสพื้นฐาน
class Animal:
   def make_sound(self):
       raise NotImplementedError("Subclass must implement abstract method")
       
# คลาสสืบทอด
class Dog(Animal):
   def make_sound(self):
       return "Woof!"
       
class Cat(Animal):
   def make_sound(self):
       return "Meow!"
       
# การขยายโค้ดง่าย
animals = [Dog(), Cat()]

for animal in animals:
   print(animal.make_sound())

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

สรุป

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

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

🔵 Facebook: Superdev School  (Superdev)

📸 Instagram: superdevschool

🎬 TikTok: superdevschool

🌐 Website: www.superdev.school