Vordefinierte Interfaces und Klassen

Inhaltsverzeichnis

Traversable — Das Traversable-Interface
Iterator — Das Iterator-Interface
- Iterator::current — Gibt das aktuelle Element zurück
- Iterator::key — Gibt den Schlüssel des aktuellen Elements zurück
- Iterator::next — Rückt den Zeiger auf das nächste Element vor
- Iterator::rewind — Setzt den Iterator auf das erste Element zurück
- Iterator::valid — Prüft, ob die aktuelle Position zulässig ist
IteratorAggregate — Das IteratorAggregate-Interface
- IteratorAggregate::getIterator — Holt einen externen Iterator
ArrayAccess — Das ArrayAccess-Interface
- ArrayAccess::offsetExists — Prüft, ob ein Offset-Punkt existiert
- ArrayAccess::offsetGet — Gibt den Wert eines Offset-Punkts zurück
- ArrayAccess::offsetSet — Zuweisen eines Wertes an angegebenen Offset
- ArrayAccess::offsetUnset — Löschen eines Offsets
Serializable — Das Serializable-Interface
- Serializable::serialize — Stringrepräsentation eines Objekts
- Serializable::unserialize — Erstellt das Objekt
Closure — The Closure class
- Closure::__construct — Constructor that disallows instantiation
- Closure::bind — Duplicates a closure with a specific bound object and class scope
- Closure::bindTo — Duplicates the closure with a new bound object and class scope
- Closure::call — Binds and calls the closure
- Closure::fromCallable — Converts a callable into a closure.
Generator — Die Generator Klasse
- Generator::current — Get the yielded value
- Generator::getReturn — Get the return value of a generator
- Generator::key — Get the yielded key
- Generator::next — Resume execution of the generator
- Generator::rewind — Rewind the iterator
- Generator::send — Send a value to the generator
- Generator::throw — Throw an exception into the generator
- Generator::valid — Check if the iterator has been closed
- Generator::__wakeup — Serialize callback

Siehe auch SPL-Interfaces und reservierte Klassen.

Das Traversable-Interface

Einführung

Interface, um herauszufinden, ob eine Klasse mittels foreach traversierbar ist.

Das abstrakte Interface kann nicht direkt implementiert werden. Stattdessen müssen Sie es entweder mittels IteratorAggregate oder Iterator implementieren.

Hinweis:
Interne (eingebaute) Klassen, die dieses Interface implementieren, können in foreach-Konstrukten verwendet werden und benötigen keine explizite Implementierung von IteratorAggregate oder Iterator.

Hinweis:
Es handelt sich um ein internes Interface der Engine, das nicht in PHP-Skripten implementiert werden kann. Statt dessen müssen IteratorAggregate oder Iterator verwendet werden. Wenn ein Interface implementiert wird, das Traversable erweitert, ist sicherzustellen, dass IteratorAggregate oder Iterator vor dessen Name in der implements Klausel angegeben wird.

Interface-Übersicht

Traversable

class Traversable {

}

Dieses Interface besitzt keine Methoden, sein einziger Sinn ist es, als Basisinterface für alle traversierbaren Klassen zu dienen.

Das Iterator-Interface

Einführung

Interface für externe Iteratoren oder Objekte, die selbstiterierend sind.

Interface-Übersicht

Iterator

class Iterator extends Traversable {

/* Methoden */

abstract public mixed current ( void )

abstract public scalar key ( void )

abstract public void next ( void )

abstract public void rewind ( void )

abstract public boolean valid ( void )

}

Vordefinierte Iteratoren

PHP bietet bereits eine Anzahl von Iteratoren für viele alltägliche Aufgaben an. SPL iterators enthält eine entsprechende Liste.

Beispiele

Beispiel #1 Basisnutzung

Dieses Beispiel demonstriert, in welcher Reihenfolge Methoden aufgerufen werden, wenn Sie foreach auf einem Iterator anwenden.


<?php
class meinIterator implements Iterator {
    private $position = 0;
    private $array = array(
        "erstesElement",
        "zweitesElement",
        "letztesElement",
    );

    public function __construct() {
        $this->position = 0;
    }

    function rewind() {
        var_dump(__METHOD__);
        $this->position = 0;
    }

    function current() {
        var_dump(__METHOD__);
        return $this->array[$this->position];
    }

    function key() {
        var_dump(__METHOD__);
        return $this->position;
    }

    function next() {
        var_dump(__METHOD__);
        ++$this->position;
    }

    function valid() {
        var_dump(__METHOD__);
        return isset($this->array[$this->position]);
    }
}

$it = new meinIterator;

foreach($it as $key => $value) {
    var_dump($key, $value);
    echo "\n";
}
?>

Das oben gezeigte Beispiel erzeugt eine ähnliche Ausgabe wie:

string(18) "meinIterator::rewind"
string(17) "meinIterator::valid"
string(19) "meinIterator::current"
string(15) "meinIterator::key"
int(0)
string(12) "erstesElement"

string(16) "meinIterator::next"
string(17) "meinIterator::valid"
string(19) "meinIterator::current"
string(15) "meinIterator::key"
int(1)
string(13) "zweitesElement"

string(16) "meinIterator::next"
string(17) "meinIterator::valid"
string(19) "meinIterator::current"
string(15) "meinIterator::key"
int(2)
string(11) "letztesElement"

string(16) "meinIterator::next"
string(17) "meinIterator::valid"

Das IteratorAggregate-Interface

Einführung

Interface, um einen externen Iterator zu erzeugen.

Interface-Übersicht

IteratorAggregate

class IteratorAggregate extends Traversable {

/* Methoden */

abstract public Traversable getIterator ( void )

}

Beispiel #1 Basisnutzung


<?php
class meineDaten implements IteratorAggregate {
    public $property1 = "Öffentliche Eigenschaft eins";
    public $property2 = "Öffentliche Eigenschaft zwei";
    public $property3 = "Öffentliche Eigenschaft drei";

    public function __construct() {
        $this->property4 = "letzte Eigenschaft";
    }

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

$obj = new meineDaten;

foreach($obj as $key => $value) {
    var_dump($key, $value);
    echo "\n";
}
?>

Das oben gezeigte Beispiel erzeugt eine ähnliche Ausgabe wie:

string(9) "property1"
string(19) "Öffentliche Eigenschaft eins"

string(9) "property2"
string(19) "Öffentliche Eigenschaft zwei"

string(9) "property3"
string(21) "Öffentliche Eigenschaft drei"

string(9) "property4"
string(13) "letzte Eigenschaft"

Das ArrayAccess-Interface

Einführung

Interface, um Objekte als Arrays ansprechen zu können

Interface-Übersicht

ArrayAccess

class ArrayAccess {

/* Methoden */

abstract public boolean offsetExists ( mixed $offset )

abstract public mixed offsetGet ( mixed $offset )

abstract public void offsetSet ( mixed $offset , mixed $value )

abstract public void offsetUnset ( mixed $offset )

}

Beispiel #1 Basisnutzung


<?php
class obj implements ArrayAccess {
    private $container = array();

    public function __construct() {
        $this->container = array(
            "eins"  => 1,
            "zwei"  => 2,
            "drei"  => 3,
        );
    }

    public function offsetSet($offset, $value) {
        if (is_null($offset)) {
            $this->container[] = $value;
        } else {
            $this->container[$offset] = $value;
        }
    }

    public function offsetExists($offset) {
        return isset($this->container[$offset]);
    }

    public function offsetUnset($offset) {
        unset($this->container[$offset]);
    }

    public function offsetGet($offset) {
        return isset($this->container[$offset]) ? $this->container[$offset] : null;
    }
}

$obj = new obj;

var_dump(isset($obj["zwei"]));
var_dump($obj["zwei"]);
unset($obj["zwei"]);
var_dump(isset($obj["zwei"]));
$obj["zwei"] = "Ein Wert";
var_dump($obj["zwei"]);
$obj[] = 'Anhängen 1';
$obj[] = 'Anhängen 2';
$obj[] = 'Anhängen 3';
print_r($obj);
?>

Das oben gezeigte Beispiel erzeugt eine ähnliche Ausgabe wie:

bool(true)
int(2)
bool(false)
string(7) "Ein Wert"
obj Object
(
    [container:obj:private] => Array
        (
            [eins] => 1
            [drei] => 3
            [zwei] => Ein Wert
            [0] => Anhängen 1
            [1] => Anhängen 2
            [2] => Anhängen 3
        )

)

Das Serializable-Interface

Einführung

Interface für benutzerdefiniertes Serialisieren.

Klassen, die dieses Interface implementieren, unterstützen __sleep und __wakeup nicht mehr. Die Methode serialize wird immer aufgerufen, wenn eine Instanz serialisiert werden muss. Dabei wird weder __destruct() aufgerufen noch irgend ein anderer Seiteneffekt erzeugt, es sei denn, ein solcher wird in der Methode serialize explizit erzeugt. Wenn die Daten deserialisiert werden, ist die Klasse bekannt und die passende unserialize()-Methode wird anstelle des Konstruktors __construct() aufgerufen. Falls notwendig, kann der Standardkonstruktor innerhalb von unserialize() aufgerufen werden.

Interface-Übersicht

Serializable

class Serializable {

/* Methoden */

abstract public string serialize ( void )

abstract public void unserialize ( string $serialized )

}

Beispiel #1 Basisnutzung


<?php
class obj implements Serializable {
    private $data;
    public function __construct() {
        $this->data = "Meine private-Daten";
    }
    public function serialize() {
        return serialize($this->data);
    }
    public function unserialize($data) {
        $this->data = unserialize($data);
    }
    public function getData() {
        return $this->data;
    }
}

$obj = new obj;
$ser = serialize($obj);

var_dump($ser);

$newobj = unserialize($ser);

var_dump($newobj->getData());
?>

Das oben gezeigte Beispiel erzeugt eine ähnliche Ausgabe wie:

string(42) "C:3:"obj":27:{s:19:"Meine private-Daten";}"
string(15) "Meine private-Daten"

The Closure class

Einführung

Class used to represent anonymous functions.

Anonymous functions, implemented in PHP 5.3, yield objects of this type. This fact used to be considered an implementation detail, but it can now be relied upon. Starting with PHP 5.4, this class has methods that allow further control of the anonymous function after it has been created.

Besides the methods listed here, this class also has an __invoke method. This is for consistency with other classes that implement calling magic, as this method is not used for calling the function.

Klassenbeschreibung

Closure

class Closure {

/* Methoden */

private __construct ( void )

public static Closure bind ( Closure $closure , object $newthis [, mixed $newscope = "static" ] )

public Closure bindTo ( object $newthis [, mixed $newscope = "static" ] )

public mixed call ( object $newthis [, mixed $... ] )

public static Closure fromCallable ( callable $callable )

}

Die Generator Klasse

Einführung

Generator Objekte werden von Generatoren zurückgeliefert.

Achtung

Generator Objekte können nicht durch new instanziiert werden.

Klassenbeschreibung

Generator

class Generator implements Iterator {

/* Methoden */

public mixed current ( void )

public mixed getReturn ( void )

public mixed key ( void )

public void next ( void )

public void rewind ( void )

public mixed send ( mixed $value )

public mixed throw ( Throwable $exception )

public bool valid ( void )

public void __wakeup ( void )

}