Analyse des traits en PHP

Cet article présente principalement l'analyse de Trait en PHP, qui a une certaine valeur de référence. Maintenant, je le partage avec tout le monde. Les amis dans le besoin peuvent s'y référer

Depuis PHP 5.4.0, PHP a implémenté A. méthode de réutilisation du code appelée traits.

Trait signifie littéralement « caractéristiques » et « caractéristiques ». On peut comprendre que l'utilisation du mot-clé Trait peut ajouter de nouvelles fonctionnalités aux classes en PHP.

Trait est un mécanisme de réutilisation de code préparé pour les langages à héritage unique comme PHP. Les traits sont conçus pour réduire les limitations des langages à héritage unique et permettre aux développeurs de réutiliser librement des méthodes dans des classes indépendantes au sein de différentes hiérarchies. La sémantique de la composition des traits et des classes définit un moyen de réduire la complexité et d'éviter les problèmes typiques associés à l'héritage multiple traditionnel et aux classes Mixin.

Trait est similaire à Class, mais est uniquement conçu pour combiner des fonctionnalités de manière fine et cohérente. Ne peut pas être instancié via le trait lui-même. Il ajoute une combinaison de fonctionnalités horizontales à l'héritage traditionnel ; c'est-à-dire qu'il n'est pas nécessaire d'hériter entre plusieurs classes dans une application.

Utilisation : en utilisant le mot-clé use dans la classe, déclarez le nom du trait à combiner. La déclaration de trait spécifique utilise le mot-clé Traits ne peut pas être instanciée.

1. Bases des traits

<?php
header("Content-type:text/html;charset=utf-8");
trait Test{public function hello1(){        
return "Test::hello1()";
    }
}class demo1{    
use Test;
}$obj = new demo1();echo $obj->hello1().&#39;<br />&#39;;//Test::hello1()

2. Priorité

<?php
class Base {    
public function sayHello() {        
echo &#39;Hello &#39;;
    }
}

trait SayWorld {    
public function sayHello() {
        parent::sayHello();        
        echo &#39;World!&#39;;
    }
}class MyHelloWorld extends Base {    
use SayWorld;
}$o = new MyHelloWorld();$o->sayHello();//Hello World!

<?php

trait HelloWorld {    
public function sayHello() {        
echo &#39;Hello World!&#39;;
    }
}class TheWorldIsNotEnough {    
use HelloWorld;    
public function sayHello() {        
echo &#39;Hello Universe!&#39;;
    }
}
$o = new TheWorldIsNotEnough();
$o->sayHello();//Hello Universe!

Les membres hérités de la classe de base sont remplacés par la méthode MyHelloWorld dans le trait SayWorld inséré. Son comportement est cohérent avec les méthodes définies dans la classe MyHelloWorld. L'ordre de priorité est que les méthodes de la classe actuelle remplacent les méthodes de trait, qui à leur tour remplacent les méthodes de la classe de base.

3. Traits multiples

Séparés par des virgules, plusieurs traits sont répertoriés dans la déclaration d'utilisation et ils peuvent tous être insérés dans une classe.

<?php

trait Hello {    
public function sayHello() {        
echo &#39;Hello &#39;.&#39;<br />&#39;;
    }
}

trait World {    
public function sayWorld() {        
echo &#39;World&#39;.&#39;<br />&#39;;
    }
}class MyHelloWorld {    
use Hello, World;    
public function sayExclamationMark() {        
echo &#39;!&#39;.&#39;<br />&#39;;
    }
}$o = new MyHelloWorld();$o->sayHello();//Hello$o->sayWorld();//World$o->sayExclamationMark();//!

4. Résolution des conflits

Si deux traits insèrent une méthode du même nom, si le conflit n'est pas résolu explicitement, le conflit se produira. Une erreur fatale se produira.

Afin de résoudre le conflit de nom de plusieurs traits dans la même classe, vous devez utiliser l'opérateur au lieu de pour spécifier explicitement laquelle des méthodes en conflit utiliser.

<?php

trait A{    public function smallTalk(){        echo &#39;a&#39;;
    }    public function bigTalk(){        echo &#39;A&#39;;
    }
}

trait B{    public function smallTalk(){        echo &#39;b&#39;;
    }    public function bigTalk(){        echo &#39;B&#39;;
    }
}class Talker{    use A,B{
        B::smallTalk insteadof A;
        A::bigTalk insteadof B;
    }
}$obj = new Talker();$obj->smallTalk();//b$obj->bigTalk();//A

La méthode ci-dessus permet uniquement d'exclure d'autres méthodes. L'opérateur as peut introduire un alias pour une méthode. Notez que l'opérateur as ne renomme pas la méthode et n'affecte pas ses méthodes.

<?php

trait A{    public function smallTalk(){        echo &#39;a&#39;;
    }    public function bigTalk(){        echo &#39;A&#39;;
    }
}

trait B{    public function smallTalk(){        echo &#39;b&#39;;
    }    public function bigTalk(){        echo &#39;B&#39;;
    }
}class Talker{    use A,B{
        B::smallTalk insteadof A;
        A::bigTalk insteadof B;
        B::bigTalk as b_bigTalk;
        A::smallTalk as a_smallTalk;
    }
}$obj = new Talker();$obj->smallTalk();//b$obj->bigTalk();//A$obj->b_bigTalk();//B$obj->a_smallTalk();//a

5. Modifier le contrôle d'accès aux méthodes

Utiliser as la syntaxe peut également être utilisée pour ajuster les méthodes d'accès contrôle.

<?php

trait A{    private function smallTalk(){        echo &#39;a&#39;;
    }
}class Talker{    use A{
        smallTalk as public aaa;
    }
}$obj = new Talker();$obj->aaa();//a

6. Groupe de traits

Tout comme la classe peut utiliser des traits, d'autres traits peuvent également utiliser des traits. En utilisant un ou plusieurs traits lors de la définition d'un trait, vous pouvez combiner tout ou partie des membres d'autres traits.

<?php

trait Hello{    public function sayHello(){        echo &#39;Hello &#39;;
    }
}

trait World{    public function sayWorld(){        echo &#39;World !&#39;;
    }
}

trait HelloWorld{    use Hello,World;
}class Talker{    use HelloWorld;
}$obj = new Talker();$obj->sayHello();//Hello$obj->sayWorld();//World !

7. Membres abstraits

Afin d'imposer des exigences obligatoires sur les classes utilisées, les traits prennent en charge l'utilisation de méthodes abstraites.

<?php

trait Hello{    public function sayWorld(){        echo &#39;Hello &#39;.$this->getWorld();
    }    abstract public function getWorld();
}class Talker{    private $world;    use Hello;    public function getWorld(){        return $this->world;
    }    public function setWorld($val){        $this->world = $val;
    }
}$obj = new Talker();$obj->setWorld("Trait !");$obj->sayWorld();//Hello Trait !

8. Traits des membres statiques

Les traits peuvent être définis par des membres statiques et des méthodes statiques.

<?php

trait HelloWorld{    public static function sayHelloWorld(){        echo &#39;Hello World !&#39;;
    }
}class Talker{    use HelloWorld;
}
Talker::sayHelloWorld();//Hello World !

<?php

trait Counter{    public function inc(){        static $c = 0;        $c++;        echo "$c\n";
    }
}class C1{    use Counter;
}class C2{    use Counter;
}$c1 = new C1();$c1->inc();//1$c1_1 = new C1();$c1_1->inc();//2$c2 = new C2();$c2->inc();//1

9. Attributs

Le trait peut également définir des attributs. .

<?php

trait PropertiesTrait {    public $x = 1;
}class PropertiesExample {    use PropertiesTrait;
}$example = new PropertiesExample;echo $example->x;//1

Trait Après avoir défini un attribut, la classe ne peut pas définir d'attributs portant le même nom, sinon une erreur fatale se produira. Il existe une exception : les propriétés sont compatibles (même visibilité d'accès, valeur initiale par défaut). Avant PHP 7.0, si l'attribut était compatible, il y aurait un rappel E_STRICT.

Ce qui précède représente l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'étude de chacun. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois !

Recommandations associées :

Comment utiliser Elasticsearch en PHP

Instructions pour le minuteur PHP

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!