วิธีสร้างวินัยให้กับโค้ดของคุณด้วยการปรับโครงสร้างใหม่ (รวมถึงตัวอย่าง PHP)

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

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

ข้อเสียของรหัสที่ไม่สะอาด

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

1. จะเพิ่มค่าบำรุงรักษาของโครงการ
2. การเพิ่มคุณสมบัติใหม่ใช้เวลานานและบางครั้งก็เพิ่มไม่ได้
3. ทำให้การแนะนำคนใหม่ในโครงการช้าลง
4. มันมีรหัสที่ซ้ำกัน
5. ไม่ผ่านการทดสอบทั้งหมด

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

ข้อดีของ Clean Code

รหัสที่สะอาดและมีระเบียบวินัยมีข้อดีของตัวเอง:

1. ไม่มีรหัสที่ซ้ำกัน
2. มันผ่านการทดสอบทั้งหมด
3. ทำให้โค้ดอ่านง่ายขึ้นและเข้าใจง่ายขึ้น
4. ทำให้รหัสง่ายต่อการบำรุงรักษาและราคาไม่แพง

ข้อดีของคลีนโค้ดมีมากมาย กระบวนการในการเปลี่ยนรหัสที่ไม่สะอาดที่ยุ่งเหยิงให้เป็นรหัสที่สะอาดซึ่งดูแลรักษาได้มากกว่านั้นเรียกว่ากระบวนการ Refactoring

กระบวนการปรับโครงสร้างใหม่

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

เมื่อใดควรปรับโครงสร้างใหม่

ควรทำการปรับโครงสร้างใหม่เมื่อ:

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

จัดการกับกลิ่นโค้ด

ปัญหาเกี่ยวกับโค้ดบางครั้งเรียกว่ากลิ่นโค้ด ปัญหาเหล่านี้ได้รับการแก้ไขแล้วในระหว่างการปรับโครงสร้างใหม่ ง่ายต่อการค้นหาและแก้ไข

ตัวอย่างเช่น:

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

เทคนิคการปรับโครงสร้างใหม่

เทคนิคการ Refactoring เป็นขั้นตอนในการปรับโครงสร้างโค้ด เทคนิคการรีแฟคเตอร์บางส่วน ได้แก่

1. วิธีการสกัด

// ปัญหา

 function printInvoice() { $this->printHeader(); // Print details. print("name: " . $this->name); print("amount " . $this->getPrice()); }

// สารละลาย

 function printInvoice() { $this->printBanner(); $this->printDetails($this->getPrice()); } function printDetails($price) { print("name: " . $this->name); print("amount " . $outstanding); }

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

2. แยกตัวแปร

// ปัญหา

 if (($student->getMarksinMath() > 60) && ($student->getMarksInPhysics() > 60) && ($student->getMarksinChemistry() > 60) && $this->pass) { // do something }

// สารละลาย

 $mathResult = $student->getMarksinMath() > 60; $physicsResult = $student->getMarksinPhysics() > 60; $chemistryResult = $student->getMarksinChemistry() > 60; $hasPassed = $this->pass; if ($mathResult && $physicsResult && $chemistryResult && $hasPassed) { // do something }

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

3. วิธีการแบบอินไลน์

// ปัญหา

 function printResult() { return ($this->getResult()) ? “Pass” : “Fail”; } function getResult() { return $this->totalMarks > 300; }

// สารละลาย

 function getRating() { return ($this->totalMarks > 300) ? “Pass” : “Fail”; }

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

4. Inline Temp

// ปัญหา

 $mathMark = $student->getMathResult(); return $mathMark > 60;

// สารละลาย

 return $student->getMathResult() > 60;

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

5. แทนที่อาร์เรย์ด้วยวัตถุ

// ปัญหา

 $row = []; $row[0] = "Virat Kohli"; $row[1] = 70;

// สารละลาย

 $row = new Player(); $row->setName("Virat Kohli"); $row->setNumberofCentury(70);

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

6. วิธีการกำหนดพารามิเตอร์

// ปัญหา

 function fivePercentRaise() { } function tenPercentRaise() { }

// สารละลาย

 function raise(percent) { }

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

7. แยกข้อความค้นหาออกจากตัวแก้ไข

// ปัญหา

 function getInterest() { $this->interestAmount = $this->principal * 10 / 100; return $this->interestAmount; }

// สารละลาย

 function setInterest() { $this->interestAmount = $this->principal * 10 / 100; } function getInterest() { return $this->interestAmount; }

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