Nuevos "Traits" PHP 5.4.0+

[andresdzphp]

Nuevos "Traits" (PHP 5.4.0+)

Un post con el fin de actualizar la gente con nuevas características de PHP orientado a objetos.

Desde PHP 5.4.0, PHP implementa una metodología de reutilización de código llamada Traits.

Los traits (rasgos) son un mecanismo de reutilización de código en lenguajes de herencia simple, como PHP. El objetivo de un trait es el de reducir las limitaciones propias de la herencia simple permitiendo que los desarrolladores reutilicen a voluntad conjuntos de métodos sobre varias clases independientes y pertenecientes a clases jerárquicas distintas. La semántica a la hora combinar Traits y clases se define de tal manera que reduzca su complejidad y se eviten los problemas típicos asociados a la herencia múltiple y a los Mixins.

Un Trait es similar a una clase, pero con el único objetivo de agrupar funcionalidades muy específicas y de una manera coherente. No se puede instanciar directamente un Trait. Es por tanto un añadido a la herencia tradicional, y habilita la composición horizontal de comportamientos; es decir, permite combinar miembros de clases sin tener que usar herencia.

Ejemplo de Trait

Código PHP:

<?php
trait ezcReflectionReturnInfo {
    function getReturnType() { /*1*/ }
    function getReturnDescription() { /*2*/ }
}
 
class ezcReflectionMethod extends ReflectionMethod {
    use ezcReflectionReturnInfo;
    /* ... */
}
 
class ezcReflectionFunction extends ReflectionFunction {
    use ezcReflectionReturnInfo;
    /* ... */
}
?>
 

Precedencia

Los miembros heredados de una clase base se sobrescriben cuando se inserta otro miembro homónimo desde un Trait. De acuerdo con el orden de precedencia, los miembros de la clase actual sobrescriben los métodos del Trait, que a su vez sobrescribe los métodos heredados.

Ejemplo de Orden de Precedencia

Se sobrescribe un miembro de la clase base con el método insertado en MiHolaMundo a partir del Trait DecirMundo. El comportamiento es el mismo para los métodos definidos en la clase MiHolaMundo. Según el orden de precedencia los métodos de la clase actual sobrescriben los métodos del Trait, a la vez que el Trait sobrescribe los métodos de la clase base.

Código PHP:

<?php
class Base {
  public function decirHola() {
    echo '¡Hola ';
  }
}
 
trait DecirMundo {
  public function decirHola() {
    parent::decirHola();
    echo 'Mundo!';
  }
}
 
class MiHolaMundo extends Base {
  use DecirMundo;
}
 
$o = new MiHolaMundo();
$o->decirHola();
?>
 

El resultado del ejemplo sería: ¡Hola Mundo!

Multiples Traits

Se pueden insertar múltiples Traits en una clase, mediante una lista separada por comas en la sentencia use.

Código PHP:

<?php
trait Hola {
  public function decirHola() {
    echo 'Hola ';
  }
}
 
trait Mundo {
  public function decirMundo() {
    echo ' Mundo';
  }
}
 
class MiHolaMundo {
  use Hola, Mundo;
  public function decirAdmiración() {
    echo '!';
  }
}
 
$o = new MiHolaMundo();
$o->decirHola();
$o->decirMundo();
$o->decirAdmiración();>
?>
 

El resultado del ejemplo sería: Hola Mundo!

Resolución de Conflictos

Si dos Traits insertan un método con el mismo nombre, se produce un error fatal, siempre y cuando no se haya resuelto explicitamente el conflicto.

Para resolver los conflictos de nombres entre Traits en una misma clase, se debe usar el operador insteadof para elejir unívocamente uno de los métodos conflictivos.

Como esto sólo permite excluir métodos, se puede usar el operador as para permitir incluir uno de los métodos conflictivos bajo otro nombre.

Ejemplo Resolución de Conflictos

En este ejemplo, Talker utiliza los traits A y B. Como A y B tienen métodos conflictos, se define el uso de la variante de smallTalk del trait B, y la variante de bigTalk del traita A.

Aliased_Talker hace uso del operador as para poder usar la implementación de bigTalk de B, bajo el alias adicional talk.

Código PHP:

<?php
trait A {
  public function smallTalk() {
    echo 'a';
  }
  public function bigTalk() {
    echo 'A';
  }
}
 
trait B {
  public function smallTalk() {
    echo 'b';
  }
  public function bigTalk() {
    echo 'B';
  }
}
 
class Talker {
  use A, B {
    B::smallTalk insteadof A;
    A::bigTalk insteadof B;
  }
}
 
class Aliased_Talker {
  use A, B {
    B::smallTalk insteadof A;
    A::bigTalk insteadof B;
    B::bigTalk as talk;
  }
}
?>
 

Modificando la Visibilidad de los Métodos

Al usar el operador as, se puede también ajustar la visibilidad del método en la clase exhibida.

Código PHP:

<?php
trait HolaMundo {
  public function decirHola() {
    echo 'Hola Mundo!';
  }
}
 
class MiClase1 {
  use HolaMundo { decirHola as protected }
}
 
class MiClase2 {
  use HolaMundo { hacerHolaMundo as private decirHola }
}
?>
 

Traits Compuestos de Traits

Al igual que las clases, los Traits también pueden hacer uso de otros Traits. Al usar uno o más traits en la definición de un trait, éste puede componerse parcial o completamente de miembros de finidos en esos otros traits.

Código PHP:

<?php
trait Hola {
  public function decirHola() {
    echo 'Hola ';
  }
}
 
trait Mundo {
  public function decirMundo() {
    echo 'Mundo!';
  }
}
 
trait HolaMundo {
  use Hola, Mundo;
}
 
class MiHolaMundo {
  use HolaMundo;
}
 
$o = new MiHolaMundo();
$o->decirHola();
$o->decirMundo();
?>
 

El resultado del ejemplo sería: Hola Mundo!

Miembros Abstractos de Traits

Los traits soportan el uso de métodos abstractos para imponer requisitos a la clase a la que se exhiban.

Código PHP:

<?php
trait Hola {
  public function decirHolaMundo() {
    echo 'Hola'.$this->obtenerMundo();
  }
  abstract public function obtenerMundo();
}
 
class MiHolaMundo {
  private $mundo;
  use Hola;
  public function obtenerMundo() {
    return $this->mundo;
  }
  public function asignarMundo($val) {
    $this->mundo = $val;
  }
}
?>
 

Miembros Estáticos en Traits

Los métodos de un trait pueden referenciar a variables estáticas, pero no puede ser definido en el trait. Los traits, sin embargo, pueden definir método estáticos a la clase a la que se exhiben.

Código PHP:

<?php
  trait Contador {
    public function inc() {
      static $c = 0;
      $c = $c + 1;
      echo "$c\n";
    }
  }
 
  class C1 {
    use Contador;
  }
 
  class C2 {
    use Contador;
  }
 
  $o = new C1(); $o->inc(); // echo 1
  $p = new C2(); $p->inc(); // echo 1
?>
 

Código PHP:

<?php
  trait Singleton {
    public static function getInstance() { ... }
  }
 
  class MiSingleton extends SomeUnrelatedSuperClass {
    use Singleton;
  }
 
  MiSingleton::getInstance();
?>
 

Espero que les haya gustado, a mi me parece interesante el tema, aunque no muy claro todavía.

Más información en nuestro querido manual:

http://php.net/manual/es/language.oop5.traits.php

Saludos

[masterpuppet]

Agrego otra referencia, Stefan Marr.
Seguro saldran cosas interesantes aunque en lo personal todavia no tengo una opinion formada al respecto y como dice el autor

It is almost like a language supported and failsafe copy’n'paste mechanism to build classes.

Saludos.

[GatorV]

Interesante lo nuevo, como dice masterpuppet todavía no me decido si es beneficioso o perjudicial, voy a esperar a ver que se puede crear correctamente y esperemos no haga más fácil hacer código espaguetti.

[pablofmorales]

Iniciado por GatorV

Interesante lo nuevo, como dice masterpuppet todavía no me decido si es beneficioso o perjudicial, voy a esperar a ver que se puede crear correctamente y esperemos no haga más fácil hacer código espaguetti.

Creo que este tipo de cambios esta mas orientados a mejorar Zend Framework y no para el uso normal.

Alguien que hace codigo spaguetti, no creo que pueda entender como aplicarlo. Al menos que haga copy/paste claro.

[mar_x4_superxv]

Hola a todos por suerte entendi todos los ejemplos menos: Miembros Estáticos en Traits. Si alguien me lo pudiera explicar le agradeceria de antemano llevo horas tratando de entenderlo.
Muchas gracias.

[GatorV]

Simplemente es que el trait como tal no puede definir variables estáticas, pero sí puede hacer uso de ellas, el ejemplo del contador es lo que dice, define una variable estática (static $c), y al darle el use del trait a las otras clases, cada clase hace uso de su propia variable.

[pateketrueke]

A mi en lo personal me parece beneficioso de muchas formas, habilita por decirlo así el patchy-monkey en php, entre otras yerbas.

Un caso concreto, cuando se trabaja con RoR es el uso de DataMappers, que con Traits podría ser así la cosa.

Código php:

namespace Model;
 
class Book
{
  use \DataMapper\Base;
  use \DataMapper\Validations;
  use \DataMapper\Engine\MongoDB;
}
 
// ...
 
echo Book::find_by_slug_and_owner_id('hello-world', 99);
 

Cosas del estilo pues, finalmente me quedo con la descripción del "copy/paste seguro".

Ciertamente es otra forma de ir construyendo clases con diversas funcionalidades sin estar obligados a extender.

Particularmente funcionalidades como estas me permiten seguir expresando cuanta cosa me venga en mente sin envidiar otros lenguajes dinámicos.