O que são traits e quando você as utiliza?

Question

Accepted Answer

Uma **trait** é um mecanismo para **reutilizar código em múltiplas classes** que não estão relacionadas por herança. Como PHP permite apenas herança única, traits fornecem uma forma de compartilhar métodos (e propriedades) horizontalmente — uma forma de reutilização de código "composicional", como mixins.

## O problema que traits resolvem

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

## Definindo e usando uma 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
```

Uma trait é um conjunto de métodos/propriedades. Uma classe `use` uma ou mais traits para **misturar** seus membros — ganhando a funcionalidade sem herdar de um pai comum.

## Traits vs herança vs interfaces

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

## Resolução de conflitos

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

Quando duas traits definem o mesmo método, PHP exige que você resolva o conflito explicitamente.

## Por que isso importa

Traits são um recurso importante do PHP para **reutilização de código em classes não relacionadas**, resolvendo uma limitação real: como PHP permite apenas herança única, traits fornecem reutilização horizontal (mixins) para compartilhar funcionalidade comum — logging, timestamps, soft-deletes, helpers de serialização — entre classes que não compartilham um pai.

Compreendê-las é valioso porque são amplamente utilizadas em frameworks PHP (Eloquent do Laravel utiliza traits extensivamente para comportamentos de modelos como `SoftDeletes`, `HasFactory`), então você as encontrará e as utilizará constantemente.

Saber como traits diferem da herança (reutilização sem um relacionamento é-um) e de interfaces (traits fornecem *implementação* real/código, enquanto interfaces definem apenas um *contrato*/assinaturas — e os dois frequentemente são combinados: uma interface declara a capacidade, uma trait fornece a implementação compartilhada) é fundamental para utilizá-las apropriadamente.

Traits permitem designs DRY e composicionais que apenas herança única não consegue, tornando-as conhecimento prático e frequentemente encontrado tanto para escrever código PHP reutilizável quanto para entender os frameworks construídos em torno delas. (A ressalva: usar traits em excesso pode obscurecer de onde o comportamento vem, então as utilize para reutilização genuína entre vários contextos, não como padrão.)