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.

Ganz klar, es handelt sich um die Interfaces Iterator und IteratorAggregate. Was aber unterscheidet die beiden?

Um den Aufbau der beiden Klassen gegenüberzustellen habe ich zwei einfache Beispiel-Klassen geschrieben, mit denen wir ein Array in einer foreach-Schleife auslesen können.

Iterator

Das Interface Iterator schreibt fünf Methoden vor, die zur Verarbeitung des Objektes in einer Schleife benötigt werden: current(), next(), key(), valid() und rewind().

<?php
class TestA implements Iterator
{
  private $_items;

  public function __construct(array $items = array())
  {
    $this->_items = $items;
  }

  public function current()
  {
    return current($this->_items);
  }

  public function next()
  {
    next($this->_items);
  }

  public function key()
  {
    return key($this->_items);
  }

  public function valid()
  {
    return false !== current($this->_items);
  }

  public function rewind()
  {
    reset($this->_items);
  }
}

Auf den ersten Blick lässt sich erkennen, dass relativ viel Code benötigt benötigt wird und dieser starr am Objekt hängt. Ok, für diesen Zweck hätte man auch den ArrayIterator nehmen können, aber dann gäbe es weniger zu gucken.

IteratorAggregate

Das zweite Iterface ist dagegen wesentlich schlanker, denn es kommt mit der einzigen Methode getIterator() aus.

<?php
class TestB implements IteratorAggregate
{
  private $_items;

  public function __construct(array $items = array())
  {
    $this->_items = $items;
  }

  public function getIterator()
  {
    return new ArrayIterator($this->_items);
  }
}

Die Methode erzeugt einen externen Iterator und lagert damit die Funktionalität in eine andere Klasse aus. Dadurch bleibt unsere Klasse übersichtlich und das Iterator-Verhalten lässt sich einfach austauschen.

Fazit

Für einfache Strukturen würde ich das IteratorAggregate-Interface vorziehen, da es sehr einfach aufgebaut ist und unseren Code schlank und übersichtlich hält. Die Funktionalität ist zudem durch verschiedene externe Klassen variabel und viele Standardfälle können mit den SPL-Klassen abgedeckt werden.

Lässt sich eine Struktur aus irgendeinem Grund nicht an einen externen Iterator übergeben, bzw. will man für diesen speziellen Fall schreiben, dann kommt das Iterator-Interface zum Einsatz.

Genaugenommen lässt sich das mit den beiden Beispielklassen schon gut testen. Einfach in der Klasse TestB

public function getIterator()
{
  return new ArrayIterator($this->_items);
}

gegen

public function getIterator()
{
  return new TestA($this->_items);
}

austauschen und etwas damit rumspielen.

In der Anwendung sind beide später identisch:

<?php
$a = new TestA(array('A','B','C','D','E'));

foreach ($a as $k => $v) {
  echo "$k = $v <br/>";
}

$b = new TestB(array('A','B','C','D','E'));

foreach ($b as $k => $v) {
  echo "$k = $v <br/>";
}

Viel Spaß damit! Eure Erkenntnisse zu dem Thema könnt ihr wie immer gerne in den Kommentaren verewigen…

Was kann unser Model dann, was es vorher noch nicht konnte? Durch die Verwendung des Interfaces können wir die gespeicherten Daten in einer foreach-Schleife verarbeiten. Das kann z.B. beim erzeugen von Tabellen erforderlich sein.

Wie immer beginne ich mit einer Skizze der heutigen Erweiterungen.

<?php
interface Custom_Model_Interface
  extends ArrayAccess,
          Iterator,
          Countable
{
}

Unser Interface Custom_Model_Interface erweitert zunächst das Iterator-Interface und auch Countable. Dadurch lassen sich dann die Elemente des Objektes zählen und in Verbindung mit ArrayAccess auch beliebig in einer for-Schleife verarbeiten.

In unserer Klasse müssen wir nun die entsprechenden Methoden deklarieren.

<?php
class Custom_Model implements Custom_Model_Interface
{
  // ...

  public function current() {}
  public function key() {}
  public function next() {}
  public function rewind() {}
  public function valid() {}
  public function count() {}

// ...
}

Jedem, der lange genug mit PHP arbeitet sollte nun was auffallen. Richtig! Wir halten unsere “Feldnamen” in einem Array und zu fast jeder Methode gibt es eine gleichnamige Array-Funktion.

Da wir aber an meistens an die Werte und nicht an die Namen der Felder wollen, müssen wir etwas tricksen.

Die erste Methode current() gibt das jeweilige Element an der Position des internen Zeigers zurück und entspricht damit der gleichnamigen Array-Funktion current().

public function current()
{
  return $this->_get(current($this->_keys));
}

Das Gegenstück dazu stellt quasi key() dar, da es den Feldnamen der Position liefert.

public function key()
{
  return $this->_keys[key($this->_keys)];
}

Auf den ersten Blick mag diese Schreibweise vielleicht etwas verwirren, aber nur so bekommen wir den richtigen Schlüssel. key() gibt uns den aktuellen Schlüssel von $this->_keys zurück, wir wollen den Wert der jeweiligen Position haben.

Um nun in der Schleife den internen Zeiger bewegen zu können, brauchen wir next().

public function next()
{
  next($this->_keys);
}

Wird das Objekt ein weiteres Mal mit foreach verarbeitet, so muss der interne Zeiger wieder auf die erste Position zurückgesetzt werden. Das Iterator-Interface schreibt dafür die Methode rewind() vor, die dann intern reset() verwenden kann.

public function rewind()
{
  reset($this->_keys);
}

Innerhalb der Schleife wir überprüft, ob weitere Elemente vorhanden sind. Dazu wird valid() verwendet.

public function valid()
{
  return current($this->_keys) !== false;
}

Damit haben wir alles notwendige eingebaut, damit unser Model in einer foreach-Schleife ausgelesen werden kann.

foreach($model as $key=>$value) {
  echo $key . ' = ' . $value . '<br/>';
}

Zuletzt gibt es dann auch noch die Methode count() des Countable-Interfaces, damit wir beliebig mit for-Schleifen über das Objekt iterieren können.

public function count()
{
  return count($this->_keys);    
}

und

for($i=0; $i<count($model); $i++) {
  echo $i . ' = ' . $model[$i] . '<br/>';
}

Damit wären wir auch schon wieder am Ende. Beim nächsten Mal geht es dann weiter mit dem Observer-Pattern.