Damit ist dann zumindest der eine Teil, die Datenstruktur, für sich gekapselt. Was ist aber mit dem Teil, den wir wahrscheinlich häufiger verwenden werden? Wir nutzen Iteratoren in Schleifen und machen irgendwas mit den Elementen.

<?php
foreach($list as $key => $item) {
  $item->doSomething();
}

// oder
$values = array();
foreach($list as $key => $item) {
  $values[] = $item->getSomething();
}

In verschiedenen anderen Sprachen, Java, JavaScript etc., sieht man häufig, dass dort auch die Scheifen gekapselt sind. Warum probieren wir das nicht auch mal in PHP?

Ich werde das Beipiel bewusst einfach halten und wie gewohnt auf einige Fehlerbehandlungen verzichten, um den Code übersichtlich zu halten.

Als erstes erstellen wir eine Klasse “WalkableIterator” und lassen diese von ArrayIterator erben. Die beiden Methoden “each” und “walk” bilden später unsere beiden Beispiele ab.

<?php
class WalkableIterator extends ArrayIterator {
  public function each($method) {}
  public function walk($callback) {}
}

Mit each() können wir eine bestimmte Methode auf jedem Element in unserem Iterator aufrufen. Dafür müssten hier natürlich diverse Fehlerbehandlungen rein was passieren soll, wenn das Element kein Objekt ist oder die Methode nicht existiert oder diese gar eine Exception wirft.

<?php
class WalkableIterator extends ArrayIterator {
  public function each($method) {
    $args = func_get_args();
    $method = array_shift($args);
    foreach($this as $item) {
      call_user_func_array( array($item, $method), $args );
    }
  }
  // ...
}

Das ganze ist denkbar einfach: Die Methode nimmt als ersten Pflichtparameter den Methodennamen entgegen, die auf allen Elementen aufgerufen werden soll und der Rest bleibt flexibel und wird einfach nur durchgereicht.

Die Implementierung von walk() wird sogar noch einfacher, da hier keine Parameter weitergegeben werden müssen. Im produktiven Einsatz müssten auch hier noch die üblichen Fehlerbehandlungen rein.

<?php
class WalkableIterator extends ArrayIterator {
  // ...
  public function walk($callback) {
    foreach($this as $item) {
      call_user_func( $callback, $item );
    }
  }
}

Soweit, so einfach… Was können wir jetzt damit machen? Bauen wir ein kleines Beispiel.

<?php
// Testklasse
class Person {
  private $name;
  public function __construct($name = 'unnamed') {
    $this->setName($name);
  }
  public function getName() {
    return $this->name;
  }
  public function setName($name) {
    $this->name = $name;
  }
}

// Testarray mit Objekten befüllen
$a = array();
for($i=1; $i <= 10; $i++) {
  $a[] = new Person('Person ' . $i);
}

// Iterator erstellen und Namen ausgeben
$it = new WalkableIterator($a);

foreach($it as $item) {
  echo $item->getName() . '<br/>';
}

// Person 1
// ...
// Person 10

Wollten wir nun allen Personenobjekten einen Namen geben, so könnten wir dafür each() verwenden.

<?php
$it->each('setName', 'PHP-Nerd');

// PHP-Nerd
// ...
// PHP-Nerd

Wollen wir unsere Personen dann vielleicht doch wieder individueller benennen, so könnten wird das mit walk() und einem Callback machen.

$callback = function(Person $person) {
  static $count = 1;
  $person->setName( $person->getName() . ' ' . $count++ );
};

$it->walk($callback);

// PHP-Nerd 1
// ...
// PHP-Nerd 10

“Was bringt uns das und warum so kompliziert?”, ist in dem Zusammenhang eine oft gehörte Frage.

Zunächst ist die Implementierung, wie das Beispiel sicher beweist, nicht kompliziert.

Die Vorteile sind kürzere Aufrufe im Code, weil wir keine Schleifen mehr schreiben müssen und durch die Kapselung verbessert sich auch die Wart- und Testbarkeit. Der Code existiert nur an einer Stelle und funktioniert überall nach dem selben Muster.

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"

Die allgemeine Erwartung ist sicher, dass range() schneller ist und umso mehr überraschte zumindest mich sein Ergebnis.

Also habe ich schnell einen kleinen Test dafür geschrieben und dabei eine weitere Überraschung erlebt.

Zunächst mein Test-Script, mit dem ich jede Möglichkeit 1000 Mal probiere, um vergleichbare Zahlen zu bekommen. Neben range() und array_push() habe ich auch noch den Operator [] getestet.

<?php
$numLoops = 1000;

$total = 0;
for ($i = 0; $i < $numLoops; $i++) {
  $start = microtime(true);

  $range = range(1,20); 

  $total += microtime(true) - $start;
}

echo 'Gesamtzeit range() = ' . $total . '<br/>';

$total = 0;
for ($i = 0; $i < $numLoops; $i++) {
  $start = microtime(true);

  $range = array();
  for ($j = 1; $j <= 20; $j++) {
    array_push($range, $j);
  }

  $total += microtime(true) - $start;
}

echo 'Gesamtzeit Schleife/array_push() = ' . $total . '<br/>'; 

$total = 0;
for ($i = 0; $i < $numLoops; $i++) {
  $start = microtime(true);

  $range = array();
  for ($j = 1; $j <= 20; $j++) {
    $range[] = $j;
  }

  $total += (microtime(true) - $start);
}

echo 'Gesamtzeit Schleife/[] = ' . $total . '<br/>';

Ein recht gutes Ergebnis sieht so aus und man kann schon sehr gut die Unterschiede sehen.

Gesamtzeit range()               = 0.0055239200592041
Gesamtzeit Schleife/array_push() = 0.015237808227539
Gesamtzeit Schleife/[]           = 0.0075914859771729

In diesem Test brauchte die Schleife mit array_push() doppelt so lange wie die mit dem  []-Oparator und sogar dreimal länger als range().

Das zeigt, dass man sich doch auf die PHP-eigenen Funktionen verlassen kann und dass Faulheit manchmal auch belohnt wird, wenn man statt array_push() nur [] verwendet.

In dem Artikel wird beschrieben, wie man Daten aus einem Array in ein Objekt (oder auch umgekehrt) überführen kann, ohne jedesmal eine foreach-Schleife zum Kopieren herumzubauen. Der Trick ist einfach, wie auch genial: Einfach ein Typecast und gut ist.

Ähnliches habe ich ja schonmal in einem Artikel über den Umgang mit “Nicht-Arrays” und foreach-Schleifen beschrieben.