SPL Interfaces

Wie ich bereits in einer meiner älteren Beiträge angekündigt, geht es dieses mal um Interfaces, die von der SPL zur Verfügung gestellt werden. Besonders interessant sind dabei die drei Intafaces IterateAggregate, ArrayAccess und Countable. Ich stelle die drei Interfaces am besten einmal vor.

Countable Interface

Mit diesem Interface ist es möglich, die Funktion count() auf eine Klasse anzuwenden. Das ist zum Beispiel dann sinnvoll, wenn die Klasse ein Array enthält und man wissen möchte, wie viele Elemente dieses Array enthält, ohne dabei eine Methode aufrufen zu müssen. Wenn ihr das Countable Interface implementiert, müsst ihr allerdings eine Methode count() schreiben. Hier ein kleines Beispiel:

class Map implements Countable
{
    protected $data = array();
 
    public function __construct() {}
 
    public function addElement($var)
    {
        $this->data[] = $var;
    }
 
    public function count()
    {
        return count($this->data);
    }
}
 
$map = new Map();
$map->addElement("foo");
$map->addElement("bar");
echo count($map);

Die Ausgabe des Beispiels wird wie zu erwarten „2“ lauten.

IterateAggregate

Dieses Interface erlaubt es uns eine Klasse mittels foreach zu durchlaufen. Als Beispiel erweitere ich einfach mal unsere Map-Klasse.

class Map implements Countable, IterateAggregate
{
    protected $data = array();
 
    public function __construct() {}
 
    public function addElement($var)
    {
        $this->data[] = $var;
    }
 
    public function count()
    {
        return count($this->data);
    }
 
    public function getIterator()
    {
        return new ArrayIterator($this->data);
    }
}
 
$map = new Map();
$map->addElement("foo");
$map->addElement("bar");
foreach($map as $entry)
{
    echo $entry;
}

Wie man sieht, müssen wir der Klasse lediglich eine weitere Methode getIterator() hinzufügen, die ein Objekt der Klasse ArrayIterator zurückgibt.

ArrayAccess

Und auch das letzte Interface, das ich vorstellen möchte, hat wieder mit Arrays zu tun. Dieses Mal erlaubt uns das Interface auf die Klasse so zuzugreifen, als ob sie ein Array wäre, also mit $object[„foo“]. Ich schreibe das Map-Beispiel jetzt einmal um, damit der Code nicht zu lang wird. Ihr könnt die drei Interfaces aber auch zusammen nutzen.

class Map implements ArrayAccess
{
    protected $data = array();
 
    public function __construct() {}
 
    public function addElement($key, $value)
    {
        $this->data[$key] = $value;
    }
 
    public function offsetSet($offset, $value)
    {
        $this->data[$offset] = $value;
    }
 
    public function offsetExists($offset)
    {
        return isset($this->data[$offset]);
    }
 
    public function offsetUnset($offset)
    {
        unset($this->data[$offset]);
    }
 
    public function offsetGet($offset)
    {
        return isset($this->offsetExists($offset)) ? $this->data[$offset] : null;
    }
}
 
$map = new Map();
$map->addElement("foo", "Apfel");
$map->addElement("bar", "Banane");
echo $map["foo"];

Hier müssen wir der Klasse noch vier zusätzliche Methoden mitgeben. Die Namen sollten eigentlich selbsterklärend sein.

So, das waren auch erst einmal die wichtigsten und nützlichsten Interfaces der SPL. Wie man sieht, hat die SPL Möglichkeiten, die uns kein anderes Framework bieten kann. Aus dem Grund ist es seit PHP 5.3 auch standardmäßig dabei, wobei es bei den meisten Webserver-Installationen im Normalfall schon zur Verfügung stehen sollte.