# หลักการ Clean Code ของคุณ Robert C. Martin และวิธีการเขียน Class อย่างมีคุณภาพ
การเขียนโปรแกรมถือเป็นศิลปะเช่นเดียวกับวิทยาศาสตร์ และหนึ่งในมาสเตอร์พีซของพัฒนาโปรแกรมคือการเขียนโค้ดที่สะอาดและอ่านได้ง่าย หลักการ Clean Code ที่จัดทำขึ้นโดย Robert C. Martin หรือที่เรารู้จักกันในชื่อ Uncle Bob ให้คำแนะนำที่ชัดเจนเกี่ยวกับวิธีการสร้างโค้ดที่ดี ในบทความนี้ เราจะสำรวจหลักการเหล่านี้ในบริบทของการเขียน class ในโปรแกรม
ก่อนที่เราจะดำดิ่งลงไปในโครงสร้างของ class ที่สะอาดนั้น เราต้องเข้าใจก่อนว่า Clean Code หมายถึงอะไร Robert C. Martin นิยามว่า Clean Code คือโค้ดที่ได้รับการเขียนอย่างมีการวางแผน และง่ายต่อการอ่าน เข้าใจ และแก้ไขโดยนักพัฒนาคนอื่น ๆ นอกเหนือจากผู้สร้างมันเอง
เมื่อพูดถึง class หลักการ Clean code แนะนำให้นักพัฒนาสร้างโครงสร้างที่มีคุณภาพสูง ดังต่อไปนี้:
1. Single Responsibility Principle (SRP)
หลักการนี้กล่าวว่า "class ควรมีเหตุผลที่จะเปลี่ยนแปลงเพียงอย่างเดียว" หรือความหมายข้ามคือ class ควรมีงานที่ทำเพียงอย่างเดียว เพื่อลดความซับซ้อนและทำให้โค้ดง่ายต่อการจัดการ
public class InvoiceCalculator {
public decimal CalculateInvoice(Invoice invoice) {
// โค้ดที่คำนวณใบแจ้งหนี้จะอยู่ที่นี่
}
}
2. Open/Closed Principle (OCP)
หลักการนี้หมายความว่า "class ควรเปิดให้ขยาย (extend) แต่ปิดให้การแก้ไข" ซึ่งหมายความว่าคุณควรสามารถเพิ่มฟังก์ชันการทำงานโดยไม่ต้องเปลี่ยนโค้ดที่มีอยู่
public abstract class Shape {
public abstract double area();
}
public class Circle extends Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
public double area() {
return Math.PI * radius * radius;
}
}
3. Liskov Substitution Principle (LSP)
หลักการนี้บอกว่า "ออบเจ็คต์ในโปรแกรมควรสามารถสับเปลี่ยนกันได้ด้วยออบเจ็คต์จาก subclass ของมันโดยที่ไม่ทำให้แอปพลิเคชันนั้นมีสิ่งที่ผิดพลาด"
public void DrawAllShapes(List allShapes) {
for (Shape shape : allShapes) {
Console.WriteLine(shape.area());
}
}
4. Interface Segregation Principle (ISP)
หลักการนี้แนะนำว่า "ไม่ควรบังคับให้ client implement interface ที่เขาไม่ใช้" นั่นหมายความว่า interface ควรแยกย่อยออกเป็นกลุ่มฟังก์ชันที่เล็กกว่า ซึ่งเกี่ยวข้องกันในลักษณะที่ง่ายต่อการจัดการ และไม่เกินความต้องการจริง
public interface IShape {
double area();
}
public interface IManageableShape {
void move(double x, double y);
void rotate(double angle);
}
public class Rectangle implements IShape, IManageableShape {
// ...
}
5. Dependency Inversion Principle (DIP)
หลักการสุดท้ายนี้หมายถึง "High-level modules ไม่ควรขึ้นอยู่กับ low-level modules ทั้งสองควรขึ้นอยู่กับ abstractions" ที่นี่ abstractions หมายถึง interface หรือ class ฐานที่ไม่มีการเฉพาะ
public class Button {
private Command command;
public Button(Command command) {
this.command = command;
}
public void click() {
command.execute();
}
}
public interface Command {
void execute();
}
Clean Code ไม่เพียงแต่ทำให้โค้ดของเราดูดีขึ้น แต่ยังช่วยให้การประกอบร่างของโค้ดมีระเบียบและนำไปสู่ผลลัพธ์ที่แข็งแกร่งกว่า การฝึกฝนหลักการเหล่านี้ในการเขียน class และโปรแกรมทั้งหมดจะทำให้ทักษะการพัฒนาโปรแกรมของคุณต่างไปจากเดิม และแน่นอนว่านี่เป็นเพียงส่วนหนึ่งของการเป็นนักพัฒนาที่ดี
ที่ Expert-Programming-Tutor (EPT), เรามุ่งมั่นที่จะฝากฝังหลักการสำคัญเหล่านี้ให้กับนักศึกษาของเรา เพื่อที่พวกเขาจะสามารถสร้างผลผลิตของโค้ดที่สะอาด รักษาได้ง่าย และนำไปใช้งานได้จริง หากคุณมีความสนใจที่จะเรียนรู้และพัฒนาการเขียนโปรแกรมของคุณถึงระดับถัดไป การเรียนรู้ทักษะในที่มีคุณภาพกับ EPT นั้นเป็นจุดเริ่มต้นที่ยอดเยี่ยม!
หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง
หากเจอข้อผิดพลาด หรือต้องการพูดคุย ติดต่อได้ที่ https://m.me/expert.Programming.Tutor/
หากมีข้อผิดพลาด/ต้องการพูดคุยเพิ่มเติมเกี่ยวกับบทความนี้ กรุณาแจ้งที่ http://m.me/Expert.Programming.Tutor
085-350-7540 (DTAC)
084-88-00-255 (AIS)
026-111-618
หรือทาง EMAIL: NTPRINTF@GMAIL.COM