Clean Code สำหรับมือใหม่: 5 เรื่องพื้นฐานที่ควรเริ่มให้ดี

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

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

1) ตั้งชื่อตัวแปรให้สื่อความหมาย

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

ชื่อตัวแปรแบบ a, data, temp หรือ x1 อาจเขียนได้เร็วในตอนแรก แต่เมื่อกลับมาอ่านภายหลัง มักทำให้เสียเวลาไล่ดูว่าแต่ละค่ามีไว้ใช้ทำอะไร

ตัวอย่าง:

// bad
let d = 1200

// better
let totalPrice = 1200

ชื่ออย่าง totalPrice, userAge หรือ isLoggedIn ช่วยให้เข้าใจบริบทได้ทันทีโดยแทบไม่ต้องเปิดโค้ดส่วนอื่นประกอบ การตั้งชื่อที่ดีจึงเป็นการประหยัดเวลาเล็ก ๆ ที่ให้ผลคุ้มค่าทุกวัน

2) 1 ฟังก์ชัน ควรมีหน้าที่หลักอย่างเดียว

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

แนวคิดที่ควรใช้คือแยกหน้าที่ออกจากกันให้ชัด เช่น

• calculateDiscount() สำหรับคำนวณส่วนลด
• renderPrice() สำหรับแสดงราคา
• sendReceiptEmail() สำหรับส่งอีเมลใบเสร็จ

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

3) เลี่ยงการเขียนซ้ำ

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

ตัวอย่างงานที่มักถูกเขียนซ้ำ เช่น

• การจัดรูปแบบเบอร์โทร
• การตรวจสอบ email
• การแปลงข้อมูลก่อนแสดงผล

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

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

4) ใส่คอมเมนต์เท่าที่จำเป็น

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

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

ตัวอย่าง:

• ไม่ค่อยช่วย: เพิ่มค่า i ทีละ 1
• มีประโยชน์กว่า: ต้องวนทีละ 1 เพื่อให้ตรงกับ index ของ API ภายนอก

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

5) จัดรูปแบบโค้ดให้สม่ำเสมอ

แม้ logic จะดีแค่ไหน แต่ถ้ารูปแบบโค้ดไม่สม่ำเสมอ เช่น spacing ไม่ตรง การเยื้องไม่เท่ากัน หรือรูปแบบการตั้งชื่อปะปนกัน โค้ดก็ยังอ่านยากอยู่ดี

การใช้เครื่องมืออย่าง Prettier สามารถช่วยจัด format ให้สม่ำเสมอได้ทันที และหากทำงานเป็นทีม ก็ควรมีกติกาพื้นฐานร่วมกัน เช่น

• ใช้ camelCase กับชื่อตัวแปร
• ตั้งชื่อฟังก์ชันเป็นคำกริยา
• ใช้รูปแบบการเปิดปีกกาแบบเดียวกันทั้งโปรเจกต์

ความสม่ำเสมอช่วยลดภาระทางสายตาและทำให้สมองโฟกัสกับ logic สำคัญได้เต็มที่ แทนที่จะเสียพลังไปกับรายละเอียดจุกจิก

Clean Code ไม่ได้แปลว่าโค้ดต้องสั้นที่สุด

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

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

วิธีเริ่มต้นแบบเอาไปใช้ได้ทันที

หากยังไม่รู้จะเริ่มฝึก Clean Code จากตรงไหน ลองเริ่มจากเช็กลิสต์ง่าย ๆ ต่อไปนี้

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

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

สรุป

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

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