Eigenschaften in PHP - Beispiele / Best Practices aus der Praxis? [geschlossen]

Eigenschaften waren eine der größten Ergänzungen für PHP 5.4. Ich kenne die Syntax und verstehe die Idee hinter Merkmalen wie der Wiederverwendung von horizontalem Code für allgemeine Dinge wie Protokollierung, Sicherheit, Caching usw.

Ich weiß jedoch immer noch nicht, wie ich Merkmale in meinen Projekten nutzen würde.

Gibt es Open Source-Projekte, die bereits Merkmale verwenden? Gibt es gute Artikel / Lesematerial zum Strukturieren von Architekturen mithilfe von Merkmalen?

Meine persönliche Meinung ist, dass es beim Schreiben von sauberem Code tatsächlich nur sehr wenige Anwendungen für Merkmale gibt.

Anstatt Merkmale zu verwenden, um Code in eine Klasse zu hacken, ist es besser, die Abhängigkeiten über den Konstruktor oder über Setter zu übergeben:

class ClassName {
    protected $logger;

    public function __construct(LoggerInterface $logger) {
        $this->logger = $logger;
    }
    // or
    public function setLogger(LoggerInterface $logger) {
        $this->logger = $logger;
    }
}

Der Hauptgrund, warum ich das besser finde als die Verwendung von Merkmalen, ist, dass Ihr Code viel flexibler ist, indem die harte Kopplung an ein Merkmal entfernt wird. Zum Beispiel könnten Sie jetzt einfach eine andere Logger-Klasse übergeben. Dies macht Ihren Code wiederverwendbar und testbar.

Ich denke, man müsste sich schon seit einiger Zeit mit Sprachen befassen, die Eigenschaften haben, um die akzeptierten Good / Best Practices zu lernen. Meine aktuelle Meinung zu Trait ist, dass Sie sie nur für Code verwenden sollten, den Sie in anderen Klassen duplizieren müssten, die dieselbe Funktionalität haben.

Beispiel für ein Logger-Merkmal:

interface Logger
{
    public function log($message, $level);    
}

class DemoLogger implements Logger
{
    public function log($message, $level)
    {
        echo "Logged message: $message with level $level", PHP_EOL; 
    }
}

trait Loggable // implements Logger
{
    protected $logger;
    public function setLogger(Logger $logger)
    {
        $this->logger = $logger;
    }
    public function log($message, $level)
    {
        $this->logger->log($message, $level);
    }
}

class Foo implements Logger
{
    use Loggable;
}

Und dann machst du ( Demo )

$foo = new Foo;
$foo->setLogger(new DemoLogger);
$foo->log('It works', 1);

Ich denke, das Wichtigste bei der Verwendung von Merkmalen ist, dass es sich wirklich nur um Codeteile handelt, die in die Klasse kopiert werden. Dies kann leicht zu Konflikten führen, wenn Sie beispielsweise versuchen, die Sichtbarkeit von Methoden zu ändern, z

trait T {
    protected function foo() {}
}
class A { 
    public function foo() {}
}
class B extends A
{
    use T;
}

Das Obige führt zu einem Fehler ( Demo ). Ebenso werden im Merkmal deklarierte Methoden, die auch bereits in der using-Klasse deklariert sind, nicht in die Klasse kopiert, z

trait T {
    public function foo() {
    return 1;
}
}
class A { 
    use T;
    public function foo() {
    return 2;
}
}

$a = new A;
echo $a->foo();

druckt 2 ( Demo ). Dies sind Dinge, die Sie vermeiden möchten, da sie das Auffinden von Fehlern erschweren. Sie sollten auch vermeiden, Dinge in Merkmale zu setzen, die auf Eigenschaften oder Methoden der Klasse wirken, die sie verwendet, z

class A
{
    use T;
    protected $prop = 1;
    protected function getProp() {
        return $this->prop;
    }
}

trait T
{
    public function foo()
    {
        return $this->getProp();
    }
}

$a = new A;
echo $a->foo();

funktioniert ( Demo ), aber jetzt ist das Merkmal eng mit A verbunden und die gesamte Idee der horizontalen Wiederverwendung geht verloren.

Wenn Sie dem Prinzip der Schnittstellentrennung folgen, haben Sie viele kleine Klassen und Schnittstellen. Das macht Traits zu einem idealen Kandidaten für die Dinge, die Sie erwähnt haben, z. B. Querschnittsthemen , aber keine Objekte (im strukturellen Sinne) zu komponieren. In unserem obigen Logger-Beispiel ist das Merkmal vollständig isoliert. Es gibt keine Abhängigkeiten von konkreten Klassen.

Wir könnten Aggregation / Komposition verwenden (wie an anderer Stelle auf dieser Seite gezeigt), um dieselbe resultierende Klasse zu erzielen, aber der Nachteil der Verwendung von Aggregation / Komposition besteht darin, dass wir die Proxy- / Delegator-Methoden manuell zu jeder Klasse hinzufügen müssen, die dies sollte in der Lage sein zu protokollieren. Eigenschaften lösen dieses Problem gut, indem ich die Kesselplatte an einem Ort aufbewahren und bei Bedarf selektiv anwenden kann.

Hinweis: Da Merkmale in PHP ein neues Konzept sind, können sich alle oben geäußerten Meinungen ändern. Ich hatte noch nicht viel Zeit, das Konzept selbst zu bewerten. Aber ich hoffe, es ist gut genug, um Ihnen etwas zum Nachdenken zu geben.

:) Ich mag es nicht zu theoretisieren und darüber zu debattieren, was mit etwas gemacht werden soll. In diesem Fall Eigenschaften. Ich werde Ihnen zeigen, wofür ich Eigenschaften nützlich finde, und Sie können entweder daraus lernen oder sie ignorieren.

Eigenschaften - sie sind großartig, um Strategien anzuwenden . Kurz gesagt, Strategiedesignmuster sind nützlich, wenn dieselben Daten unterschiedlich behandelt (gefiltert, sortiert usw.) werden sollen.

Beispielsweise haben Sie eine Liste von Produkten, die Sie nach bestimmten Kriterien (Marken, Spezifikationen, was auch immer) herausfiltern oder nach verschiedenen Mitteln sortieren möchten (Preis, Etikett, was auch immer). Sie können ein Sortiermerkmal erstellen, das verschiedene Funktionen für verschiedene Sortiertypen (numerisch, Zeichenfolge, Datum usw.) enthält. Sie können dieses Merkmal dann nicht nur in Ihrer Produktklasse (wie im Beispiel angegeben) verwenden, sondern auch in anderen Klassen, die ähnliche Strategien benötigen (um eine numerische Sortierung auf einige Daten usw. anzuwenden).

Versuch es:

<?php
trait SortStrategy {
    private $sort_field = null;
    private function string_asc($item1, $item2) {
        return strnatcmp($item1[$this->sort_field], $item2[$this->sort_field]);
    }
    private function string_desc($item1, $item2) {
        return strnatcmp($item2[$this->sort_field], $item1[$this->sort_field]);
    }
    private function num_asc($item1, $item2) {
        if ($item1[$this->sort_field] == $item2[$this->sort_field]) return 0;
        return ($item1[$this->sort_field] < $item2[$this->sort_field] ? -1 : 1 );
    }
    private function num_desc($item1, $item2) {
        if ($item1[$this->sort_field] == $item2[$this->sort_field]) return 0;
        return ($item1[$this->sort_field] > $item2[$this->sort_field] ? -1 : 1 );
    }
    private function date_asc($item1, $item2) {
        $date1 = intval(str_replace('-', '', $item1[$this->sort_field]));
        $date2 = intval(str_replace('-', '', $item2[$this->sort_field]));
        if ($date1 == $date2) return 0;
        return ($date1 < $date2 ? -1 : 1 );
    }
    private function date_desc($item1, $item2) {
        $date1 = intval(str_replace('-', '', $item1[$this->sort_field]));
        $date2 = intval(str_replace('-', '', $item2[$this->sort_field]));
        if ($date1 == $date2) return 0;
        return ($date1 > $date2 ? -1 : 1 );
    }
}

class Product {
    public $data = array();

    use SortStrategy;

    public function get() {
        // do something to get the data, for this ex. I just included an array
        $this->data = array(
            101222 => array('label' => 'Awesome product', 'price' => 10.50, 'date_added' => '2012-02-01'),
            101232 => array('label' => 'Not so awesome product', 'price' => 5.20, 'date_added' => '2012-03-20'),
            101241 => array('label' => 'Pretty neat product', 'price' => 9.65, 'date_added' => '2012-04-15'),
            101256 => array('label' => 'Freakishly cool product', 'price' => 12.55, 'date_added' => '2012-01-11'),
            101219 => array('label' => 'Meh product', 'price' => 3.69, 'date_added' => '2012-06-11'),
        );
    }

    public function sort_by($by = 'price', $type = 'asc') {
        if (!preg_match('/^(asc|desc)$/', $type)) $type = 'asc';
        switch ($by) {
            case 'name':
                $this->sort_field = 'label';
                uasort($this->data, array('Product', 'string_'.$type));
            break;
            case 'date':
                $this->sort_field = 'date_added';
                uasort($this->data, array('Product', 'date_'.$type));
            break;
            default:
                $this->sort_field = 'price';
                uasort($this->data, array('Product', 'num_'.$type));
        }
    }
}

$product = new Product();
$product->get();
$product->sort_by('name');
echo '<pre>'.print_r($product->data, true).'</pre>';
?>

Abschließend denke ich über Merkmale wie Zubehör nach (mit denen ich meine Daten ändern kann). Ähnliche Methoden und Eigenschaften, die aus meinen Klassen herausgeschnitten und an einem einzigen Ort abgelegt werden können, für eine einfache Wartung, kürzeren und saubereren Code.

Ich freue mich über Traits, da sie ein häufiges Problem bei der Entwicklung von Erweiterungen für die Magento-E-Commerce-Plattform lösen . Das Problem tritt auf, wenn Erweiterungen einer Kernklasse (z. B. dem Benutzermodell) Funktionen hinzufügen, indem sie diese erweitern. Dazu zeigen Sie dem Zend-Autoloader (über eine XML-Konfigurationsdatei), dass er das Benutzermodell aus der Erweiterung verwenden soll, und lassen Sie dieses neue Modell das Kernmodell erweitern. ( Beispiel ) Aber was ist, wenn zwei Erweiterungen dasselbe Modell überschreiben? Sie erhalten eine "Rennbedingung" und nur eine wird geladen.

Die derzeitige Lösung besteht darin, die Erweiterungen so zu bearbeiten, dass eine die Modellüberschreibungsklasse des anderen in einer Kette erweitert, und dann die Erweiterungskonfiguration so festzulegen, dass sie in der richtigen Reihenfolge geladen werden, damit die Vererbungskette funktioniert.

Dieses System verursacht häufig Fehler. Bei der Installation neuer Erweiterungen müssen Sie nach Konflikten suchen und Erweiterungen bearbeiten. Dies ist ein Schmerz und unterbricht den Upgrade-Prozess.

Ich denke, die Verwendung von Traits wäre ein guter Weg, um dasselbe zu erreichen, ohne dass dieses nervige Modell die "Rennbedingung" außer Kraft setzt. Zugegeben, es könnte immer noch Konflikte geben, wenn mehrere Traits Methoden mit demselben Namen implementieren, aber ich würde mir vorstellen, dass eine einfache Namespace-Konvention dies größtenteils lösen könnte.

TL; DR Ich denke, Traits könnten nützlich sein, um Erweiterungen / Module / Plugins für große PHP-Softwarepakete wie Magento zu erstellen.

Sie könnten eine Eigenschaft für schreibgeschützte Objekte wie diese haben:

  trait ReadOnly{  
      protected $readonly = false;

      public function setReadonly($value){ $this->readonly = (bool)$value; }
      public function getReadonly($value){ return $this->readonly; }
  }

Sie können feststellen, ob dieses Merkmal verwendet wird, und bestimmen, ob Sie dieses Objekt in eine Datenbank, Datei usw. schreiben sollen oder nicht.