¿Qué son los traits y cuándo los usas?

Question

Accepted Answer

Un **trait** es un mecanismo para **reutilizar código en múltiples clases** que no están relacionadas por herencia. Dado que PHP solo permite herencia simple, los traits proporcionan una forma de compartir métodos (y propiedades) horizontalmente — una forma de reutilización de código "composicional", como mixins.

## Por qué es importante

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

## Definiendo y usando un 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 es un conjunto de métodos/propiedades. Una clase `use` uno o más traits para **mezclar** sus miembros — ganando la funcionalidad sin heredar de un padre común.

## Traits vs herencia 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.
```

## Resolución de conflictos

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

Cuando dos traits definen el mismo método, PHP te obliga a resolver el conflicto explícitamente.

## Por qué es importante

Los traits son una característica importante de PHP para **reutilizar código en clases no relacionadas**, resolviendo una limitación real: dado que PHP permite solo herencia simple, los traits proporcionan reutilización horizontal (mixins) para compartir funcionalidad común — logging, timestamps, soft-deletes, ayudantes de serialización — en clases que no comparten un padre.

Entenderlos es valioso porque se usan ampliamente en frameworks PHP (Eloquent de Laravel usa traits extensivamente para comportamientos de modelos como `SoftDeletes`, `HasFactory`), así que constantemente los encontrarás y usarás.

Saber cómo difieren los traits de la herencia (reutilización sin una relación es-un) y de las interfaces (los traits proporcionan *implementación*/código real, mientras que las interfaces definen solo un *contrato*/firmas — y los dos a menudo se combinan: una interface declara la capacidad, un trait proporciona la implementación compartida) es clave para usarlos apropiadamente.

Los traits permiten diseños DRY y composicionales que la herencia simple por sí sola no puede lograr, convirtiéndolos en conocimiento práctico y frecuentemente encontrado tanto para escribir código PHP reutilizable como para entender los frameworks construidos alrededor de ellos. (La advertencia: el uso excesivo de traits puede oscurecer dónde proviene el comportamiento, así que úsalos para reutilización genuina entre capas, no como predeterminado.)