PHP trait方法冲突：trait“继承”和trait层次结构

Question

更新：我并不是唯一一个思考这个问题的人，它似乎确实是一个错误。看这里。这一天是固定的将是一个梦幻般的一天！：）

这是从我喜欢PHP特性开始的！我要在任何地方使用它们^_^ 思维练习/学习体验

考虑以下示例：

trait TheErrorOfYourWays{

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

trait SpectacularStuff1 {
    use TheErrorOfYourWays; 
}

trait SpectacularStuff2 {
    use TheErrorOfYourWays;
}

class DoSomethingSpectacular {
    use SpectacularStuff1, SpectacularStuff2;
}

这导致(

致命错误：尚未应用Trait方法booboo，因为在dosomethingspectical上存在与其他Trait方法的冲突。

所以我的问题是：如何解决性状中的方法冲突？有没有可能实现重叠性状“遗传”？如果是这样，那么这样做的“正确”方式是什么？

我为什么要这样做：

1. 我想创建自包含的特征和类（混合和匹配风格）。如果可能的话，我想说“使用”，然后神奇的事情一定会发生。不用挠头想，“现在这个特征又在哪个命名空间里了？”等等。
2. 当我做一些“冒险”的事情，发现我无意中制造了冲突时，不必匆忙编辑类别和特征。
3. 当时看起来是个好主意。

我所尝试的：

>

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

和

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

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

我理解：

1. 我可以将错误方式更改为类并使booboo（）成为静态的，但我想了解这种特殊的特性行为
2. 我可以从traits中删除errorofyourways，并在课堂上使用它，但这很难做到“自给自足”。每次我使用traits时，我必须记住在类中使用errorofyourways，即使我没有直接从类中调用booboo（）。听起来很危险
3. 我可能犯了一些新手语法错误，或者未能深刻理解别名。如果是，请。。。解释慢慢地
4. 也许有更好的方法可以做到这一点。如果是，请。。。解释慢慢地
5. 我可能有点过早的热情，PHP还没有做到这一点。轻轻地让我下来

谢谢




Answer 1

我找到了另一种解决临时问题的方法：

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 ();
    }
}

它是有效的：）

Answer 2

因此，非官方的“官方”答案是：

你可以做到没有混淆现象，而不是任何事情！但还没有...

我从5.5.1升级到5.5.6，但都是徒劳。当修复可用时，我将更新此答案。有趣的是，您可以直接调用trait静态函数。以下示例起作用：

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

是的，是的，你也可以通过上课来做到这一点，但上赛季的课太少了。

Answer 3

您需要使用关键字代替来解决Traits中的冲突。

源代码

重写你的

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

到

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

会解决冲突。