Detailed explanation of the use of traits reuse mechanism in PHP

When it comes to PHP code reuse, we may think of inheritance at the first time. However, once this single inheritance language derives too many subclasses, it will cause a series of problems, such as dependence on parent classes and excessive coupling. Large, destroying the encapsulation of the class. So is there a better way to achieve code reuse?

Since PHP 5.4.0, PHP has implemented another method of code reuse called traits.

Traits is a code reuse mechanism prepared for single inheritance languages ​​like PHP. Traits are designed to reduce the constraints of single-inheritance languages ​​and allow developers to freely reuse method sets in independent classes within different hierarchies. The semantics of traits and class composition define a way to reduce complexity and avoid the typical problems associated with traditional multiple inheritance and mixins.

Basic usage

The use of Traits is very simple, just use the use keyword in the class.

trait A {    public function test() {
        echo 'trait A::test()';
    }
}class b {
    use A;
}$b=new b();$b->test();

Priority

Simply put, Trait priority is greater than the parent class method, but less than the current class method.

trait A {    public function test() {
        echo 'trait A::test()';
    }    public function test1() {
        echo 'trait A::test1()';
    }    
}class base{
    public function test(){
        echo 'base::test()';
    }    public function test1(){
        echo 'base::test1()';
    }    
}class b extends base{
    use A;    public function test(){
        echo 'b::test()';
    }
}$b=new b();$b->test();//b::test()$b->test1();//trait A::test1()

Trait conflict problem

When using multiple Traits, if the same method name exists, a conflict will occur. Use insteadof and as to solve the problem of method name conflict

insteadof can declare a specific method using two identical method names.

trait A {    public function test() {
        echo 'trait A::test()';
    } 
}trait B {    public function test() {
        echo 'trait B::test()';
    } 
}class c{
    use A,B{        A::test insteadof B;//使用 insteadof 明确使用哪个方法
        B::test as testB;//使用 as 修改另外一个方法名称，必须在使用 insteadof 解决冲突后使用
    }
}$c=new c();$c->test();//trait A::test()$c->testB();//trait B::test()

Method access control

Using the as keyword we can modify the access permissions of the trait method

trait A {    public function test() {
        echo 'trait A::test()';
    } 
    private function test1(){
        echo 'trait A::test1()';
    }
}class b{
    use A{        test as protected;
        test1 as public test2;//更改权限时还可以修改名称
    }
}$b=new b();$b->test();//Fatal error: Call to protected method b::test()$b->test2();//trait A::test1()

Trait nesting uses

 trait A {        public function test1() {
            echo 'test1';
        }
    }    trait B {        public function test2() {
            echo 'test2';
        }
    }    trait C {        use A,B;
    }    class D {
        use C;
    }    $d = new D();    $d->test2();  //test2

Variables, Attribute and method definition

Trait can define attributes, but the same name attribute cannot be defined in the class

 trait A {       
 public $test1;
    }    class B {
        use A;        
        public $test;        
        public $test1;//Strict Standards: B and A define the same property ($test1) in the composition of B...
    }

Trait supports abstract methods, supports static methods, and cannot directly define static variables, but static variables can Referenced by trait method.

  trait A {        
  public function test1() {
            static $a = 0;            
            $a++;            
            echo $a;
        }        
        abstract public function test2(); //可定义抽象方法
    }    
    class B 
    {
        use A;        
        public function test2() {

        }
    }    
    $b = new B();    
    $b->test1(); //1
    $b->test1(); //2

Compare to javascript

The usage method of this trait use is probably somewhat similar to the call in javascript, which is to mount another object into the execution environment of the current object. Of course javascript is a prototype-based language. There is no comparison between the two. It's just that the usage methods are almost the same, which helps to understand.

function a() {
    this.name="a";    this.getName=function(){
        console.log(this.name);
    }
}function b(){
    this.name="b";
    a.call(this);
}var b = new b();     
b.getName();//a

The above is the detailed content of Detailed explanation of the use of traits reuse mechanism in PHP. For more information, please follow other related articles on the PHP Chinese website!