traits คืออะไรและใช้เมื่อไร?

Question

Accepted Answer

**trait** คือกลไกสำหรับ **การใช้โค้ดซ้ำข้ามหลายคลาส** ที่ไม่ได้มีความสัมพันธ์กันผ่าน inheritance เนื่องจาก PHP อนุญาตเพียง single inheritance trait จึงเป็นวิธีแบ่งปันเมธอด (และ property) ในแนวนอน เป็นรูปแบบหนึ่งของการใช้โค้ดซ้ำแบบ "compositional" คล้ายกับ mixin

## ปัญหาที่ trait แก้ไข

```text
PHP has single inheritance — a class can extend only ONE parent. But you often want
to share the SAME methods across unrelated classes (e.g. logging, timestamps).
Duplicating the code is bad; traits let you reuse it without inheritance.
```

## การนิยามและใช้ trait

```php
<?php
trait Timestampable {
    private ?DateTime $createdAt = null;

public function setCreatedAt(): void {
        $this->createdAt = new DateTime();
    }
    public function getCreatedAt(): ?DateTime {
        return $this->createdAt;
    }
}

trait Loggable {
    public function log(string $msg): void {
        echo "[" . static::class . "] $msg";
    }
}

// a class can USE MULTIPLE traits — their methods become part of the class
class Article {
    use Timestampable, Loggable;     // mix in BOTH traits' methods
}

$a = new Article();
$a->setCreatedAt();    // from Timestampable
$a->log("created");     // from Loggable
```

trait คือชุดของเมธอด/property คลาสจะ `use` trait หนึ่งหรือหลายอันเพื่อ **ผสม (mix in)** สมาชิกของมันเข้ามา ได้รับฟังก์ชันการทำงานโดยไม่ต้องสืบทอดจากคลาสแม่ร่วมกัน

## trait vs inheritance vs interface

```text
Inheritance (extends) → single parent, "is-a", inherits implementation
Interface → a CONTRACT (signatures only, no code), multiple allowed
Trait → reusable IMPLEMENTATION (actual code), multiple allowed, NO contract
→ Interfaces say WHAT a class can do; traits provide HOW (shared code).
  They're often used together: implement an interface, use a trait for the impl.
```

## การแก้ไขความขัดแย้ง (Conflict resolution)

```php
class X {
    use TraitA, TraitB {
        TraitA::hello insteadof TraitB;   // if both define hello(), pick TraitA's
        TraitB::hello as helloB;           // alias TraitB's version
    }
}
```

เมื่อ trait สองอันนิยามเมธอดเดียวกัน PHP บังคับให้คุณแก้ไขความขัดแย้งอย่างชัดเจน

## ทำไมจึงสำคัญ

trait เป็นคุณสมบัติสำคัญของ PHP สำหรับ **การใช้โค้ดซ้ำข้ามคลาสที่ไม่เกี่ยวข้องกัน** โดยแก้ไขข้อจำกัดที่แท้จริง: เนื่องจาก PHP อนุญาตเพียง single inheritance trait จึงให้การใช้ซ้ำในแนวนอน (mixin) สำหรับแบ่งปันฟังก์ชันการทำงานทั่วไป เช่น logging, timestamp, soft-delete, ตัวช่วย serialization ข้ามคลาสที่ไม่ได้มีคลาสแม่ร่วมกัน

การเข้าใจมันมีค่าเพราะถูกใช้กันแพร่หลายในเฟรมเวิร์ก PHP (Eloquent ของ Laravel ใช้ trait อย่างมากสำหรับพฤติกรรมของ model เช่น `SoftDeletes`, `HasFactory`) ดังนั้นคุณจะพบเจอและใช้มันอยู่ตลอด

การรู้ว่า trait ต่างจาก inheritance อย่างไร (ใช้ซ้ำได้โดยไม่ต้องมีความสัมพันธ์แบบ is-a) และต่างจาก interface อย่างไร (trait ให้ *implementation*/โค้ดจริง ขณะที่ interface นิยามเพียง *สัญญา*/signature และทั้งสองมักใช้ร่วมกัน: interface ประกาศความสามารถ ส่วน trait ให้ implementation ที่ใช้ร่วมกัน) เป็นกุญแจสำคัญในการใช้มันอย่างเหมาะสม

trait ทำให้การออกแบบแบบ DRY และ compositional เป็นไปได้ในแบบที่ single inheritance อย่างเดียวทำไม่ได้ ทำให้มันเป็นความรู้เชิงปฏิบัติที่พบเจอบ่อยทั้งสำหรับการเขียนโค้ด PHP ที่ใช้ซ้ำได้และการเข้าใจเฟรมเวิร์กที่สร้างขึ้นรอบ ๆ มัน (ข้อควรระวัง: การใช้ trait มากเกินไปอาจทำให้คลุมเครือว่าพฤติกรรมมาจากไหน ดังนั้นควรใช้สำหรับการใช้ซ้ำแบบ cross-cutting ที่แท้จริง ไม่ใช่ใช้เป็นค่าตั้งต้น)