Explication détaillée des traits et de leurs applications en PHP

Cet article présente principalement en détail les traits et leurs applications en PHP. Il a une certaine valeur de référence. Les amis intéressés peuvent s'y référer

À partir de la version PHP 5.4.0, PHP Il fournit un nouveau concept de code. réutilisation, qui est Trait. Trait signifie littéralement « caractéristiques » et « fonctionnalités ». On peut comprendre que l'utilisation du mot-clé Trait peut ajouter de nouvelles caractéristiques aux classes en PHP.

Tous ceux qui sont familiers avec l'orientation objet savent qu'il existe deux méthodes de réutilisation de code couramment utilisées dans le développement logiciel : l'héritage et le polymorphisme. En PHP, un seul héritage peut être obtenu. Les traits évitent cela. Ce qui suit est une explication comparative à travers un exemple simple.

1. Héritage VS Polymorphisme VS Trait

Il y a maintenant deux classes : Publish.php et Answer.php. Pour y ajouter la fonction LOG, enregistrez les actions à l'intérieur de la classe. Il existe plusieurs options :

Héritage
Polymorphisme
Trait

1.1. Hériter

Comme le montre la figure :

La structure du code est la suivante suit :

// Log.php
<?php
Class Log
{
 public function startLog()
 {
  // echo ...
 }

 public function endLog()
 {
  // echo ...
 }
}

// Publish.php
<?php
Class Publish extends Log
{

} // Answer.php
<?php
Class Answer extends Log
{

}

Vous pouvez voir que l'héritage répond aux exigences . Mais cela viole le principe orienté objet. La relation entre les opérations telles que Publier, Répondre et Journaliser n'est pas la relation entre la sous-classe et la classe parent. Il n’est donc pas recommandé de l’utiliser de cette façon.

1.2. Polymorphisme

Comme indiqué :

Code d'implémentation :

 // Log.php
<?php
Interface Log
{
 public function startLog();
 public function endLog();
}

// Publish.php
<?php
Class Publish implements Log
{
 public function startLog()
 {
  // TODO: Implement startLog() method.
 }
 public function endLog()
 {
  // TODO: Implement endLog() method.
 }
}

// Answer.php
<?php
Class Answer implements Log
{
 public function startLog()
 {
  // TODO: Implement startLog() method.
 }
 public function endLog()
 {
  // TODO: Implement endLog() method.
 }
}

Les opérations de journalisation doivent être les mêmes, donc l'implémentation de la journalisation dans les actions Publier et Répondre est également la même. Évidemment, cela viole le principe DRY (Don't Repeat Yourself). Il n’est donc pas recommandé de le mettre en œuvre de cette façon.

1.3. Trait

Comme indiqué :

Le code d'implémentation est le suivant :

 // Log.php
<?php
trait Log{
 public function startLog() {
  // echo ..
 }
 public function endLog() {
  // echo ..
 }
}

// Publish.php
<?php
class Publish {
 use Log;
}
$publish = new Publish();
$publish->startLog();
$publish->endLog();

// Answer.php
<?php
class Answer {
 use Log;
}
$answer = new Answer();
$answer->startLog();
$answer->endLog();

Comme vous pouvez le constater, nous avons réussi à réutiliser le code sans augmenter la complexité du code.

1.4. Conclusion

Bien que l'héritage puisse également résoudre le problème, son idée va à l'encontre de l'approche orientée objet. Le principe semble très rudimentaire ; la méthode polymorphe est également réalisable, mais elle ne respecte pas le principe DRY en développement logiciel et augmente les coûts de maintenance. La méthode Trait évite les défauts ci-dessus et permet de réutiliser le code de manière relativement élégante.

2. Portée du Trait

Après avoir compris les avantages du Trait, nous devons également comprendre les règles de sa mise en œuvre. la portée en premier. C'est plus facile à prouver. Le code d'implémentation est le suivant :

 <?php
class Publish {
 use Log;
 public function doPublish() {
  $this->publicF();
  $this->protectF();
  $this->privateF();
 }
}
$publish = new Publish();
$publish->doPublish();

Le résultat de l'exécution du code ci-dessus est le suivant :
fonction publique
fonction protégée
fonction privée

On peut constater que la portée de Trait est visible à l'intérieur de la classe Trait qui y fait référence. On peut comprendre que le mot-clé use copie le code d'implémentation du Trait dans la classe qui référence le Trait.

3. La priorité des attributs dans Trait

En matière de priorité, il doit y avoir une référence pour comparaison, voici la référence L'objet fait référence à la classe du Trait et à sa classe parent.

Utilisez le code suivant pour prouver la priorité des attributs dans l'application Trait :

 <?php
trait Log
{
 public function publicF()
 {
  echo __METHOD__ . &#39; public function&#39; . PHP_EOL;
 }
 protected function protectF()
 {
  echo __METHOD__ . &#39; protected function&#39; . PHP_EOL;
 }
}

class Question
{
 public function publicF()
 {
  echo __METHOD__ . &#39; public function&#39; . PHP_EOL;
 }
 protected function protectF()
 {
  echo __METHOD__ . &#39; protected function&#39; . PHP_EOL;
 }
}

class Publish extends Question
{
 use Log;

 public function publicF()
 {
  echo __METHOD__ . &#39; public function&#39; . PHP_EOL;
 }
 public function doPublish()
 {
  $this->publicF();
  $this->protectF();
 }
}
$publish = new Publish();
$publish->doPublish();

Ce qui précède code Le résultat des priorités dans les applications Trait est résumé comme suit :
1. Les membres de la classe actuelle remplacent les méthodes du trait 2. Le trait remplace les méthodes héritées

Priorité des membres de la classe Pour : classe actuelle>Trait>classe parent

4 Au lieu de et en tant que mots-clés

Dans une classe, vous pouvez référencer plusieurs traits comme. suit :

Grâce à la méthode ci-dessus, nous pouvons référencer plusieurs traits dans une classe. Lors du référencement de plusieurs traits, il est facile de causer des problèmes. Le problème le plus courant est que faire s'il existe des propriétés ou des méthodes portant le même nom dans deux traits. À ce stade, vous devez utiliser les mots-clés à la place de et as. voir le code d'implémentation suivant :

 <?php

trait Log
{
  public function parameterCheck($parameters)
  {
    echo __METHOD__ . &#39; parameter check&#39; . $parameters . PHP_EOL;
  }

  public function startLog()
  {
    echo __METHOD__ . &#39; public function&#39; . PHP_EOL;
  }
}

trait Check
{
  public function parameterCheck($parameters)
  {
    echo __METHOD__ . &#39; parameter check&#39; . $parameters . PHP_EOL;
  }

  public function startLog()
  {
    echo __METHOD__ . &#39; public function&#39; . PHP_EOL;
  }
}

class Publish
{
  use Check, Log {
    Check::parameterCheck insteadof Log;
    Log::startLog insteadof Check;
    Check::startLog as csl;
  }

  public function doPublish()
  {
    $this->startLog();
    $this->parameterCheck(&#39;params&#39;);
    $this->csl();
  }
}

$publish = new Publish();
$publish->doPublish();

执行上述代码,输出结果如下:
 Log::startLog public function
Check::parameterCheck parameter checkparams
Check::startLog public function

就如字面意思一般,insteadof关键字用前者取代了后者,as 关键字给被取代的方法起了一个别名。 

在引用Trait时,使用了use关键字,use关键字也用来引用命名空间。两者的区别在于,引用Trait时是在class内部使用的。

以上就是本文的全部内容，希望对大家的学习有所帮助。

相关推荐：

关于PHP中的trait简单介绍

PHP中trait使用方法图文详解

php的Traits属性以及基本用法

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!