Using Traits: การรวม Code เข้ากับ Class

จากบทที่แล้ว เราได้รู้จักกับ Traits ซึ่งเป็นเหมือนพิมพ์เขียวของกลุ่ม Methods ที่เราสามารถนำไปใช้ซ้ำในหลาย Class ได้ โดยไม่ต้องอาศัยการสืบทอด (Inheritance) ในบทนี้ เราจะมาเรียนรู้วิธีการนำ Traits เหล่านั้นมาใช้งานจริงใน Class ของเรา

ความหมายของการ Using

คำว่า "Using" ในบริบทของ Traits หมายถึง การรวมเอา Code ที่อยู่ใน Traits เข้าไปเป็นส่วนหนึ่งของ Class ของเรา เหมือนกับการคัดลอก Code จาก Traits ไปวางไว้ใน Class โดยตรง แต่การใช้ Traits จะทำให้ Code ของเราเป็นระเบียบและง่ายต่อการดูแลรักษามากกว่า

การ Using Traits

การใช้งาน Traits ใน Class นั้นง่ายมาก เราใช้ Keyword use ตามด้วยชื่อของ Traits ที่เราต้องการนำมาใช้งาน ตัวอย่างเช่น:

<?php

trait Logger {
    public function logMessage(string $message): void {
        echo "[" . date("Y-m-d H:i:s") . "] " . $message . "\n";
    }
}

class User {
    use Logger;

    public string $name;

    public function __construct(string $name) {
        $this->name = $name;
    }

    public function register(): void {
        $this->logMessage("User " . $this->name . " registered.");
        // ... logic การ register user ...
    }
}

$user = new User("John Doe");
$user->register();

// Output: [2023-10-27 10:00:00] User John Doe registered. (เวลาอาจแตกต่างกัน)

?>

ในตัวอย่างนี้ เราสร้าง Traits ชื่อ Logger ซึ่งมี Method logMessage สำหรับบันทึกข้อความ จากนั้นเราใช้ use Logger; ภายใน Class User ซึ่งหมายความว่า Class User จะสามารถเรียกใช้ Method logMessage ได้เหมือนเป็น Method ของตัวเอง

ขั้นตอนการ Using Traits:

สร้าง Traits ที่ต้องการนำมาใช้งาน (ดูบทที่แล้ว)
ภายใน Class ที่ต้องการใช้งาน Traits ให้ใช้ Keyword use ตามด้วยชื่อ Traits
Class นั้นจะสามารถเรียกใช้ Methods และ Properties ที่อยู่ใน Traits ได้เหมือนเป็นส่วนหนึ่งของ Class

ตัวอย่างการใช้งาน Traits เพิ่มเติม

เราสามารถใช้ Traits ได้มากกว่าหนึ่ง Traits ใน Class เดียว โดยคั่นด้วยเครื่องหมาย comma (,) ตัวอย่างเช่น:

<?php

trait Logger {
    public function logMessage(string $message): void {
        echo "[" . date("Y-m-d H:i:s") . "] " . $message . "\n";
    }
}

trait Notifier {
    public function sendNotification(string $message): void {
        echo "Sending notification: " . $message . "\n";
    }
}

class Order {
    use Logger, Notifier;

    public int $orderId;

    public function __construct(int $orderId) {
        $this->orderId = $orderId;
    }

    public function processOrder(): void {
        $this->logMessage("Processing order #" . $this->orderId);
        // ... logic การ process order ...
        $this->sendNotification("Order #" . $this->orderId . " processed.");
    }
}

$order = new Order(123);
$order->processOrder();

// Output:
// [2023-10-27 10:00:00] Processing order #123 (เวลาอาจแตกต่างกัน)
// Sending notification: Order #123 processed.

?>

ในตัวอย่างนี้ Class Order ใช้ทั้ง Traits Logger และ Notifier ทำให้สามารถเรียกใช้ Methods logMessage และ sendNotification ได้

ข้อดีของการใช้ Traits

Code Reuse: ช่วยลดการเขียน Code ที่ซ้ำซ้อน โดยเฉพาะอย่างยิ่งในกรณีที่ Class ที่ต้องการใช้งาน Code นั้น ไม่มีความสัมพันธ์กันในเชิง Inheritance
Single Inheritance: PHP รองรับการสืบทอด Class ได้เพียงครั้งเดียว (Single Inheritance) แต่ Traits ช่วยให้เราสามารถนำ Code จากหลายแหล่งมาใช้งานได้
Flexibility: Traits ช่วยให้การออกแบบ Class มีความยืดหยุ่นมากขึ้น เพราะเราสามารถเลือก Traits ที่ต้องการนำมาใช้งานได้อย่างอิสระ
Composition over Inheritance: Traits สนับสนุนแนวคิด Composition over Inheritance ซึ่งเป็นหลักการออกแบบที่ดี ที่เน้นการรวมส่วนประกอบย่อยๆ เข้าด้วยกัน แทนที่จะพึ่งพาการสืบทอดเพียงอย่างเดียว

กรณีใช้งานจริง

ลองนึกภาพว่าคุณกำลังสร้างระบบ E-commerce และมี Class หลาย Class ที่ต้องการความสามารถในการบันทึกข้อมูล (Logging) เช่น User, Product, Order แทนที่จะต้องเขียน Code สำหรับ Logging ในทุก Class คุณสามารถสร้าง Traits Logger และนำไปใช้ใน Class เหล่านั้นได้

<?php

trait Logger {
    public function log(string $message): void {
        error_log("[" . date("Y-m-d H:i:s") . "] " . $message); // บันทึกลง error log
    }
}

class User {
    use Logger;

    public string $username;

    public function __construct(string $username) {
        $this->username = $username;
    }

    public function login(): bool {
        // ... logic การ login ...
        $this->log("User " . $this->username . " logged in.");
        return true;
    }
}

class Product {
    use Logger;

    public string $name;

    public function __construct(string $name) {
        $this->name = $name;
    }

    public function purchase(int $quantity): void {
        // ... logic การ purchase ...
        $this->log("Product " . $this->name . " purchased (" . $quantity . ")");
    }
}

// ...

?>

ข้อผิดพลาดที่พบบ่อย

Name Conflicts: หาก Traits หลาย Traits มี Method หรือ Property ที่มีชื่อเดียวกัน และ Class ที่ใช้ Traits เหล่านั้นไม่ได้จัดการกับ Conflict นั้น PHP จะแสดง Error วิธีแก้ไขคือการใช้ Keyword insteadof และ as เพื่อระบุว่า Method ไหนควรถูกใช้งาน (จะกล่าวถึงในบทต่อไป)
Access Modifiers: Access Modifiers (public, protected, private) ใน Traits จะถูกนำไปใช้ใน Class ที่ใช้ Traits นั้น ดังนั้นควรระมัดระวังในการกำหนด Access Modifiers เพื่อหลีกเลี่ยงปัญหาการเข้าถึง

สรุป

การใช้ Traits เป็นวิธีที่มีประสิทธิภาพในการนำ Code กลับมาใช้ใหม่ใน PHP ช่วยลด Code duplication และเพิ่มความยืดหยุ่นในการออกแบบ Class โดยเฉพาะอย่างยิ่งในสถานการณ์ที่ Single Inheritance ไม่สามารถตอบโจทย์ได้ ในบทต่อไป เราจะมาเรียนรู้เกี่ยวกับวิธีการจัดการกับ Conflicts ที่อาจเกิดขึ้นเมื่อใช้ Traits หลาย Traits ใน Class เดียว