Traits en PHP

Los Traits en PHP o, traducido al español «rasgos» (no me gusta nada esta traducción), nos permiten reutilizar código en lenguajes de herencia simple como es el caso de PHP.

PHP no soporta la herencia múltiple por lo que, gracias a los Traits, podemos agrupar métodos comunes que pueden ser utilizados por múltiples clases independientes y de diferentes jerarquías. Podemos decir que un Trait es similar a una clase, pero con el objetivo de agrupar funcionalidades específicas, eso sí, no se pueden instanciar directamente.

Veamos un ejemplo:

<?php

trait Loggable
{
    public function log($message)
    {
        echo "Logging message: $message";
    }
}


class User
{
    use Loggable;

    private $name;

    public function createUser($name)
    {
        $this->name = $name;
        $this->log("User $name created.");
    }
}

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

En el ejemplo, definimos un Trait llamado «Loggable» , que contiene un método «log» para registrar mensajes. Luego usamos este Trait en la clase «User» usando la palabra clave use, que es con la cual «incluimos» el Trait.

La clase User ahora tiene acceso al método «log» definido en el Trait «Loggable».

También podemos incluir varios Traits en una misma clase, mediante una lista separada por comas en la sentencia use.

<?php
trait Greetable
{
    public function greet()
    {
        echo "Hello! Nice to meet you.";
    }
}

trait Farewellable
{
    public function farewell()
    {
        echo "Goodbye! Have a great day.";
    }
}

class Person
{
    use Greetable, Farewellable;

    private $name;

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

    public function getName()
    {
        return $this->name;
    }
}

$person = new Person("Oscar");
$person->greet(); // Output: Hello! Nice to meet you.

$person->farewell(); // Output: Goodbye! Have a great day.

El ejemplo anterior es sencillo.

Tenemos dos Traits, uno para saludar y otro para despedirse.

En la clase Person, usamos ambos Traits separándolos con comas en la sentencia use.

Se crea una instancia de Person con el nombre de «Oscar».

Llamamos al método greet() del Trait Greetable y al método farewell() del Trait Farewellable.

Resolviendo conflictos.

Puede suceder que queriendo o sin querer incluyamos más de un Trait con métodos con el mismo nombre. Esto nos provocaría un error fatal, sin embargo, podemos resolverlo de las siguientes dos maneras que nos ofrece PHP.

La primera es usar insteadof para elegir un método en lugar del otro.

La segunda es usar el operador as para añadir un alias a uno de los métodos.

Veámoslo mejor con otro ejemplo:

<?php
trait A
{
    public function hello()
    {
        echo "Hello from A";
    }
}

trait B
{
    public function hello()
    {
        echo "Hello from B";
    }
}

class MyClass
{
    use A, B {
        A::hello insteadof B; // Usar hello de A en lugar de B
        B::hello as helloB; // Renombrar el hello de B a helloB
    }
}

$obj = new MyClass();
$obj->hello(); // Output: Hello from A
$obj->helloB(); // Output: Hello from B

Como ves, tenemos dos métodos con el mismo nombre, sin embargo, al usar

 A::hello insteadof B;

Le indicamos explícitamente que use el método «hello()» de A, en lugar del de B.

Y por otro lado podemos usar el operador as como he indicado antes para “renombrar” un método.

Combinando estas dos cosas podemos evitar el conflicto mencionado.

En definitiva, los Traits, aunque ya llevan un tiempo con nosotros, pues existen desde la versión de PHP 5.4, son una poderosa herramienta que nos permite compartir funcionalidad entre clases de manera flexible y eficiente, pues promueve la reutilización de código haciendo que este sea mas modular y más fácil de mantener.

Ten en cuenta que el objetivo es agregar funcionalidad reutilizable. No agregues lógica especifica para una determinada clase.

De momento hemos visto esta pequeña introducción. En una segunda parte hablaremos un poco más de forma extendida sobre el uso de métodos abstractos y estáticos, propiedades, etc.

Sobre el autor