Traits

นโรดม ทรัพย์มูล 640710533

PHP Traits คืออะไร

ก่อนเราที่จะเราจะพูดถึง Traits ใน PHP คืออะไร เรามาทำความเข้าใจเกี่ยวกับ การสืบทอด ในภาษา PHP หรือ ชื่อที่เราคุ้นเคย inheritance ในภาษา PHP โดยเฉพาะโครงสร้างการเขียนเชิงวัตถุแบบ OOP (Object-Oriented Programming) นั้น PHP จะมีการรองรับ การสืบทอดแบบเดี่ยว (Single inheritance) ซึ่งจะหมายความว่า คลาสลูก (subclass) สามารถสืบทอดจาก คลาสแม่ (parent class) ได้เพียงคลาสเดียวเท่านั้น ตัวอย่าง การสืบทอดแบบเดี่ยว คือจะใช้ extends ในการสืบทอด ความสามารถของคลาสแม่ ไปยัง คลาสลูก

class Animal {
    public function sound() {
        echo "Animal makes a sound";
    }
}
class Cat extends Animal {
    public function sound() {
        echo "Cat: meow meow ";
    }
}
$dog = new Dog();
$dog->sound();  // output คือ meow meow 

PHP ไม่ได้มีการรองรับการสืบทอดหลายคลาส (multiple inheritance) จึงเป็นข้อจำกัดที่ PHP จะความสามารถของแต่ละคลาสมารวมๆกันในคลาสเดียว ตัว Traits ใน PHP นี่เองจะเข้ามาช่วยให้การใช้งานฟังก์ชันการทำงานจากหลายๆ คลาสเป็นเรื่องง่ายขึ้น

ผมสงสัยครับ!!! ถ้าผมอยากจะสืบทอดหลายๆคลาสจะทำยังไงต่อล่ะ? ในเมื่อ PHP ไม่มีการรองรับการสืบทอดแบบหลายคลาส (multiple inheritance)

คำตอบคือ....Traits

Traits ใน PHP มีหน้าที่ ที่คล้ายกับ interface ในภาษา Java , ตัว Traits เองเหมือนกับ class แต่จะไม่มีการเขียน อินสแตนซ์ โดยแต่ละ Traits ข้างในก็จะมีฟังก์ชันการทำงานของมัน ประโยชน์คือ Traits A และ Traits B ถูกเรียกใช้ไป Class C โดยจะใช้คำว่า use ในการเรียกใช้ได้โดยไม่ต้องสนใจการสืบทอดหรือการ implement ใดๆ

Trait A และ Trait B ที่ถูก Class C เรียกใช้งาน

ตัวอย่างการสร้างและการใช้ Traits

trait Users {
    // ฟังชั่นการทำงานใน Trait Users 
}

ตัวอย่างการสร้าง Trait ให้ชัดเจนมากขึ้น

trait Users {
    public $firstname; 
    public $lastname;
    
    public function setFirstname($fn){ //กำหนดชื่อจริง
        $this->$firstname = $fn;
    }
    public function setLastname($ln){ //กำหนดนามสกุล
        $this->$lastname = $ln;
    }
    public function getName(){ //คืนค่า ชื่อจริง-นามสกุล 
        return  $this->firstname . ' ' . $this->lastname;
    }
}
class Employee { // คลาส Employee ทำการเรียกใช้ Traits Users
    use Users;
}
$employee = new Employee(); //สร้างอินสแตนซ์ employee 
$employee->setFirstname("Narodom"); 
$employee->setLastname("Supmoon");

echo $employee->getName(); //จะได้คำตอบเป็น Narodom Supmoon 

output: Narodom Supmoon 

นอกจากนี้เราเรียกใช้ Traits หลายๆอันพร้อมกันได้ด้วย (Multiple Traits) Ex:

MultipleTraits

trait Users {
    public $firstname; 
    public $lastname;
    
    public function setFirstname($fn){ //กำหนดชื่อจริง
        $this->firstname = $fn;
    }
    public function setLastname($ln){ //กำหนดนามสกุล
        $this->lastname = $ln;
    }
    public function getName(){ //คืนค่า ชื่อจริง-นามสกุล 
        return $firstname.' '.$lastname;
    }
}

trait Age {
    public $age;
    
    public function setAge($_age){
        $this->age = $_age;
    }
    public function getAge(){
        return $age;
    }
}

trait job {
    public $jobTitle;

    public function setJobTitle($title) {
        $this->jobTitle = $title;
    }
    public function getJobTitle() {
        return $this->jobTitle;
    }
}

class Employee { // คลาส Employee ทำการเรียกใช้ Traits Users,Age,Job
    use Users , Age, Job;
    
    public function showDetails() {
        echo "Name: " . $this->getName() . "\n";
        echo "Age: " . $this->getAge() . "\n";
        echo "Job Title: " . $this->getJobTitle() . "\n";
    }
}
$employee = new Employee(); //สร้างอินสแตนซ์ employee 
$employee->setFirstname("Narodom"); 
$employee->setLastname("Supmoon");
//ส่วนเพิ่มเติมเข้ามา
$employee->setAge(23);
$employee->setJob("Dev");

$employee->showDetails();

output: 
        Name: Narodom Supmoon
        Age: 23
        Job Title: Dev

จากตัวอย่าง จะเห็นว่าเราสามารถเรียกใช้ Traits ได้หลายๆ traits พร้อมกันได้โดยใช้คำว่า use ง่ายๆและไม่ได้สนใจการสืบทอดหรือimplement ใดๆ เราจะวิเคราะห์ได้จากตัวอย่าง หากมีการทำงานที่ซ้ำๆกัน การใช้ Traits จะช่วยลดความซับซ้อนในการใช้งานและเป็นระเบียบมากขึ้น Multiple Traits จะให้ความคลายกับ interface ในภาษา Java ซึ่งมีความสามารถคล้ายๆกัน

ผมสงสัยอีกแล้วอะครับ!!!(ขี้สงสัยจังอะ) ภาษาอื่นๆ เช่น Java , c , python มีการทำงานที่คล้ายกับ Trait ไหมอะครับ

Java, C, Python มีการทำงานที่คล้ายกับ Traits ไหมอะครับ?

คำตอบคือ....มีครับน้อง!!!

PHP มี Traits จัดการการสืบทอด ภาษาอื่นๆก็มี Traits ในแบบของเฉพาะของตัวเองเหมือนกันครับ เราอาจจะคุ้นเคยกับชื่อของมันแต่เราอาจจะไม่รู้ว่ามันทำงานคล้ายๆกัน เช่น Java จะมี interface, Abstract Classes Java เองนั้นมีการสืบทอดที่เหมือนกับ PHP คือการสืบทอดแบบเดี่ยว ส่วน Python จะมี Mixins ส่วนภาษา C นั่นเองไม่ได้ถูกออกแบบมาให้เขียนโปรแกรมเชิงวัตถุเลยไม่ได้มีโครงสร้างแบบกับภาษาอื่นๆโดยจะใช้ คำว่า function pointers หรือ structures ในการจัดกลุ่มการทำงาน อาจจะยังไม่เห็นภาพ เดี๋ยวผมทำตัวอย่างเปรียบเทียบให้ครับ

Traits ใน Java หรือเรียกว่า (interface) Java เองนั้นไม่ได้มี Traits ไว้รับรอง แต่จะใช้ Interface ในการกำหนด methods แต่ใน Methods นั้น ยังไม่ได้กำหนดว่าสามารถทำอะไรได้บ้าง แล้วจะใช้ implement ในการเรียกใช้งานนั้นเอง แล้วค่อยกำหนดฟังก์ชันการทำงานใน method นั้นเอง ฟังดูแล้วเหมือนกับการทำงานของ Traits เลยใช่ไหมครับ แต่แตกต่างกันที่ Traits จะกำหนด ฟังก์ชันการทำงานไว้แล้ว อาจจะเพราะว่า PHP และ Java มีการ สืบทอดแบบเดี่ยว(Single inheritance) เหมือนกันครับผม

ตัวอย่างการใช้งาน Interface และการเรียกใช้

// Interface
interface Animal {
  public void animalSound(); 
  public void sleep(); 
}

class Pig implements Animal {
  public void animalSound() {
    System.out.println("The pig says: wee wee");
  }
  public void sleep() {
    System.out.println("Zzz");
  }
}
class Main {
  public static void main(String[] args) {
    Pig myPig = new Pig();  
    myPig.animalSound();
    myPig.sleep();
  }
}

// การ implement หลายๆ interface
interface FirstInterface {
  public void myMethod(); // interface method
}

interface SecondInterface {
  public void myOtherMethod(); // interface method
}

class DemoClass implements FirstInterface, SecondInterface {
  public void myMethod() {
    System.out.println("Some text..");
  }
  public void myOtherMethod() {
    System.out.println("Some other text...");
  }
}

class Main {
  public static void main(String[] args) {
    DemoClass myObj = new DemoClass();
    myObj.myMethod();
    myObj.myOtherMethod();
  }
}

หลายคนอาจจะสงสัยว่ามันต่างกับการที่เรา Extends จากคลาสแม่มาคลาสลูกอย่างไรกัน?

การ extends นั้น จะเป็นการสืบทอดของคลาสๆเดียวเท่ากัน จากคลาสแม่ไปยังคลาสลูก เช่น class Animal มีความสามารถในการส่งเสียง เป็นคลาสหลักหรือคลาสเเม่ สร้าง class Dog ที่ extends Animal @override เพื่อให้ dog มีความสามารถเหมือนใน Animal ที่ dog สามารถส่งเสียงเห่าได้ นั่นเองครับ แต่ไม่สามารถ extends ได้หลายๆคลาสพร้อมกันครับ เราเลยใช้ interface ในการกำหนดการทำงาน และ ใช้ implement ในการเรียกใช้งานนั่นเองครับผม ขอถามอีกนิดนะพี่?? ผมจะใช้ extends หรือ implement ในสถานการณ์แบบไหนอะครับ(เองนี่ขี้สงสัยจริง;-;) เองฟังพี่นะ!!!! - ถ้าน้องต้องการแค่ ให้คลาสมีการฟังก์ชันการทำงานจากแค่คลาสๆเดียว น้องใช้ extends เข้าใจนะแต่ถ้าน้องเนี้ย อยากให้คลาสของน้องมีฟังก์ชันการทำงานหลายๆคลาสมารวมกัน น้องใช้ implement กับ interface เคนะ

พี่ครับอย่าลืมภาษา C นะครับ

อะอะอะ.....ต่อมา ภาษา C มีอะไรที่เหมือนกับชาวบ้านบ้างไหม เรามาเจาะลึกกันครับ

โดยภาษา C นั่นจะไม่มีโครงสร้างแบบการ Traits หรือแบบภาษา Java, python แต่ภาษา C นั่นเองจะใช้การเขียน function pointer หรือ struct เพื่อให้การใช้งานมีความใกล้เคียงกับ Traits ได้ครับผม

โดย Struct จะเป็นโครงสร้างข้อมูลครับ ใช้ในการ กำหนด obj หรือ กำหนดฟังก์ชั่นการทำงานข้างในครับ

ตัวอย่างการสร้าง Struct และ function pointer

//struct ชื่อ pet
typedef struct {
    char name[50]; 
    //function pointer เอาไว้ตั้งชื่อและการพูด
    void (*set_name)(struct Pet* self, const char* name);
    void (*speak)(struct Pet* self);
} Pet;

void set_name(Pet* self, const char* name) {
    strcpy(self->name, name);  
}

void speak(Pet* self) {
    printf("%s says: Meow!\n", self->name);  
}
Pet create_pet() {
    Pet p;
    p.set_name = set_name;  
    p.speak = speak;        
    return p;      
}

int main() {
    Pet my_pet = create_pet();
    my_pet.set_name(&my_pet, "Panda");  
    my_pet.speak(&my_pet);  

    return 0; 
}

Output

Panda says: Meow!

จะเห็นว่าค่อนข้างยุ่งยากกว่าภาษาอื่นๆเลยครับฮ่าๆๆ อธิบายเพิ่มเติมนะครับ คือข้อมูลของสัตว์เลี้ยง(Pet) จะถูกจัดเก็บไว้ใน Struct เพื่อให้ pointer สามารถเข้าถึงข้อมูลเพื่อแก้ไขและบันทึกข้อมูลในหน่วยความจำได้ ท้ายสุดการใช้ struct และ function ในภาษา c มีความซับซ้อนพอสมควร ควรระมัดระวังให้ดีครับ ผมเองก็ยังไม่ค่อยเข้าใจมากกับภาษา c หากในส่วนนี้อธิบายผิดพลาดประการใด ขออภัยครับผม

สรุปท้ายบท Traits เป็นเครื่องมือที่สำคัญในการช่วยลดขั้นตอนในการเขียนโปรแกรมเชิงวัตถุ OOP และภาษาอื่นๆก็ยังมีตัวช่วยในการเขียนโปรแกรมเชิงวัตถุไม่ว่าจะเป็น ภาษา Java ที่มี interface , Python ที่มี Mixin ในการช่วยในการเรียกคลาสอื่นๆมาใช้งาน หรือ ภาษา C ที่มี Struct และ Function ในการจัดการโครงสร้างของคลาส หากเลือกใช้เครื่องมือให้ถูกต้องและเข้าใจการทำงานของมัน สิ่งเหล่านี้จะช่วยให้เราประหยัดเวลาในการทำงานมากขึ้นครับ ผมหวังว่าบทความนี้จะช่วยให้ผู้อ่านเข้าใจแนวคิด Traits และนำไปประยุกต์ใช้ในงานเขียนโปรแกรมได้ผิดพลาดประการใด ขออภัยด้วยครับผม

Video PHP Traits

เอกสาร PHP Traits

3MB

PHP_Traits.pdf.pdf

Open

แหล่งที่มา (อ้างอิง)

ใช้ในการศึกษาเรื่อง PHP Trait - https://www.geeksforgeeks.org/php-tutorial/ - https://www.w3schools.com/php/default.asp - https://www.php.net/manual/en/language.oop5.traits.php - https://www.tutorialspoint.com/php/index.htm - https://www.tutorialspoint.com/php/php_traits.htm ใช้ในการศึกษาเรื่องภาษา Python Mixin - https://www.pythontutorial.net/python-oop/python-mixin/ - https://www.javatpoint.com/php-tutorial ใช้ในการศึกษาเรื่องภาษา Java OOP - https://www.w3schools.com/java/java_interface.asp - https://www.w3schools.com/java/java_oop.asp - https://www.tutorialspoint.com/java/java_inheritance.htm ใช้ในการศึกษาเรื่องภาษา C Struct, Function - https://www.w3schools.com/c/c_structs.php - https://www.geeksforgeeks.org/structures-c/ - https://www.geeksforgeeks.org/function-pointer-in-c/