จาก blog เรื่องของ Refactoring Rule of Three นั้น
อธิบายไปอาจจะเห็นภาพไม่ชัดเจนเท่าไรนัก
ดังนั้น เรามาลองเขียน code กันดีกว่า …
โดยเป้าหมายคือ
จะทำการแยกส่วนการทำงานที่มันซ้ำกัน 3 ครั้งออกไปจาก code ของเรา
มาเริ่มกันเลย !!
แนวคิดเบื้องต้น
เราต้องการเข้าใจ code ให้ดีขึ้น
ซึ่งเป็นหัวใจหลักของการ refactoring
โดยเราจะทำการนำแนวคิดการแบ่งส่วนการทำงานต่างๆ ออกจากกัน
นั่นคือ
เราจะทำการสร้าง method เล็กๆ
เราจะทำการสร้าง class
เราจะทำการสร้าง module
ดังนั้นถ้าเมื่อไรที่เราเจอ ugly code แล้ว
เราต้องทำความเข้าใจการทำงาน ugly code
เราต้องทำความเข้าใจโครงสร้างของ ugly code
และเราต้องเห็น duplication code ใน ugly code แบบชัดเจนให้ได้ เช่น
- พวก magic number
- พวก magic string
- constant ต่างๆ
- ตัวแปรต่างๆ
- ชุดของ code
- Method, class และอื่นๆ อีกมากมาย
มาดูตัวอย่างกันดีกว่า
จาก code เราเห็นอะไรบ้าง ?
เราเห็นว่า code มันใช้งาน System.out.println() ซ้ำกันถึง 4 ครั้ง
แต่มันไม่ซ้ากันจริงๆ นะเพราะว่า มี parameter ที่ส่งไปต่างกัน
ซึ่งมันเรียกว่า partial duplication หรือ ซ้ำกันบางส่วน
ดังนั้น สิ่งที่เราต้องทำก็คือ
ทำให้มันเกิด Truly duplication กันขึ้นมาให้ได้
คำถาม
เราจะทำอย่างไรดีล่ะ ?
คำตอบ
ต้องทำให้ code ใน System.out.println() มันเหมือนกันแบบชัดเจน !!
นั้นคือการสร้างตัวแปรขึ้นมา ดังนี้
มาถึงตรงนี้ เราจะว่า code มันซ้ำกันแบบชัดเจนถึง 4 ครั้ง !!
ดังนั้นได้เวลาที่ต้อง refactor code
ด้วยการ extract ออกมาเป็น method ใหม่ชื่อว่า showMessageOnConsole() ดังนี้
โดยผมทำการ refactor ด้วยการ Extract to new method ใน IntelliJ
ซึ่งมันจะบอกเราว่ามี code ที่เหมือนกัน
และจะ refactor code ให้เราแบบอัตโนมัติดังรูป
และผลจากการ refactor code ได้ผลดังนี้
คำถาม
เราเห็นอะไรจาก code ?
คำตอบ
เห็นไหมว่า ตัวแปร message มันใช้เพียงครั้งเดียว
ซึ่งเราก็ไม่น่าจะต้องสร้างเป็นตัวแปรนะครับ !!
ดังนั้น ให้ทำการ refactor code ด้วยการใช้ Inline temporary
ได้ผลดังนี้
จะเห็นได้ว่า
เมื่อเราใช้ Rule of Three ในการ refactor code
เราสามารถแยกการทำงานที่มันซ้ำออกมาเป็น method ใหม่ได้ทันที
ยิ่งใช้งานผ่านเครื่องมือที่ดี ก็จะยิ่งช่วยอำนวยความสะดวก
ไม่ต้องมานั่งเสียเวลาแก้ไขทีละจุด
แต่เราต้องทำให้ code ส่วนนั้นมันเหมือนกันจริงๆ (Truely duplication)
ไม่ใช่เพียงแค่ duplication ในความหมายของการทำงานเท่านั้นนะครับ
จากตัวอย่างมันเห็น duplication ได้ง่าย
เพราะว่า มันคือส่วนที่เล็กมากๆ นั่นคือ statement
ลองคิดดูสิว่า …
ถ้าเป็นระดับ method, class และ module
มันจะหา Truely duplication ได้ยากเพียงใด !!
ถ้าเรานำ Rule of Three มาใช้ตั้งแต่เริ่มพัฒนา
มันจะช่วยตัดปัญหาตั้งแต่ต้นลม
นั่นคือ ทำให้เรา refactoring จากปัญหาเล็กๆ
ซึ่งจะช่วยลดปัญหาเรื่อง duplication code ลงไปอย่างมาก
ดังนั้นลองนำไปฝึกใช้ดูครับ
โดยมันยังมีกรณีอื่นๆ อีกมากมาย
เช่น constant, variable, method และ class
อย่าหยุดที่จะเรียนรู้ และ ลงมือปฏิบัตินะครับ
