9. Traits
Los traits son estructuras análogas a las clases. Sin embargo, no se pueden instanciar: están destinados a incluirse en clases. Incluir un trait en una clase tiene el mismo efecto que si el código del trait se hubiera copiado en la clase. El código que puede reutilizarse en varias clases se coloca en un trait.
Los traits existen desde PHP 5.4. PHP 8 introdujo varias novedades, que veremos al final de este capítulo: verificación de firmas para métodos abstractos (PHP 8.0), constantes en traits (PHP 8.2), el atributo [#[\Override]] utilizable en un trait (PHP 8.3).
9.1. Estructura de directorios de los scripts
Los scripts de este capítulo se encuentran en la carpeta [scripts-console/traits]:
9.2. Inclusión de un trait en una clase
El script [trait-01.php] muestra un uso básico de un trait en una clase:
Comentarios del código
- líneas 5–22: definición de la clase [Class04] con un atributo [$name] (inicializado por el constructor), su getter y su setter;
- líneas 24–39: tomamos el código de [Class04]—sin su constructor— y lo trasladamos al trait [Trait04]. Esta vez el atributo se declara explícitamente, junto con su tipo. No incluimos el constructor, ya que un trait no se puede instanciar;
- línea 24: la palabra clave [trait] designa a [Trait04] como un trait y no como una clase;
- líneas 41–51: definimos una clase [Class05] que incluye el código del trait [Trait04] y le agrega un constructor, para que la clase sea instanciable;
- línea 44: la palabra clave [use], colocada dentro de una clase, permite incluir un trait en ella. No debe confundirse con la instrucción [use], que se coloca fuera de cualquier clase e importa un nombre de un espacio de nombres;
- líneas 54–60: las pruebas muestran que las clases [Class04] y [Class05] funcionan de la misma manera.
Resultados
Los resultados de las líneas 4–11 muestran que los objetos [Class04] y [Class05] tienen el mismo contenido: el atributo privado [$name] del trait se ha convertido en un atributo privado de la clase [Class05].
Conclusión: usar la instrucción [use Trait] en una clase equivale a incluir en ella el código de [Trait] .
9.3. Uso del mismo trait en diferentes clases
Uno de los principales beneficios de un trait parece ser la reutilización del mismo código (atributos + métodos) en diferentes clases. Sin embargo, veremos que el mismo objetivo puede lograrse con clases simples.
El siguiente script, [trait-02.php], ilustra cómo compartir un trait entre clases:
Comentarios
- líneas 5–15: un trait que define un atributo [$id] y un método [doSomething];
- el trait [Trait01] se incluye en dos clases: [Class02] (líneas 17–36) y [Class03] (líneas 38–53);
- líneas 20–24: inclusión de [Trait01] en [Class02]. A la inclusión le sigue un bloque [{...}] que permite ajustar los métodos incluidos;
- línea 23: esta línea resuelve un conflicto: [Trait01] y [Class02] tienen ambos un método llamado [doSomething]. En este caso, el método de la clase tiene prioridad: el método del trait queda oculto. El operador [as] hace que el método [Trait01::doSomething] sea accesible en la clase con el nombre [doSomethingInTrait]. Así, dentro de [Class02], se usarán las siguientes notaciones:
- [doSomethingInTrait] para llamar al método [Trait01::doSomething];
- [doSomething] para llamar al método [Class02::doSomething];
- líneas 30–32: la clase [Class02] usa el atributo y el método de [Trait01] como si fueran propios;
- líneas 38–53: la clase [Class03] es análoga a la clase [Class02]. La inclusión de [Trait01] es aquí más sencilla porque no hay conflicto entre los métodos de [Trait01] y de [Class03].
Resultados
Observe que el trait [Trait01] no se comparte entre las clases [Class02] y [Class03]. El atributo [$id] de [Trait01] se convierte, debido a la inclusión de [Trait01] en las clases [Class02] y [Class03], en dos atributos distintos: [Class02::$id] y [Class03::$id]. Esto se muestra en las líneas 3 y 5 de los resultados. Si el atributo [$id] se hubiera compartido entre las clases [Class02] y [Class03], el valor de la línea 5 habría sido 20 en lugar de 10.
El script [trait-03.php] muestra que puede obtenerse el mismo resultado usando una clase en lugar del trait:
Comentarios
- Líneas 6–28: la clase [Class01] reemplaza al trait [Trait01]. El código de [Trait01] se incorporaba al código de las clases [Class02] y [Class03]. Aquí no ocurrirá así: se inyectará una referencia a un objeto [Class01] en las clases [Class02] y [Class03] . Los atributos de la clase [Class01] serán, por lo tanto, externos a los objetos [Class02] y [Class03] . Como el atributo [$id] es privado, es necesario proporcionar un getter y un setter. Esta es la primera diferencia con un trait: hay que crear código para acceder a los atributos privados de la clase. Podríamos haber hecho público el atributo [$id], pero no se recomienda: usar un setter para asignar el valor de un atributo permite validarlo;
- línea 33: la referencia al objeto
*[Class01]se inyecta en*[Class02]mediante su constructor, gracias a la promoción de parámetros. El curso de PHP 7 usaba un setter [setClass01]. La inyección por el constructor es preferible: el objeto [Class02] está completo desde que se construye y, como el atributo es [readonly], la referencia ya no puede cambiarse; - líneas 41–45: para cualquier uso del código de [Class01], debemos pasar por el atributo [$this->class01];
- líneas 51–70: la clase [Class03] es un clon de la clase [Class02], salvo que su método tiene un nombre distinto;
- líneas 73–81: la primera prueba. Consiste en inyectar dos instancias distintas de la clase [Class01] en los objetos [Class02] y [Class03];
- líneas 84–94: la segunda prueba inyecta la misma instancia de la clase [Class01] en los objetos [Class02] y [Class03].
Resultados
Comentarios sobre los resultados
- líneas 3–6: obtenemos los mismos resultados que con el trait [Trait01]. Podemos concluir que aquí el uso del trait no es indispensable, pero sí reduce la cantidad de código, porque no se necesitan métodos para acceder a los atributos del trait: estos forman parte integral de la clase en la que se incorporó el trait;
- líneas 8–11: como se inyectó la misma referencia a [Class01] en los objetos [Class02] y [Class03], el atributo [Class01::$id] se compartió entre los dos objetos. Por eso la línea 10 de los resultados muestra 20 en lugar de 10 cuando se usa el trait. Podemos concluir que, si se necesita compartir atributos entre objetos, no se puede usar el trait y debe usarse una clase en su lugar.
9.4. Agrupación de métodos en un trait
En el ejemplo anterior, el trait incluía atributos y métodos. Aquí consideraremos el caso en que contiene solo métodos. El trait se parece entonces a una factorización de métodos que pueden usarse en distintas clases. Como aquí el trait no tiene atributos, consideraremos el caso en que los métodos que contiene operan únicamente sobre los parámetros que reciben. Esto no es obligatorio: un trait puede operar sobre un atributo [$this->attribute1] sin tener él mismo ese atributo. En ese caso, corresponde a las clases que usan el trait proporcionar el atributo [$this->attribute1].
Cuando el trait solo tiene métodos que operan únicamente sobre los parámetros que reciben, mostraremos que el trait puede sustituirse por una clase con los mismos métodos que el trait, declarados como estáticos.
El uso del trait se ilustra con el script [trait-04.php], que reutiliza el trait del ejemplo anterior pero elimina todos los atributos:
Comentarios
- líneas 5–12: el trait [Trait01] ya no tiene atributos;
- líneas 17–21: [Trait01] se incluye en [Class02]. El método de [Trait01] se usa en la línea 26;
- línea 35: [Trait01] se incluye en [Class03]. El método de [Trait01] se usa en la línea 41.
Resultados
En este caso de uso, el trait [Trait01] puede sustituirse fácilmente por una clase. Lo demuestra el siguiente script [trait-05.php]:
Comentarios
- líneas 6–18: el trait [Trait01] se sustituye por una clase [Class01], todos cuyos métodos son estáticos. No es necesario instanciarla ni derivarla. En el curso de PHP 7 se la declaraba abstracta para impedir su instanciación, lamentando que PHP rechace el prefijo [final abstract]. Esto sigue siendo así en PHP 8: en su lugar, declaramos la clase [final] (no derivable) con un constructor privado (no instanciable). Es lo que hicimos con la clase [Utilities] en la versión 3 del ejercicio de aplicación;
- línea 25: en lugar de escribir [$this->doSomethingInTrait()], ahora escribimos [Class01::doSomething()], es decir, llamamos al método estático [doSomething] de la clase [Class01];
- línea 37: se repite el mismo procedimiento en [Class03].
Resultados
Efectivamente obtenemos el mismo resultado que con el trait [Trait01], lo que demuestra que su uso puede evitarse. Observamos que los métodos de un trait pueden operar sobre un atributo [$this->attribute1] aunque el trait mismo no tenga ese atributo; corresponde a las clases que usan el trait proporcionarlo. Es un escenario exótico y frágil: es mejor “subir” el atributo [$this->attribute1] al propio trait. De ese modo, formará necesariamente parte de los atributos de la clase que usa el trait. Veremos al final del capítulo que PHP 8 ofrece una solución limpia para exigir algo a las clases que usan un trait: los métodos abstractos.
9.5. Herencia múltiple con un trait
Es común leer en la literatura que los traits permiten la herencia múltiple: la capacidad de una clase de heredar de varias clases. El lenguaje C++ admite esta característica, pero ni Java ni C# lo hacen, ya que solo admiten la herencia simple. Mostraremos que, si bien usar un trait en una clase derivada permite implementar algo parecido a la herencia múltiple, este caso de uso también puede implementarse con clases simples.
El script [trait-06.php] implementa una clase derivada y un trait:
Comentarios
- líneas 5–18: un trait [Trait01] con un atributo y un método que lo manipula;
- líneas 20–33: una clase [Class02] que no tiene nada que ver con el trait [Trait01]. No lo usa;
- línea 23: el único atributo de [Class02] tiene la visibilidad [protected] para que sea accesible en las clases derivadas;
- línea 36: la clase [Class03] extiende la clase [Class02]. Además, incorpora el trait [Trait01] (línea 39). Por lo tanto, hereda los atributos y métodos de [Class02] e incorpora los atributos y métodos de [Trait01]. Esto es, entonces, análogo a la herencia múltiple.
Resultados
Al igual que en un ejemplo anterior, mostraremos que:
- el trait puede sustituirse por una clase;
- en lugar de incorporar el trait en la clase derivada, le inyectamos una referencia a una instancia de esa clase.
El script [trait-07.php] es el siguiente:
Comentarios
- líneas 5–29: la clase
*[Class01]sustituye al trait*[Trait01]. Como un objeto [Class01] se usará mediante una referencia, se proporcionaron un getter y un setter para el atributo [$i]; - líneas 31–44: la clase [Class02] permanece sin cambios;
- línea 46: la clase [Class03] extiende la clase [Class02];
- línea 49: se inyecta en [Class03] una referencia a un objeto [Class01] mediante su constructor;
- líneas 54–66: el método [doSomethingInClass03] hace lo mismo que antes, pero con un código más complejo.
Resultados
De este ejemplo podemos concluir que, una vez más, el trait no es indispensable, pero hay que reconocer que permite un código más corto en la clase derivada.
9.6. Uso de un trait en lugar de una clase abstracta
El siguiente caso de uso es común: se crea una interfaz I bastante general que puede dar lugar a varias implementaciones. Estas implementaciones comparten código común pero difieren en otros métodos. Hay dos maneras de implementar este caso de uso:
- Se crea una clase abstracta
Cque contiene el código común a las clases derivadas. La claseCimplementa la interfazI, pero ciertos métodos —que deben definirse en las clases derivadas— se declaran abstractos en la claseC, que por lo tanto es a su vez abstracta. Luego se crean las clases C1 y C2 derivadas de C, cada una de las cuales implementa a su manera los métodos abstractos de su clase padre C; - se crea un trait T casi idéntico a la clase abstracta C de la solución anterior. Este trait no implementa la interfaz I porque, sintácticamente, no puede. Luego se crean las clases C1 y C2, que implementan la interfaz I y usan el trait T. A estas clases solo les resta implementar los métodos de la interfaz I que no están implementados por el trait T que importan.
A continuación se presenta un ejemplo que ilustra cuán parecidas son estas dos soluciones. La aplicación 1 implementa la solución 1 ([trait-08.php]):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 | |
Comentarios
- líneas 5–10: la interfaz [Interface1] tiene dos métodos;
- línea 12: la clase abstracta [AbstractClass] implementa la interfaz [Interface1]. Tiene dos atributos con sus getters y setters, implementa el método [doSomething] de la interfaz [Interface1] (línea 43), pero no implementa el método [doSomethingElse]. Por lo tanto, este método se declara abstracto (línea 50). La clase abstracta [AbstractClass] no puede instanciarse y, para ser útil, debe derivarse;
- líneas 29–39: los setters son “fluidos”: en lugar de no devolver nada, devuelven el objeto [$this]. Esto permite encadenar llamadas (línea 116). El tipo de retorno [static] (PHP 8.0) se refiere a la clase del objeto sobre el que se llamó al método: [(new Class1())->setAttr1(21)] es de tipo [Class1] y no [AbstractClass], lo que permite llamar a continuación a [setAttr3]—un método específico de [Class1]—;
- línea 54: la clase [Class1] extiende la clase abstracta [AbstractClass] y por lo tanto implementa la interfaz [Interface1]. Proporciona un cuerpo para el método [doSomethingElse], que su clase padre no había definido. También agrega un atributo a los de su clase padre;
- línea 80: la clase [Class2] hace lo mismo con otro atributo;
- líneas 106–110: la función [useInterfaceWith] recibe como parámetro un tipo [Interface1] y llama a los dos métodos de esta interfaz;
- líneas 113–116: se llama a la función [useInterfaceWith] con un tipo [Class1] y luego con un tipo [Class2]. Esto es correcto porque ambos tipos implementan la interfaz [Interface1].
Resultados
Ahora implementamos la solución 2 mediante el script [trait-09.php]. Consiste en sustituir la clase abstracta por un trait:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 | |
Comentarios
- líneas 5–10: la interfaz [Interface1] no ha cambiado;
- líneas 12–47: el trait [Trait1] sustituye a la clase abstracta [AbstractClass] de la solución 1. El código es el mismo, salvo por los siguientes detalles:
- línea 12: el trait [Trait1] no implementa la interfaz [Interface1]. Esto es sintácticamente imposible;
- líneas 15–16: la visibilidad de los atributos de la clase abstracta
*[AbstractClass]cambia aquí de***[protected]a[private]***. En ambos casos, el objetivo es dar a las clases concretas acceso directo a los atributos sin pasar por getters y setters. Con un trait, [private]* basta, ya que los atributos del trait pasan a ser los de la clase; - el trait [Trait1] no declara el método abstracto [doSomethingElse];
- línea 42: a partir de PHP 8.3, el atributo [#[\Override]] puede aplicarse a un método de un trait. Esto se verifica en cada clase que usa el trait: aquí, el método [doSomething] debe corresponder a un método de una interfaz o de una clase padre de [Class1] y de [Class2]. Efectivamente es así: es el método [doSomething] de [Interface1];
- línea 50: la clase
*[Class1]de la solución 2 es idéntica a la clase*[Class1]de la solución 1, salvo por los siguientes detalles:- implementa la interfaz [Interface1], mientras que en la solución 1 extendía la clase abstracta [AbstractClass];
- usa el trait [Trait1] (línea 53) para implementar parte de la interfaz;
- línea 79: se aplican los mismos comentarios que para [Class1];
- el resto del código permanece sin cambios.
Resultados
Efectivamente obtenemos los mismos resultados.
9.7. Los traits en PHP 8
PHP 8 ha hecho que los traits sean más confiables y completos. El script [trait-10.php] ilustra estas novedades:
Comentarios
- línea 9: desde PHP 8.2, un trait puede declarar constantes. Estas pasan a ser constantes de la clase que usa el trait;
- línea 12: un trait puede declarar atributos estáticos. Al igual que los atributos de instancia, se copian en cada clase que usa el trait: cada clase tiene su propio contador de instancias;
- líneas 18–21: un trait puede declarar métodos estáticos. En el código del trait, [self] se refiere a la clase que usa el trait;
- línea 24: un trait puede declarar métodos abstractos. Toda clase que use el trait debe implementarlos; de lo contrario, debe declararse ella misma abstracta (véase la clase [Plane] comentada al final del script). A partir de PHP 8.0, se verifica la firma de la implementación (tipos de los parámetros y del retorno). Esta es la manera adecuada de imponer requisitos a las clases que usan el trait, en lugar de suponer que tienen un atributo o un método determinado;
- líneas 33–38: un método concreto [increment] que usa el método abstracto [getName] y la constante [STEP]. Devuelve [$this] (tipo [static]) para que pueda encadenarse;
- líneas 41–56: la clase [Car] usa el trait, llama en su constructor al método privado [register] del trait e implementa el método abstracto [getName]. Observe el atributo [#[\Override]] en esta implementación: se acepta porque la clase implementa un método abstracto del trait;
- líneas 58–72: la clase
*[Bike]* hace lo mismo; - líneas 79–80: cada clase tiene su propio atributo estático [$nbInstances];
- línea 82: la constante del trait es accesible a través de la clase que lo usa;
- línea 84: pero no directamente a través del trait: se produce un error.
Resultados
9.8. Conclusión
De los ejemplos anteriores se desprende que los casos de uso en los que usar un trait aporta un beneficio neto no son evidentes. En nuestros ejemplos, siempre podemos prescindir de él sustituyéndolo por una clase. Sin embargo, es útil para factorizar código entre distintas clases, como si ese código perteneciera a una clase padre, sin consumir la herencia simple de la que dispone una clase PHP. Es lo que haremos en la versión 4 del ejercicio de aplicación.