Ce sunt trait-urile și când le folosești?

Question

Accepted Answer

Un **trait** este un mecanism pentru **reutilizarea codului în mai multe clase** care nu sunt legate prin moștenire. Deoarece PHP permite doar moștenirea simplă, trait-urile oferă o modalitate de a partaja metode (și proprietăți) în mod orizontal — o formă de reutilizare a codului de tip „compoziție", asemănătoare mixin-urilor.

## Problema pe care o rezolvă trait-urile

```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.
```

## Definirea și utilizarea unui 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
```

Un trait este un set de metode/proprietăți. O clasă `use` (folosește) unu sau mai multe trait-uri pentru a **amesteca** membrii acestora — obținând funcționalitatea fără a moșteni de la o clasă părinte comună.

## Trait-uri vs moștenire vs interfețe

```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.
```

## Rezolvarea conflictelor

```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
    }
}
```

Când două trait-uri definesc aceeași metodă, PHP te obligă să rezolvi explicit conflictul.

## De ce este important

Trait-urile sunt o caracteristică importantă a PHP pentru **reutilizarea codului în clase neînrudite**, rezolvând o limitare reală: deoarece PHP permite doar moștenirea simplă, trait-urile oferă reutilizare orizontală (mixin-uri) pentru partajarea funcționalității comune — logging, timestamps, soft-deletes, ajutoare de serializare — în clase care nu au o clasă părinte comună.

Înțelegerea lor este valoroasă deoarece sunt utilizate pe scară largă în framework-urile PHP (Eloquent-ul Laravel folosește trait-uri în mod extensiv pentru comportamentele modelelor, cum ar fi `SoftDeletes`, `HasFactory`), deci le vei întâlni și utiliza în mod constant.

Cunoașterea modului în care trait-urile diferă de moștenire (reutilizare fără o relație "is-a") și de interfețe (trait-urile oferă *implementare* reală/cod, în timp ce interfețele definesc doar un *contract*/semnături — și adesea sunt combinate: o interfață declară capacitatea, un trait oferă implementarea partajată) este esențială pentru a le folosi în mod corespunzător.

Trait-urile permit proiecte DRY, compoziție care moștenirea simplă nu poate singură, făcându-le cunoștințe practice și frecvent întâlnite atât pentru scrierea codului PHP reutilizabil, cât și pentru înțelegerea framework-urilor construite în jurul lor. (Caveat: subutilizarea trait-urilor poate ascunde de unde provine comportamentul, deci folosește-le pentru reutilizare transversală genuină, nu ca implicație implicită.)