Detaillierte Grafik- und Texterklärung zur Anwendung von Merkmalen in PHP

Ab PHP-Version 5.4.0 bietet PHP ein neues Konzept der Code-Wiederverwendung, nämlich Trait. Trait bedeutet wörtlich „Merkmale“ und „Merkmale“. Wir können verstehen, dass die Verwendung des Schlüsselworts Trait den Klassen in PHP neue Merkmale hinzufügen kann.

Jeder, der mit objektorientiert vertraut ist, weiß, dass es zwei Methoden der Code-Wiederverwendung gibt, die häufig in der Softwareentwicklung verwendet werden: Vererbung und Polymorphismus. In PHP kann nur eine einzelne Vererbung erreicht werden. Eigenschaften vermeiden dies. Das Folgende ist eine vergleichende Erklärung anhand eines einfachen Beispiels.

1. Vererbung vs. Polymorphismus vs. Merkmal

Es gibt jetzt zwei Klassen: Publish.php und Answer.php. Um die LOG-Funktion hinzuzufügen, zeichnen Sie die Aktionen innerhalb der Klasse auf. Es gibt mehrere Möglichkeiten:

Vererbung
Polymorphismus
Merkmal

1.1. Erben

Wie in der Abbildung gezeigt:

Die Codestruktur ist wie folgt folgt:

// 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
{

}

Sie sehen, dass die Vererbung den Anforderungen entspricht. Dies verstößt jedoch gegen das objektorientierte Prinzip. Die Beziehung zwischen Vorgängen wie „Veröffentlichen“, „Antworten“ und „Protokollieren“ ist nicht die Beziehung zwischen der Unterklasse und der übergeordneten Klasse. Es wird daher nicht empfohlen, es auf diese Weise zu verwenden.

1.2. Polymorphismus

Wie gezeigt:

Implementierungscode:

 // 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.
 }
}

Die Protokollierungsvorgänge sollten gleich sein, daher ist die Protokollierungsimplementierung in den Aktionen „Veröffentlichen“ und „Antworten“ dasselbe. Offensichtlich verstößt dies gegen das DRY-Prinzip (Don't Repeat Yourself). Daher wird die Implementierung auf diese Weise nicht empfohlen.

1.3. Merkmal

Wie gezeigt:

Der Implementierungscode lautet wie folgt:

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

Wie Sie sehen können, haben wir die Wiederverwendung von Code erreicht, ohne die Komplexität des Codes zu erhöhen.

1.4. Fazit

Obwohl Vererbung das Problem auch lösen kann, widerspricht ihre Idee dem objektorientierten Ansatz Das Prinzip erscheint sehr grob; die polymorphe Methode ist ebenfalls machbar, entspricht jedoch nicht dem DRY-Prinzip in der Softwareentwicklung und erhöht die Wartungskosten. Die Trait-Methode vermeidet die oben genannten Mängel und erreicht die Wiederverwendung von Code relativ elegant.

2. Umfang von Trait

Nachdem wir die Vorteile von Trait verstanden haben, müssen wir auch die Regeln für seine Umsetzung verstehen es zuerst. Dies ist einfacher zu beweisen. Der Implementierungscode lautet wie folgt:

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

Das Ausgabeergebnis der Ausführung des obigen Codes lautet wie folgt:

öffentliche Funktiongeschützte Funktion
private Funktion

Es kann festgestellt werden, dass der Umfang von Trait innerhalb der Trait-Klasse sichtbar ist, die darauf verweist. Es versteht sich, dass das Schlüsselwort use den Implementierungscode des Merkmals in die Klasse kopiert, die auf das Merkmal verweist.

3. Die Priorität des Attributs in Trait

Wenn es um Priorität geht Zum Vergleich muss ein Referenzobjekt vorhanden sein. Das Referenzobjekt bezieht sich hier auf die Klasse des Merkmals und seine übergeordnete Klasse.

Verwenden Sie den folgenden Code, um die Priorität von Attributen in der Trait-Anwendung zu beweisen:

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

Die Ausgabe des obigen Codes lautet wie folgt:

Veröffentlichen ::publicF öffentliche FunktionLog::protectF geschützte Funktion

Anhand des obigen Beispiels können die Prioritäten in Trait-Anwendungen wie folgt zusammengefasst werden:

1. Mitglieder der aktuellen Klasse überschreiben die Trait-Methode
2. Trait überschreibt die geerbte Methode

Die Priorität der Klassenmitglieder ist: aktuelle Klasse>Trait> übergeordnete Klasse

4. Statt- und As-Schlüsselwörter

In einer Klasse können mehrere Merkmale wie folgt referenziert werden:

<?php
trait Log
{
  public function startLog()
  {
    echo METHOD . &#39; public function&#39; . PHP_EOL;
  }
  protected function endLog()
  {
    echo METHOD . &#39; protected function&#39; . PHP_EOL;
  }
}

trait Check
{
  public function parameterCheck($parameters) {
    // do sth
  }
}

class Publish extends Question
{
  use Log,Check;
  public function doPublish($para) {
    $this->startLog();
    $this->parameterCheck($para);
    $this->endLog();
  }
}

Durch das oben Gesagte Auf diese Weise können wir auf mehrere Merkmale in einer Klasse verweisen. Beim Verweisen auf mehrere Merkmale kann es leicht zu Problemen kommen. Was ist zu tun, wenn in zwei Merkmalen Eigenschaften oder Methoden mit demselben Namen vorhanden sind? Siehe den folgenden Implementierungscode:

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

Führen Sie den obigen Code aus. Das Ausgabeergebnis lautet wie folgt:

Log::startLog öffentliche FunktionCheck::parameterCheck-Parameter checkparams
Check::startLog öffentliche Funktion

Genau wie die wörtliche Bedeutung ersetzt das Schlüsselwort Insteadof letzteres durch ersteres und das Schlüsselwort as gibt der ersetzten Methode einen Alias.

verwendet das Schlüsselwort „use“, wenn auf Trait verwiesen wird. Das Schlüsselwort „use“ wird auch verwendet, um auf den Namespace zu verweisen. Der Unterschied zwischen den beiden besteht darin, dass Trait beim Verweisen innerhalb der Klasse verwendet wird.

Das obige ist der detaillierte Inhalt vonDetaillierte Grafik- und Texterklärung zur Anwendung von Merkmalen in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!