imported>Tubsyq: /* growthexperiments-addlink-summary-summary:1|0|0 */

2025-07-01T05:20:35Z

growthexperiments-addlink-summary-summary:1|0|0

Neue Seite

Der Begriff '''Iterator''' stammt aus dem Bereich der [[Softwareentwicklung]] und bezeichnet einen [[Zeiger (Informatik)|Zeiger]], mit dem die Elemente einer Menge durchlaufen werden können (z. B. eine Liste). Der Begriff leitet sich aus der mathematischen Methode der [[Iteration]] ab. Der Iterator wird insbesondere im Bereich der [[Relationale Datenbank|Datenbanken]] meist '''Cursor''' genannt.

== Beschreibung ==
Ein Iterator ist ein spezieller Zeiger, der innerhalb eines Programms vom Software-Entwickler dazu verwendet werden kann, auf Elemente einer Menge, vereinfacht eine Liste, zuzugreifen. Iteratoren arbeiten nach dem Grundprinzip „Wenn es ein weiteres Element in der Liste gibt, dann stelle es zur Verfügung.“

Dies ist vereinfacht damit vergleichbar, wie man einen Text, der eine Liste von Worten ist, liest: „Wenn es ein nächstes Wort gibt, dann lies es. Wenn kein weiteres Wort mehr folgt, ist der Text beendet.“ In jedem als Iteration bezeichneten Zugriffsschritt steht somit exakt ein Wort des Textes zur Bearbeitung zur Verfügung.

Viele der in der Programmierpraxis verwendeten Iteratoren stellen über die lesende Zugriffsmöglichkeit hinaus Mechanismen zur Verfügung, die ein aktuell gelesenes Element aus der Liste entfernen oder ein neues Element in die Liste aufnehmen, so wie bei der Bearbeitung eines Textes Worte eingefügt oder gelöscht werden können.

=== Externe Iteratoren und das Iterator-Entwurfsmuster ===
{{Hauptartikel|Iterator (Entwurfsmuster)}}

Ein externer Iterator kann als eine Art Zeiger betrachtet werden, der zwei primäre Funktionen besitzt: ein bestimmtes Element in einer Menge von Objekten referenzieren ({{lang|en|''element access''}} genannt) sowie durch Selbstmodifizierung auf das nächste Element in der Menge zeigen ({{lang|en|''element traversal''}} genannt). Abhängig von der verwendeten Programmiersprache und der Anwendung können Iteratoren zusätzliche Funktionalität sowie verschiedenes Verhalten aufweisen.

Der Hauptzweck des Iterators besteht darin, dem Benutzer zu erlauben, auf jedes Element in einer Menge zuzugreifen, während es ihn von der [[Datenstruktur]] der Menge isoliert. Dies befähigt die Menge, die Elemente auf jede mögliche Art und Weise zu verwalten, während sie sich dem Benutzer gegenüber so verhält, als wäre sie eine simple Sequenz oder eine Liste. Eine Iteratorklasse wird in enger Koordination mit ihrer Containerklasse, also ihrer Menge, entworfen. Üblicherweise stellt die Containerklasse die Funktionen zur Verfügung, die zur Erstellung von Iteratoren benutzt werden. Ein Zähler in einer Schleife (auch Loop Counter genannt) wird manchmal auch als Schleifeniterator bezeichnet. Dabei ist zu beachten, dass ein solcher Zähler nur die ''element-traversal''-Funktionalität abbildet und nicht die ''element-access''-Funktionalität.

=== Implizite Iteratoren ===
Mehrere objektorientierte Sprachen wie [[Perl (Programmiersprache)|Perl]], [[Python (Programmiersprache)|Python]], [[C (Programmiersprache)|C#]], [[Ruby (Programmiersprache)|Ruby]] sowie neuere [[Java (Programmiersprache)|Java]]- und [[Object Pascal|Delphi]]-Versionen stellen eine [[intrinsisch]]e Art zur Verfügung, durch Elemente zu iterieren, ohne dabei ein explizites Iteratorobjekt zu benutzen. Dieses kann allerdings auch vorhanden sein, ist aber nicht im Code der jeweiligen Programmiersprache verfügbar, wenn dies der Fall sein sollte.

Implizite Iteratoren manifestieren sich oft durch den for_each-Befehl oder seine Äquivalente, wie unten stehendes Python-Beispiel zeigt:
<syntaxhighlight lang="python">
for value in iterable:
print(value)
</syntaxhighlight>
Die Menge/Liste <code>iterable</code> wird mittels der <code>for</code>-Schleife durchlaufen; in jedem Schleifendurchlauf enthält die Variable <code>value</code> jeweils das aktuelle Element aus <code>iterable</code>.

Manchmal werden Iteratoren auch direkt vom Objekt der Datensammlung generiert, wie unten stehendes Ruby-Beispiel zeigt:

<syntaxhighlight lang="ruby">
iterable.each do |value|
puts value
end
</syntaxhighlight>
Der Aufruf der Methode <code>each</code> der Menge/Liste <code>iterable</code> liefert einen Iterator, den die <code>do</code>-Schleife Element für Element abschreitet. Für jedes Element wird der Schleifenkörper <code>puts value</code> ausgeführt, wobei die Variable <code>value</code> das jeweils aktuelle Element enthält.

Dieser Iterationsstil wird auch ''internal iteration'' genannt, da sein Code vollständig im Kontext des zu iterierenden Objektes ausgeführt wird. Dieses kontrolliert somit sämtliche Aspekte der Iteration, der jeweilige Benutzer respektive Programmierer stellt nur die Operation für die einzelnen Iterationsschritte zur Verfügung, indem er eine [[anonyme Subroutine]] benutzt.

Sprachen, welche sogenannte ''[[List Comprehension|Listenkomprehensionen]]'' oder ähnliche Konstrukte unterstützen, bedienen sich analog zu Python ebenfalls der impliziten Iteratoren während der Erstellung der Resultatsliste:
<syntaxhighlight lang="python">
names = [person.name for person in roster if person.male]
</syntaxhighlight>
<code>for ... in ...</code> ist hier die „Schleife“ über der Menge/Liste <code>roster</code> mit „aktuelles-Element-Variable“ <code>person</code>. Für jedes Element wird geprüft, ob (für das Element) eine Bedingung zutrifft (<code>if person.male</code>), die Menge wird also gefiltert. Von den verbleibenden Elementen wird jeweils <code>person.name</code> in die Ergebnisliste <code>names</code> übernommen – eine Liste der Namen.

Manchmal ist die implizite, versteckte Natur nur teilweise vorhanden. Die Programmiersprache [[C++]] stellt die for_each-Funktionalität über Funktions[[Template (C++)|templates]] zur Verfügung, und diese erlaubt die implizite Iteration.

=== Der Gegensatz zum Indizieren ===
Der Iterator steht dabei im Gegensatz zu einem Index oder [[Nummerung|Schlüssel]]:
* Über einen Iterator kann man direkt auf das zugehörige Element zugreifen, ohne die Datenstruktur selber zu kennen. Bei einem Index benötigt man immer Index ''und'' Datenstruktur.
* Ein Iterator ist nur für genau eine Datenstruktur gültig. Ein Index kann auf andere Datenstrukturen übertragen werden.
* Iteratoren lassen sich nicht [[Serialisierung|serialisieren]]. Sie müssen dazu erst in einen Index umgewandelt werden.

Die Fähigkeit eines Containers zur Selbstmodifizierung, während durch seine Elemente iteriert wird, hat sich in modernen, objektorientierten Programmiersprachen als wichtig erwiesen. Die Beziehungen zwischen den einzelnen Objekten und zwischen den Effekten ihrer Operationen sind in solchen Sprachen nicht mehr eindeutig. Um dieses Problem zu lösen, werden Iteratoren eingesetzt.

=== Generatoren ===
Ein Generator ist eine spezielle Form einer [[Koroutine]], die bei jedem Aufruf ein (oder mehrere) Element(e) einer Folge liefert. Diese Folge kann eine gegebene Liste sein, dann entspricht der Generator weitgehend einem Iterator. Ein Generator kann die (nächsten) Elemente aber auch erst beim jeweiligen Aufruf erzeugen – dann benötigt er ''keine'' bestehende Liste, wie sie beim Iterator notwendig ist.

Die meisten Iteratoren lassen sich in natürlicher, intuitiver Art und Weise durch Generatoren implementieren. Da Generatoren ihren lokalen Status zwischen Funktionsaufrufen beibehalten, eignen sie sich hervorragend zur Implementierung von komplexen zustandsorientierten Iteratoren wie beispielsweise [[Binärbaum#Traversierung|Binärbaumtraversierern]].

Beispiel für einen Generator, der Elemente ''erzeugt,'' statt sie aus einer Liste zu lesen:

([[Fibonacci-Folge]]; „Rückgabe“ des jeweiligen Werts mit Hilfe des Python-Befehls <code>yield</code>)
<syntaxhighlight lang="python">
# Ein Generator für die Fibonacci-Folge
def fibonacci(limit_anzahl_elemente):
a, b = 0, 1

for _ in range(limit_anzahl_elemente):
a, b = b, a + b
yield a

# Die ersten Zahlen der Folge werden berechnet und ausgegeben
for number in fibonacci(100):
print(number)
</syntaxhighlight>

== Iteratoren in verschiedenen Programmiersprachen ==
=== C# und andere .NET-Sprachen ===
Iteratoren im .NET-Framework werden als Enumeratoren bezeichnet und von der Schnittstelle <code>IEnumerator</code> repräsentiert. <code>IEnumerator</code> stellt eine Funktion namens <code>MoveNext()</code> zur Verfügung, die jeweils zum nächsten Element der Menge geht und anzeigt, wenn das Ende erreicht ist, sowie eine Eigenschaft namens <code>Current</code>, um den Wert des aktuellen Elementes zu erhalten. Des Weiteren wird eine optionale <code>Reset()</code>-Funktion angeboten, damit an den Anfang zurückgekehrt werden kann. Der Enumerator gibt als Initialisierungswert einen speziellen Wert zurück, der den Anfang markiert. Aus diesem Grund ist es nötig, nach der Initialisierung <code>MoveNext()</code> auszuführen.

Enumeratoren werden typischerweise von einer <code>GetEnumerator()</code> -Funktion zurückgegeben, welche einem Objekt zugehörig ist, das die <code>IEnumerable</code>-Schnittstelle implementiert. Der for_each-Befehl in C# operiert allerdings auf jeder solchen Funktion, selbst wenn diese nicht von einem Objekt stammt, welches die <code>IEnumerable</code>-Schnittstelle implementiert. Das folgende Beispiel zeigt eine simple Verwendung von Iteratoren in C# 2.0:
<syntaxhighlight lang="csharp">
// explizite Version
IEnumerator<MyType> iter = list.GetEnumerator();
while (iter.MoveNext())
Console.WriteLine(iter.Current);

// implizite Version
foreach (MyType item in list)
Console.WriteLine(item);
</syntaxhighlight>

C# 2.0 unterstützt ebenfalls Generatoren: Eine Funktion, welche als <code>IEnumerable</code> (oder auch <code>IEnumerator</code>) zurückkehrt, aber den Befehl <code>yield return</code> dabei benutzt, wird vom [[Compiler]] automatisch in eine neue Klasse umgewandelt, welche die angemessene Schnittstelle implementiert.

=== C++ ===
Die Programmiersprache C++ setzt Iteratoren im großen Stil ein und stellt über die [[C++-Standardbibliothek]] Iteratoren verschiedener Typen wie sogenannte ''forward iterators'', ''bidirectional iterators'' und ''random access iterators'' zur Verfügung. Jede der Standard-Containerklassen besitzt Iteratortypen. Die Syntax der Standarditeratoren wurde an die [[Zeiger (Informatik)|Zeigerarithmetik]] von C angelehnt. Die Operatoren <code>*</code> und <code>-></code> werden zur Referenzierung der Elemente benutzt. Weitere Operatoren wie <code>++</code> werden zum Navigieren durch die Elemente benutzt.

Iteratoren werden üblicherweise paarweise eingesetzt. Der eine Iterator stellt die aktuelle Iteration dar, während der andere das Ende der Iteration darstellt. Die Iteratoren werden von der entsprechenden Containerklasse durch die Benutzung der Standardfunktionen <code>begin()</code> und <code>end()</code> generiert. Der Iterator, der durch <code>begin()</code> zurückgegeben wird, zeigt auf das erste Element, während der Iterator, der von <code>end()</code> zurückgeliefert wird, auf einen speziellen Wert zeigt, welcher kein Element referenziert. Wenn ein Iterator hinter das letzte Element gesetzt wird, gibt dieser den speziellen Wert von <code>end()</code> zurück. Das folgende Beispiel zeigt die typische Definition und Verwendung eines Iterators in C++11:<ref>{{Literatur|Autor=Bjarne Stroustrup| Titel=Programming: Principles and Practice using C++| Auflage=2| Verlag=Addison-Wesley| Jahr=2014| ISBN=978-0-321-99278-9|Seiten=729 ff.}}</ref>
<syntaxhighlight lang="cpp">
#include <iostream>
#include <stdexcept>
#include <initializer_list>

class Vector {
public:
using iterator = double*;
iterator begin() { return elem; }
iterator end() { return elem + sz; }

Vector(std::initializer_list<double> lst) :elem(nullptr), sz(0) {
sz = lst.size();
elem = new double[sz];
double* p = elem;
for (auto i = lst.begin(); i != lst.end(); ++i, ++p) {
*p = *i;
}
}
~Vector() { delete[] elem; }
int size() const { return sz; }
double& operator[](int n) {
if (n < 0 || n >= sz) throw std::out_of_range("Vector::operator[]");
return elem[n];
}
Vector(const Vector&) = delete; // Dreierregel
Vector& operator=(const Vector&) = delete;
private:
double* elem;
int sz;
};

int main() {
Vector v = {1.1*1.1, 2.2*2.2};

for (const auto& x : v) {
std::cout << x << '\n';
}
for (auto i = v.begin(); i != v.end(); ++i) {
std::cout << *i << '\n';
}
for (auto i = 0; i <= v.size(); ++i) {
std::cout << v[i] << '\n';
}
}
</syntaxhighlight>

Die Programmausgabe ist:

<syntaxhighlight lang="cpp">
1.21
4.84
1.21
4.84
1.21
4.84
terminate called after throwing an instance of 'std::out_of_range'
what(): Vector::operator[]
</syntaxhighlight>

Es existieren viele verschiedene Iteratortypen mit leicht voneinander abweichendem Verhalten. Nicht jeder Iteratortyp unterstützt jeden Containertyp. Es ist allerdings für Programmierer möglich, eigene Iteratortypen zu definieren, indem sie eine Klasse vom Template <code>std::iterator</code> ableiten. Die Iteratorsicherheit ist für die verschiedenen Typen separat definiert. Die implizite Iteration ist in C++ teilweise vorhanden und wird von den Funktionen <code>std::for_each()</code>,<ref>[http://www.sgi.com/tech/stl/for_each.html <code>std::for_each()</code>]</ref> <code>std::copy()</code><ref>[http://www.sgi.com/tech/stl/copy.html <code>std::copy()</code>]</ref> und <code>std::accumulate()</code><ref>[http://www.sgi.com/tech/stl/accumulate.html <code>std::accumulate()</code>]</ref> zur Verfügung gestellt.
Iteratoren benötigen allerdings immer ein explizites Objekt zu ihrer Initialisierung, üblicherweise diejenigen, welche von <code>begin()</code> und <code>end()</code> zurückgegeben werden. Sobald diese ausgeführt wurde, geschieht die Iteration auf implizite Weise ohne weitere Benutzung des Iteratorobjekts. Das unten stehende Beispiel zeigt die Verwendung von for_each:
<syntaxhighlight lang="cpp">
// Ein beliebiger Standard-Containertyp jedes ItemType Elements
ContainerType<ItemType> c;

// Funktion, die Zugriff auf jedes Element besitzt
void processItem(const ItemType& i) {
std::cout << i << '\n';
}

// Eine for-each-Iterationsschleife
std::for_each(c.begin(), c.end(), processItem);
</syntaxhighlight>

Dasselbe kann durch den Einsatz von <code>std::copy</code> und <code>std::ostream_iterator</code><ref>[http://www.sgi.com/tech/stl/ostream_iterator.html <code>std::ostream_iterator</code>]</ref> erreicht werden:
<syntaxhighlight lang="Cpp">
std::copy(C.begin(), C.end(), std::ostream_iterator<ItemType>(std::cout, "\n"));
</syntaxhighlight>

Eine Einschränkung dieser Technik ist, dass es dem Rumpf nicht erlaubt, inline deklariert zu sein. Zudem benötigt dies einen Funktionszeiger, welcher an anderer Stelle deklariert und als Parameter übergeben werden muss. Dies kann teilweise durch die Benutzung von Bibliotheken wie [[Boost (C++-Bibliothek)|Boost]] und der Anwendung von Lambda kompensiert werden, die zum Generieren von Funktionsobjekten mit verwandter Infix-Syntax gebraucht werden. Da diese Funktionalität nur über externe Bibliotheken zur Verfügung gestellt wird, müssen diverse Problemumgehungen, auch ''Workarounds'' genannt, eingesetzt werden.

=== Java ===
Die Schnittstelle java.util.Iterator,<ref>[http://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html <code>java.util.Iterator</code>] Java API Specification</ref> die im [[Java-Technologie|Java]] JDK 1.2 eingeführt wurde, erlaubt das Iterieren von Containerklassen. Jeder <code>Iterator</code> stellt Funktionen namens <code>next()</code>,<ref>[http://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html#next() <code>next()</code>] Java API Specification</ref> <code>hasNext()</code><ref>[http://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html#hasNext() <code>hasNext()</code>] Java API Specification</ref> sowie eine optionale Funktion namens <code>remove()</code><ref>[http://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html#remove() <code>remove()</code>] Java API Specification</ref> zur Verfügung. Iteratoren werden üblicherweise von einer Funktion namens <code>iterator()</code> generiert, welche von der dementsprechenden Containerklasse zur Verfügung gestellt wird.
Ein Iterator gibt als Initialisierungwert einen speziellen Wert zurück, der den Anfang markiert. Aus diesem Grund ist es nötig, nach der Initialisierung <code>next()</code> auszuführen, womit das erste Element zurückgegeben wird. Die Funktion <code>hasNext()</code> wird dazu benutzt, herauszufinden, ob das letzte Element bereits zurückgegeben wurde. Das folgende Beispiel zeigt eine simple Verwendung von Iteratoren in Java:
<syntaxhighlight lang="java">
Iterator iter = list.iterator();

while (iter.hasNext())
System.out.println(iter.next());
</syntaxhighlight>

Für Kollektionen, die es unterstützen, entfernt die optionale Funktion <code>remove()</code> das letzte Element, auf das zugegriffen wurde. Die meisten anderen Modifikationen dieser Art sind unsicher. Zusätzlich besitzt java.util.<code>List</code><ref>[http://docs.oracle.com/javase/7/docs/api/java/util/List.html <code>java.util.List</code>] Java API Specification</ref> einen Iterator namens <code>ListIterator</code>,<ref>[http://docs.oracle.com/javase/7/docs/api/java/util/ListIterator.html <code>java.util.ListIterator</code>] Java API Specification</ref> welcher eine ähnliche Schnittstelle zur Verfügung stellt, die Vorwärts- und Rückwärtsiteration erlaubt sowie den Index des aktuellen Elementes zurückgibt und das Element an einer gegebenen Position einfügen kann.

Mit der [[Java Platform, Standard Edition|J2SE]] 5.0 wurde die Schnittstelle <code>Iterable</code><ref>[http://docs.oracle.com/javase/7/docs/api/java/lang/Iterable.html <code>Iterable</code>] Java API Specification</ref> eingeführt, welche eine erweiterte [[for-Schleife]] im Sinne von for_each darstellt. <code>Iterable</code> definiert die Funktion <code>iterator()</code>,<ref>[http://docs.oracle.com/javase/7/docs/api/java/lang/Iterable.html#iterator() <code>iterator()</code>] Java API Specification</ref> welche einen <code>Iterator</code> zurückliefert. Mit der Benutzung der erweiterten for-Schleife kann das vorhergehende Beispiel auf folgende Art und Weise geschrieben werden:
<syntaxhighlight lang="java">
for (MyType obj: list)
System.out.print(obj);
</syntaxhighlight>

=== MATLAB ===
[[Matlab|MATLAB]] unterstützt externe sowie interne Iteratoren. Im Falle einer externen Iteration, bei welcher der Benutzer dazu verpflichtet, ist das nächste Element bereitzustellen, können mehrere Elemente definiert und mit einer for-Schleife anschließend durchlaufen werden, wie folgendes Beispiel zeigt:
<syntaxhighlight lang="matlab">
% Definition eines an integer arrays
myArray = [1, 3, 5, 7, 11, 13];

for n = myArray
% ... etwas mit n machen...
disp(n) %Integerausgabe zur Kommandozeile
end
</syntaxhighlight>

Im Falle einer internen Iteration kann der Benutzer eine Operation dem Iterator übergeben und so auf jedes Element in einem Array zuzugreifen. Viele native Operatoren und MATLAB-Funktionen werden überladen, damit ein korrespondierendes Ausgabearray als impliziter Rückgabewert erhalten wird. Des Weiteren können die Funktionen ''<code>arrayfun</code>'' und ''<code>cellfun</code>'' für benutzerdefinierte Operationen über native und sogenannte ''cell-Arrays'' gebraucht werden.
<syntaxhighlight lang="matlab">
function simpleFun
% Definition eines an integer arrays
myArray = [1, 3, 5, 7, 11, 13];

% Benutzerdefinierte Operation für jedes Element durchführen
myNewArray = arrayfun(@(a)myCustomFun(a), myArray);

% Arrayausgabe zur Kommandozeile
myNewArray

function outScalar = myCustomFun(inScalar)
% Mit 2 multiplizieren
outScalar = 2 * inScalar;
</syntaxhighlight>

Alternativ kann es wünschenswert sein, die Speichermechanismen des Arrays vom Programmieren zu abstrahieren, indem eine benutzerdefinierte, objektorientierte Implementierung des Iteratorentwurfsmusters zur Verfügung gestellt wird. Eine solche Implementierung, welche die externe Iteration unterstützt, wird im MATLAB Central File Exchange Item<ref>[http://www.mathworks.com.au/matlabcentral/fileexchange/25225 Entwurfsmuster: Iterator (Verhalten)]</ref> angeboten. Dieses Entwurfsmuster ist nach der neuen Klassendefinitionssyntax geschrieben, welche mit der MATLAB Version 7.6 (R2008a) eingeführt wurde. Des Weiteren ist eine eindimensionale ''cell''-Array-Realisierung des [[List Abstract Data Type]] enthalten, damit eine heterogene Speicherung jedes Datentyps erfolgt. Es stellt die Funktionalität zur Verfügung, mit der eine Liste mit ''<code>hasNext()</code>'', ''<code>next()</code>'' und ''<code>reset()</code>'' in einer ''while''-Schleife verarbeitet werden kann.

=== PHP ===
Mit PHP4 wurde ein <code>foreach</code>-Konstrukt eingeführt, das ähnlich wie in Perl und vielen anderen Programmiersprachen aufgebaut war. Dieses Konstrukt erlaubt eine einfache Art über Arrays zu iterieren. Der <code>foreach</code>-Befehl funktioniert nur mit Arrays in PHP4 und wird einen Fehler melden, wenn versucht wird, ihn über einen anderen [[Datentyp]] oder mit einer uninitialisierten Variable zu benutzen. In PHP5 ist der <code>foreach</code>-Befehl zur Iteration über alle public members erlaubt.
Das folgende Beispiel zeigt zwei unterschiedliche Schreibweisen, die zweite ist eine nützliche Erweiterung zur ersten Schreibweise:

;Beispiel A
<syntaxhighlight lang="php">
foreach (array_expression as $value)
echo "$value\n"
</syntaxhighlight>

;Beispiel B
<syntaxhighlight lang="php">
foreach (array_expression as $key => $value)
echo "($key)$value\n";
</syntaxhighlight>

Im Beispiel A wird über ein Array, welches von array_expression dargestellt wird, iteriert. Bei jedem Schleifendurchlauf wird der Wert des Arrayelements an <code>$value</code> zugewiesen sowie der interne Zeiger des Arrays um eins nach vorne geschoben. Somit wird beim nächsten Schleifendurchlauf das nächste Arrayelement zurückgegeben.
Das Beispiel B besitzt dieselbe Funktionalität wie das Beispiel A. Zusätzlich wird der Index des Elementes bei jedem Schleifendurchlauf der Variable <code>$key</code> zugewiesen.

In PHP5 ist die Iteratorschnittstelle vordefiniert, Objekte können zur Handhabung der Iteration verändert werden.
<syntaxhighlight lang="php">
class MyIterator implements Iterator {
private $var = array();

public function __construct($array) {
if (is_array($array)) {
$this->var = $array;
}
}

public function rewind() {
echo "rewinding\n";
reset($this->var);
}

public function current() {
$var = current($this->var);
echo "current: $var\n";
return $var;
}

public function key() {
$var = key($this->var);
echo "key: $var\n";
return $var;
}

public function next() {
$var = next($this->var);
echo "next: $var\n";
return $var;
}

public function valid() {
$var = $this->current() !== false;
echo "valid: {$var}\n";
return $var;
}
}
</syntaxhighlight>

Diese Funktionen werden alle in einer kompletten <code>foreach($obj as $key=>$value)</code>-Sequenz genutzt.
Die Iteratormethoden werden in der folgenden Reihenfolge ausgeführt:
<syntaxhighlight lang="PHP">
1. rewind()
2. while valid()
{
2.1 current() in $value
2.3 key() in $key
2.4 next()
}
</syntaxhighlight>

=== Python ===
Iteratoren in Python stellen einen fundamentalen Teil der Sprache dar, allerdings werden sie vielfach implizit und somit unsichtbar in Sprachbefehlen versteckt genutzt. Solche Befehle sind z. B. <code>for</code>(foreach) in sogenannten list comprehensions und in Generatorausdrücken zu finden. Alle sequentiellen Basistypen sowie viele Klassen der Standardbibliothek in Python unterstützen Iterationen. Das folgende Beispiel zeigt eine typische Iteration über einer Sequenz:
<syntaxhighlight lang="python">
for value in sequence:
print(value)
</syntaxhighlight>

''Python Dictionaries'', eine Form von [[Assoziatives Array|assoziativem Array]] erlaubt es, direkt über sich zu iterieren, wenn die sogenannten ''dictionary keys'' zurückgegeben werden. Es kann aber auch über die ''items''-Funktion eines dictionary iteriert werden, wo es die Werte dem nachfolgenden Beispiel entsprechend zu key und value zurückgibt:
<syntaxhighlight lang="Python">
for key in dictionary:
value = dictionary[key]
print(key, value)
</syntaxhighlight>

<syntaxhighlight lang="Python">
for key, value in dictionary.items():
print(key, value)
</syntaxhighlight>

Iteratoren in Python können aber auch explizit definiert und benutzt werden. Für jeden iterierbaren Sequenztypen oder jede iterierbare Klasse steht die eingebaute <code>iter()</code>-Funktion zum Iterieren eines Iteratorobjekts zur Verfügung. Mit dem Iteratorobjekt kann über die Funktionen <code>next()</code> oder <code>__next__()</code> zum nächsten Element navigiert werden. Ist das Ende der Menge erreicht, wird ein <code>StopIteration</code>-Fehler aufgeworfen. Das nachfolgende Beispiel zeigt eine äquivalente Implementation von expliziten Iteratoren:
<syntaxhighlight lang="python">
it = iter(sequence)

while True:
try:
value = it.next()
except StopIteration:
break

print(value)
</syntaxhighlight>

Jede benutzerdefinierte Klasse kann die Standarditeration unterstützen, wenn eine <code>_iter__()</code>-Funktion definiert wurde, welche ein Iteratorobjekt generiert. Der Iterator muss dann eine <code> __next__()</code> Funktion definieren, die das nächste Element zurückgibt. Die Python-Generatoren implementieren dieses Iterationsprotokoll.

=== Ruby ===
Die Implementation der Iteratoren in Ruby unterscheidet sich von den meisten anderen Programmiersprachen: Alle Iterationen gehen dem Gedanken nach, sogenannte callback closures an Containermethoden durchzureichen. Auf diese Art und Weise implementiert Ruby nicht nur eine Basisfunktionalität an Iteratoren, sondern bildet viele Iteratorentwurfsmuster ab, wie z. B. sogenanntes ''function mapping'', Filter und sogenanntes ''reducing''.

Ruby unterstützt des Weiteren noch eine alternative Syntax für jede Basisfunktion zur Iteration:
<syntaxhighlight lang="ruby">
(0...42).each do |n|
puts n
end
</syntaxhighlight>
… und …
<syntaxhighlight lang="ruby">
for n in 0...42
puts n
end
</syntaxhighlight>

oder noch kürzer

<syntaxhighlight lang="ruby">
42.times do |n|
puts n
end
</syntaxhighlight>

=== Rust ===
In Rust werden Iteratoren ebenfalls häufig implizit genutzt, jedoch ist auch das funktionale Programmieren mit expliziten Iteratoren möglich. Iteratoren werden in Rust [[Lazy Evaluation|bedarfsweise]] ausgewertet, d.h., alle Funktionen auf Iteratoren werden erst dann auf die eigentlichen Elemente angewendet, wenn sie ausgelesen werden.

Die for-Schleife ist ein Beispiel für die implizite Nutzung eines Iterators:

<syntaxhighlight lang="rust">
let numbers = vec![24, 30, 13, 19, 12, 17];

for number in numbers {
println("Zahl: {}", number);
}
</syntaxhighlight>

Mithilfe von expliziten Iteratoren und anonymen Funktionen ist Rust mit einem funktionalen Paradigma nutzbar. Das folgende Beispiel zeigt, wie eine Funktion aussehen könnte, die die Summe der Quadrate aller ungeraden Zahlen von 1 bis zu einer bestimmten Zahl n berechnet:

<syntaxhighlight lang="rust">
fn sum_of_odd_squares_up_to(n: u32) -> u32 {
(1..=n) // Eine Range ist in Rust ein Iterator.
.filter(n%2 == 1) // Alle geraden Zahlen werden verworfen.
.map(|n| n.pow(2)) // Ersetze jede Zahl durch ihr Quadrat
.sum() // Berechne die Summe
}
</syntaxhighlight>

== Siehe auch ==
* [[Iterator (Entwurfsmuster)|Iterator Entwurfsmuster]]

== Weblinks ==
* Joshua Gatcomb: [http://www.perl.com/pub/a/2005/06/16/iterators.html ''Understanding and Using Iterators''.] (englisch)
* [http://www.csd.uwo.ca/~watt/pub/reprints/2006-wgp-jflow.pdf ''A Technique for Generic Iteration and Its Optimization''.] (PDF; englisch; 216 kB)
* [http://www.cprogramming.com/tutorial/stl/iterators.html ''STL Iterators''.] (englisch)
* [http://www.phpro.org/tutorials/Introduction-to-SPL.html#2 ''What are iterators?''] – [http://www.php.net/~helly/php/ext/spl/interfaceIterator.html#_details Referenzbeschreibung.] (englisch)
* [http://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html Interface <code>Iterator</code> Java API]
* [http://msdn.microsoft.com/en-us/library/78dfe2yb.aspx .NET Interface] im [[Microsoft Developer Network|MSDN]]
* [http://www.boost.org/doc/libs/1_43_0/libs/iterator/doc/index.html Boost C++ Iterator Library] (englisch)
* [http://us3.php.net/manual/en/language.oop5.iterations.php PHP: Object Iteration] (englisch)

== Einzelnachweise ==
<references />

[[Kategorie:Datentyp]]
[[Kategorie:Programmiersprachelement]]

Iterator - Versionsgeschichte

imported>Tubsyq: /* growthexperiments-addlink-summary-summary:1|0|0 */