ejemplos - traits php

Conflictos en el método del rasgo de PHP: rasgo "herencia" y jerarquías de rasgo

Question

ACTUALIZACIÓN: No estoy solo al reflexionar sobre este tema y parece que es un error Ver here ¡El día que se arregle será un día fantástico! :)

¡Esto comenzó cuando I love PHP traits! I''m going to use them everywhere! ^_^ I love PHP traits! I''m going to use them everywhere! ^_^ I love PHP traits! I''m going to use them everywhere! ^_^ y ahora se ha convertido en un Thought Exercise / Learning Experience >_< .

Considere el siguiente ejemplo:

trait TheErrorOfYourWays{

   public function booboo(){
       echo ''You had a booboo :('';
   }
}

trait SpectacularStuff1 {
    use TheErrorOfYourWays; 
}

trait SpectacularStuff2 {
    use TheErrorOfYourWays;
}

class DoSomethingSpectacular {
    use SpectacularStuff1, SpectacularStuff2;
}

Esto resulta en ( obviamente no tan obviamente):

Error fatal: no se ha aplicado el método de rasgo booboo, porque hay colisiones con otros métodos de rasgo en DoSomethingSpectacular.

Entonces mi pregunta: ¿Cómo resuelvo los conflictos de métodos en los rasgos? ¿Es posible lograr el rasgo superpuesto de "herencia"? Si es así, ¿cuál es la manera "correcta" de hacer esto?

Por qué quiero hacer esto:

1. Quiero crear rasgos y clases independientes (mezclar y combinar estilo). Si es posible , quiero decir "uso" y luego deben pasar cosas mágicas. No tengo que rascarme la cabeza y pensar: "Ahora, ¿en qué espacio de nombres estaba ese rasgo otra vez?", Etc., etc.
2. No tengo que editar clases y rasgos sobre la marcha cuando hago algo "aventurero" y descubro que involuntariamente he creado un conflicto.
3. Parecía una buena idea en ese momento.

Lo que he intentado:

1. El manual de PHP.
2. El Google.
3. Por lo que incluye esta pregunta -> No es la respuesta correcta para este escenario.
4. Encontré esto pero estoy usando PHP versión 5.5.1. Es fijo, ¿verdad? ¿Derecha?

5. Una fantástica variedad de "como", alias, incluso en lugar de, en diferentes lugares, tiempos, universos, etc. Incluyendo, entre otros:

   trait SpectacularStuff1 {
      use TheErrorOfYourWays{
         TheErrorOfYourWays::booboo as booboo1;
      }
   }
   trait SpectacularStuff2 {
      use TheErrorOfYourWays{
         TheErrorOfYourWays::booboo as booboo2;
      }
   }
   class DoSomethingSpectacular {
      use SpectacularStuff1, SpectacularStuff2 {
         /* Tried separately, but included here for brevity''s sake */
         SpectacularStuff1::booboo as booboo3;
         SpectacularStuff2::booboo as booboo4;
      }
   }

   Y

   use TheErrorOfYourWays as Erroneous1;
   trait SpectacularStuff1 {
       use Erroneous1{
           Erroneous1::booboo as booboo1;
       }
   }
   
   use TheErrorOfYourWays as Erroneous2;
   trait SpectacularStuff2 {
       use Erroneous2{
           Erroneous2::booboo as booboo2;
       }
   }

Entiendo que:

1. Puedo cambiar TheErrorOfYourWays a una clase y hacer que booboo () sea estático, pero me gustaría aprender sobre este comportamiento específico del rasgo.
2. Puedo eliminar TheErrorOfYourWays de los rasgos y usarlo en la clase, pero eso no es "independiente" en ese momento. Cada vez que uso los rasgos, debo recordar usar TheErrorOfYourWays en la clase, incluso si no llamo a booboo () directamente desde la clase. Suena peligroso.
3. Probablemente he cometido algún error de sintaxis de novato o no he podido entender el alias en un nivel profundo. Si es así, por favor ... explique ... lentamente ...
4. Probablemente hay una mejor manera de hacer esto. Si es así, por favor ... explique ... lentamente ...
5. Puede que sea prematuramente entusiasta y PHP todavía no hace esto. Déjame bajar suavemente.

¡Gracias!

Answer 1

Así que la here es:

¡Puedes hacerlo sin alias, en lugar de nada! Pero no todavía...

Actualicé de 5.5.1 a 5.5.6, pero fue en vano. Si recuerdo, actualizaré esta respuesta cuando la solución esté disponible. Para algo parecido a una solución alternativa, es interesante observar que puede llamar directamente a las funciones estáticas de rasgos. El siguiente ejemplo funciona:

trait TheErrorOfYourWays{
    public static function booboo($thisTrait){
        echo ''You had a booboo :( in ''.$thisTrait.''<br>'';
    }
}

trait SpectacularStuff1 {
    public function boobooTest1(){
        TheErrorOfYourWays::booboo(__TRAIT__);
    }
}

trait SpectacularStuff2 {
    public function boobooTest2(){
        TheErrorOfYourWays::booboo(__TRAIT__);
    }
}

class DoSomethingSpectacular {
    use SpectacularStuff1, SpectacularStuff2;
}

$boobooAChoo = new DoSomethingSpectacular();
$boobooAChoo->boobooTest1(); // You had a booboo :( in SpectacularStuff1
$boobooAChoo->boobooTest2(); // You had a booboo :( in SpectacularStuff2

Sí, sí, también puedes hacer eso con una clase, pero las clases son tan buenas la temporada pasada.

Answer 2

Encontré otra forma de arreglar temporalmente esto:

trait A {
   public function foo(){
       echo ''foo'';
   }
}

trait B {
   public function foofoo(){
       return $this->foo () . ''foo'';
   }
}

trait C {
   public function foobar(){
       return $this->foo () . ''bar'';
   }
}

class DoSomethingSpectacular {
    use A, B, C;

    public function foobarfoofoo () {
        echo $this->foobar () . $this->foofoo ();
    }
}

Y funciona :)

Answer 3

Un pequeño truco, solo agrega la función booboo a la clase DoSomethingSpectacular

<?php
trait TheErrorOfYourWays{

   public function booboo(){
       echo ''You had a booboo :('';
   }
}

trait SpectacularStuff1 {
   use TheErrorOfYourWays{
      TheErrorOfYourWays::booboo as booboo1;
   }
}

trait SpectacularStuff2 {
   use TheErrorOfYourWays{
      TheErrorOfYourWays::booboo as booboo2;
   }
}
class DoSomethingSpectacular {
   use SpectacularStuff1, SpectacularStuff2 {
      /* Tried separately, but included here for brevity''s sake */
      SpectacularStuff1::booboo as booboo3;
      SpectacularStuff2::booboo as booboo4;
   }

  //very ugly hack
  public function booboo() {}
}

Answer 4

insteadof utilizar la palabra clave en lugar de resolver los conflictos en Rasgos.

Source

Reescribiendo tu

class DoSomethingSpectacular {
   use SpectacularStuff1, SpectacularStuff2 {
      /* Tried separately, but included here for brevity''s sake */
      SpectacularStuff1::booboo as booboo3;
      SpectacularStuff2::booboo as booboo4;
   }
}

a

class DoSomethingSpectacular {
    use SpectacularStuff1, SpectacularStuff2 
    {
     SpectacularStuff1::booboo insteadof SpectacularStuff2;
     SpectacularStuff2::booboo insteadof SpectacularStuff1;
    }
}

Se resolverán los conflictos.