Der herkömmliche Weg eine Instanz einer Klasse zu erzeugen ist die Verwendung des new-Operators.

<?php
$meinObject = new MeineKlasse();
$meineKlasse->machWas();

Leider funktioniert Methodenverkettung in PHP nicht wie in Java direkt nach “new” und wir müssen uns mit einer statischen Methode behelfen. Das Prinzip ähnelt dem Singleton-Muster, jedoch wollen wir in diesem Fall bei jedem Aufruf eine neue Instanz bekommen. Wer schonmal mit (Borland-)Delphi gearbeitet hat, der kennt das sicher schon.

<?php
class MeineKlasse
{
  public static function create()
  {
    return new self();
  }
}

Der Vorteil ist nun ganz klar der, dass sich Instanzen in einer Zeile benutzen lassen.

<?php
MeineKlasse::create()->machWas();

Leider fallen mir aber auch spontan zwei Nachteile ein: Bis PHP 5.3 ist die Methode nicht vererbbar, das bedeutet, dass wir die Methode mit jeder Ableitung erneut überschreiben müssten. Ab Version 5.3 kann statt “self” dann “static” instanziiert werden. Genaueres findet sich auch in den Links in meinem Singleton-Artikel.

Der zweite Nachteil ist genau der, warum man auch “new” nicht verwenden sollte. Beides schafft an vielen Stellen im Code Abhängigkeitet zu einer bestimmten Klasse. Wenn nun irgendwann eine abgeleitete Klasse benötigt wird müssen viele Änderungen gemacht werden.

Im Zweifelsfall sollte auf eine klassische, externe Factory zurückgegriffen werden, um derartigen Problemen im Voraus aus dem Weg zu gehen.

Es gibt aber auch Fälle, in denen die magische Methode __call() den Code lesbarer machen kann und gleichzeitig eine Menge Schreibarbeit einspart.

Stellen wir uns einfach mal vor, wir hätten ein Model mit 20 Werten und wollen es anhand eines bestimmten Feldes laden.

<?php
$model->load($id);  // lädt das Model mit Defaultkey = $id, oder

$model->load('Daniel', 'name');  // Feld 'name' = 'Daniel'

Letzteres ist durchaus gut zu lesen und lädt bestenfalls auch die richtigen Daten. Mit __call() lässt sich das ganze ohne viel Aufwand noch etwas dekorieren, so dass wir das Model dann so laden können:

<?php
$model->loadByName('Daniel');

Nun könnte man entweder für alle 20 Felder die jeweiligen Methoden schreiben, oder eine Art Template mit __call() und eines RegEx erstellen und den Aufruf einfach deligieren.

<?php
class Custom_Model
{
  public function __call($method, $args)
  {
    if (preg_match('/^loadBy([a-zA-Z]*?)$/', $method, $matches))
      return $this->load($args[0], $matches[1]);
    }
    // ...
  }
}

Der Vorteil ist ganz klar die eingesparte Tipparbeit und eine übersichtlichere Klasse, da wir alleine für diese Funktionalität 20 Methoden weniger im Code haben. Jedoch ist auch der Nachteil nicht außer Acht zu lassen. Weil die Methoden nur virtuell existieren, sind sie z.B. für die IDE unsichtbar und sind daher auch für neue Entwickler nicht sofort erkennbar.

Es bleibt also wieder dem eigenen Geschmack überlassen, für welchen Weg man sich entscheidet.

Da es ja nicht sonderlich spannend ist, ein Schnipsel Beispielcode zu Bloggen, dachte ich mir daraus einfach einen Mittagspausen-Spaß-Contest daraus zu machen. Schreibt Code, der die Aufgabe löst, die Liste nicht verändert und dabei besonders ist. Also z.B. besonders kurz, besonders verrückt oder besonders “designverpattert”. Was auch immer, ob in den Kommentaren oder in eurem Blog.

Zu gewinnen gibt es außer Spaß leider nichts, aber ich hoffe trotzdem auf eine rege Teilnahme.

Ein hoffentlich anfängerfreundliches Beispiel könnte also so aussehen:

<?php
$elements = array('Apfel','Banane','Erdbeere','Birne');

$count = count($elements);

$str = '';
foreach ($elements as $index => $element) {
  if ($index > 0) {
    if ($index < ($count - 1)) {
      $str .= ', ';
    } else {
      $str .= ' und ';
    }
  }
  $str .= $element;
}

echo $str;  // Ausgabe: Apfel, Banane, Erdbeere und Birne

Ein anderer Weg wäre eine Lösung mit den Array-Funktionen, wobei hier aber durch array_pop() das Array verändert würde.

$lastElement = array_pop($elements);
echo implode(', ', $elements) . ' und ' . $lastElement;

Nun also ran an die Tasten und abschicken.

Die gewohnte, und sicher aus jedem Informatikuntericht bekannte Form des If/If-Else kann ja bekanntlich beliebig viele Bedingungen abdecken und ist für Kontrollstrukturen auch sehr gut geeignet.

<?php
if ($bedingung1) {
  // mach was
} else if ($bedingung2) {
  // mach was anderes
} else {
  // mach was ganz anderes
}

Die geschweiften Klammern sind zwar bei nur einer folgenden Anweisung optional, aber sollten dennoch immer geschrieben werden, denn spätestens mit der nächsten Änderung und einer weiteren Anweisung werden sie gebraucht.

Für einfache Überprüfungen z.B. ob eine Variable gesetzt ist oder nicht, ist dieses Konstrukt dann aber doch etwas unhandlich.

<?php
if ('ja' == $wert) {
  $variable = 1;
} else {
  $variable = 0;
}

Nun gut, der Code ist nicht besonders sinnvoll, aber es geht ja auch nur um ein Beipiel. In der Kurzschreibweise sieht die selbe Logik dann so aus:

<?php
$variable = 'ja' == $wert ? 1 : 0;

Es müssen aber auch nicht immer Zuweisungen von Variablen sein, auch einfache Verzweigungen sind damit möglich. Ob man das im Code haben mag oder nicht sollte dann jeder für sich entscheiden.

<php
function peng() { echo __FUNCTION__; }
function puff() { echo __FUNCTION__; }

$flag = true;
$flag ? peng() : puff();

// Ausgabe: peng

Noch kürzer geht es, wenn wir auf Objektinstanzen prüfen wollen und gegebenenfalls eine Instanz erzeugen müssen.

<?php
class Obst {
  private $_name;
  public function __construct($name) { $this->_name = $name; }
  public function __toString() { return $this->_name; }
}

$test = new Obst('Apfel');

echo $test ?: new Obst('Birne');

// Ausgabe: Apfel

In diesem Fall wird nur dann eine neu Instanz von Obst erzeugt, wenn $test null ist. Dementsprechend wäre dann die Ausgabe Birne.

Zeitlich war das wie erwartet locker drin, nur leider klappte das mit dem Inline aufgrund der Funktion sort() nicht, da diese das zu sortierende Array als Referenz verarbeitet.

Kleine Spielerei aber vielleicht braucht ja mal jemand den Schipsel.

<?php
$file = 'pfad/zur/datei.csv';
$lines = file($file);
sort($lines);
file_put_contents($file, implode('', $lines));

Einmal ausgeführt und aus

"test","test"
"bla","blubber"
"apfel","apfel"

wird

"apfel","apfel"
"bla","blubber"
"test","test"

Alle, die bislang nur wenig oder keine Erfahrung mit MVC-Anwendungen gesammelt haben, werden sich vielleicht nun fragen, wofür dieses Objekt gut ist. Das Response-Objekt kontrolliert die komplette Ausgabe der Anwendung an den Client (z.B. einen Browser).

Während der kompletten Laufzeit können mit dem Objekt Ausgaben gesammelt und auch nachträglich verändert werden und auch die Reihenfolge spielt keine Rolle. So kann nun zuerst die Ausgabe gemacht werden und dann die Header gesetzt werden.

So müsste es klassisch mit PHP geschrieben werden:

<?php header('Content-type: text/xml'); echo $xml;

Wenn wir nun die Reihenfolge vertauschen würden, hätte das eine Warning zur Folge.

<?php echo $xml; header('Content-type: text/xml');

Warning: Cannot modify header information - headers already sent by (output started at ####) in #### on line 3

Wenn wir uns in einer MVC-Umgebung befinden, stellt diese Reihenfolge kein Problem dar, denn das Objekt verwaltet die Ausgabe und schickt alles zur rechten Zeit raus.

So könnte es dann z.B. in einer Action des Kontrollers aussehen:

<?php public function indexAction() { // ... $this->getResponse()->appendBody($xml); $this->getResponse()->setHeader('Content-type', 'text/xml'); } 

Neben den relativ harmlosen direkten Ausgaben mit echo oder print habe ich in den vergangenen Jahren auch Ausgaben mit die() gefunden. Die offensichtliche Arbeit verrichtet die Anwendung zwar in den Actions der Kontroller, aber es passiert unter Umständen auch vor- und nachher eine Menge. Letzteres würde dann unterbunden werden und evtl. wichtige Aufgaben nicht mehr abgearbeitet werden.

Ein Beispiel sah etwa so aus:

<?php
public function jsonAction()
{
  // ...
  header('Content-type: text/json');
  die($json);
  // ...
}

Die Anwendung verliert so die Kontrolle über die Ausgabe und wird an der falschen Stelle beendet. Der richtige Weg führt auch hier zum Response-Objekt.

<?php
public function jsonAction()
{
  // ...
  $this->getResponse()->setHeader('COntent-type', 'text/json');
  $this->getResponse()->appendBody($json);
  return;  // <== falls die Bearbeitung hier enden soll
  // ...
}

So, nun gibt es in Zukunft keine Ausreden mehr, wenn irgendwo ein echo im Kontroller steht. Ich würde mich natürlich wie immer freuen eure Erfahrungen in den Kommentaren zu lesen.

Nebenbei bemerkt ist das mein 50. Artikel, also schon fast ein kleiner Grund zum Feiern.

Viele Methoden sind mit __call() implementiert und das hat die Nachteile, dass z.B. die Codecompletion, Reflection, automatische Dokumentation oder die Navigation in der IDE ausgehebelt werden.

Zum Glück können wir das ja zum Teil in vererbten Klassen wieder abfangen, ohne die ursprünglichen Klassen umschreiben zu müssen, z.B. weil wir die fremden Libraries zwecks späterer Updates nicht verändern wollen.

<?php

class A
{
  public function __call($method, $args)
  {
    echo __METHOD__ . ' ' . $method;
  }
}

class B extends A
{
  public function machWas()
  {
    parent::machWas();
  }
}

$b = new B();
$b->machWas();

Die Methode B::machWas() delegiert den Aufruf an die magische Methode, wobei sich das Verhalten nach außen nicht verändert, jedoch alles andere wieder funktionieren wird.