PHP 5.4 – Neuerungen für Schreibfaule

Nachdem PHP 5.4 nun offiziell erschienen ist, möchte ich dieses Ereignis zum Anlass nehmen, ein paar neue Features zu beleuchten. Sicher, PHP 5.4 macht zwar nicht einen so gewaltigen Satz wie es damals von Version 5.2 auf 5.3 gelang. Dennoch gibt es viele interessante Neuerungen. Dabei stehen oft Traits im Vordergrund, die ich heute aber nicht behandeln möchte (siehe dazu: http://www.codenaschereien.de/php/traits-was-soll-das-alles/). Werfen wir also einen Blick auf die Kleinigkeiten, die uns als PHP-Programmierer zukünftig das Leben nicht nur in Sonderfällen, sondern im täglichen Doing, erleichtern sollen.

Zugriff auf Klassenmember während der Instantiierung

Schreibfaule kamen bisher einfach nicht auf Ihre Kosten:

$o = new Obj();
$o->doSomething(); //two lines needed

Damit ist nun glücklicherweise Schluss. PHP 5.4 räumt mit diesen Eigenheiten auf und erlaubt das folgende Konstrukt:

(new Obj())->doSomething();

Super! Das spart Codezeilen und wirkt auch nicht mehr so angestaubt. Sicherlich ist es auch ein wenig Geschmackssache – mich überzeugt es aber.

Änderungen bei Arrays:

Auch bei Arrays ist ab sofort weniger Tipparbeit nötig. Dies macht sich vor allem bei Funktionen bemerkbar, die Arrays zurückgeben. Gegeben sei folgende Funktion:

function getArray() {
  return array(1,2,3);
}

Bisher musste man Folgendes schreiben, um auf den ersten Wert des Rückgabearrays zugreifen zu können:

$arr = getArray();
echo $arr[0]

PHP 5.4 räumt auch hier auf und bietet die folgende Möglichkeit an:

echo getArray()[0];

Außerdem gibt es eine Kurzschreibweise für die Initialisierung von Arrays:

$arr = [1,2,3,4];

getArray() könnte damit also auch so aussehen:

function getArray() {
  return [1,2,3,4];
}

Typehints

Leider zog nicht das Feature ein, auch skalare Typen als Typehints benutzen zu können. Zwischenzeitlich wurde zwar viel darüber diskutiert – letztendlich wurde es aber wieder verworfen. Dennoch gibt es auch hier eine sinnvolle Ergänzung namens „callable“. Damit kann eine Funktion vorraussetzen, dass ein übergebener Parameter aufrufbar ist. Jetzt kann man behaupten: Das hat vorher doch auch schon mit dem Closure-Typehint funktioniert:

function callme(Closure $c) {
  $c();
}

Richtig, es gibt nur ein Problem mit built-in-Funktionen. Diese müssen nämlich in einem Closure „gewrapped“ werden – denn Strings akzeptiert der Closure-Typehint nicht:

callme(function() { flush(); });

Nun geht das auch einfacher:

function callme(callable $c) {
  c();
}

callme('flush');

Closures

Bleiben wir bei Closures, denn hier gibt es eine weitere, interessante Neuerung. Man kann nun $this in Closures verwenden, wenn man PHP mitteilt, was das aktuelle Objekt ist:

class T {
  public function init() {
    $obj = $this;
    $c = function() use ($obj) {
      $this->doSomething();
    };
    $c();
  }

  private function doSomething() {
    echo __METHOD__;
  }
}

$t = new T();
$t->init();

Interessant dabei ist vor allem der Zugriff auf objektinterne Methoden, was wir im obigen Beispiel am Schlüsselwort private erkennen können.

Callbacks

Von Closures zu Callbacks. Diese können nun endlich auch ohne call_user_func() aufgerufen werden:

class T {
  public function doSomething() {
    echo __METHOD__;
  }
}

$t = new T();
$callback = array($t, 'doSomething');
$callback();

Fazit:

In diesem Artikel habe ich versucht vor allem jene Features herauszustellen, die einem vor allem Schreibarbeit ersparen oder die Lesbarkeit des Codes erhöhen. Sicherlich wird man davon nicht alle im täglichen Gebrauch verwenden können. Als nützlich erscheinen die Neuerungen für mich aber allemal und ich werde sie mir im Hinterkopf behalten.

Links

https://wiki.php.net/rfc/instance-method-call

https://wiki.php.net/rfc/callable

https://wiki.php.net/rfc/shortsyntaxforarrays

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *