Lua Iterators

Der Iterator (iterator) ist ein Objekt, das verwendet werden kann, um durch einige oder alle Elemente der Standard-Templatibibliothek-Container zu navigieren, jedes Iteratorobjekt repräsentiert eine bestimmte Adresse im Container.

In Lua ist der Iterator eine Struktur, die Zeiger unterstützt und jedes Element der Sammlung durchsuchen kann.

Der generische for-Iterator

Der generische for-Iterator speichert intern die Iterationsfunktion,实际上 es speichert drei Werte: die Iterationsfunktion, den Zustandskonstanten und den Kontrollvariable.

Der generische for-Iterator bietet den Schlüssel der Sammlung/Wert korrekt, die Syntax ist wie folgt:

for k, v in pairs(t) do
　　　　print(k, v)
end

In dem obigen Code sind k, v Variablenlisten; pairs(t) ist eine Ausdrucksliste.

Betrachten Sie das folgende Beispiel:

array = {"Google", "w3codebox}
for key, value in ipairs(array)　
do
　　　print(key, value)
end

Das obige Code führt die folgenden Ausgabe aus:

1　　Google
2　　w3codebox

Im obigen Beispiel haben wir den Standard-Iteratoren ipairs von Lua verwendet.

Sehen wir uns den Ablauf des generischen for an:

• Zunächst, Initialisierung, berechnen Sie den Wert nach dem 'in', der drei Werte der generischen for benötigt: Iterationsfunktion, konstanter Zustand, Steuervariable; wie bei der mehrwerten Zuweisung wird automatisch mit nil ergänzt, wenn die Anzahl der zurückgegebenen Ergebnisse weniger als drei ist, und die überschüssigen Teile werden ignoriert.

• Zweitens, rufen Sie die Iterationsfunktion mit dem konstanten Zustand und der Steuervariable als Parameter auf (Beachten Sie: Der konstante Zustand ist für die for-Struktur nutzlos, er wird nur zur Initialisierung seines Wertes und zur Übermittlung an die Iterationsfunktion verwendet).

• Drittens, weisen Sie den Werten, die die Iterationsfunktion zurückgibt, die Variablenliste zu.

• Viertens, wenn der erste zurückgegebene Wert nil ist, endet die Schleife, andernfalls wird der Schleifenkörper ausgeführt.

• Fünftens, rufen Sie den Iterationsfunktion erneut im zweiten Schritt auf

In Lua verwenden wir oft Funktionen, um Iteratoren zu beschreiben, und bei jedem Aufruf dieser Funktion wird der nächste Element der Sammlung zurückgegeben. Lua-Iteratoren umfassen zwei Arten:

• Stateless Iterator

• Iterators with multiple states

Stateless Iterator

Ein stateloser Iterator ist ein Iterator, der keine Zustände speichert, daher können wir in der Schleife statelose Iteratoren verwenden, um den zusätzlichen Aufwand für die Erstellung von Closures zu vermeiden.

Bei jeder Iteration wird die Iterationsfunktion mit den Werten beider Variablen (konstanter Zustand und Steuervariable) als Parameter aufgerufen, ein stateloser Iterator kann mit diesen beiden Werten den nächsten Element erhalten.

Ein typischer einfacher Beispiel für einen statelosen Iterator ist ipairs, der jedes Element des Arrays durchläuft.

Im folgenden Beispiel verwenden wir eine einfache Funktion, um den Iterator zu implementieren, um die Quadratwurzel von der Zahl n zu berechnen:

function square(iteratorMaxCount, currentNumber)
　　　if currentNumber < iteratorMaxCount
　　　then
　　　　　　currentNumber = currentNumber+1
　　　return currentNumber, currentNumber*currentNumber
　　　end
end
for i, n in square,3,0
do
　　　print(i, n)
end

The output result of the above example is:

1　　　　1
2　　　　4
3　　　　9

Der Zustand der Iteration umfasst das zu durchlaufende Array (ein konstanter Zustand, der während des Durchlaufs nicht geändert wird) und den aktuellen Index (der Steuervariable), die Funktion ipairs und die Iterationsfunktion sind sehr einfach, und wir können dies in Lua so umsetzen:

function iter(a, i)
　　　　i = i　+　1
　　　　local v = a[i]
　　　　if v then
　　　　　　　return i, v
　　　　end
end
　
function ipairs(a)
　　　　return iter, a, 0
end

When Lua calls ipairs(a) to start the loop, it gets three values: the iteration function iter, the state constant a, and the control variable initial value 0; then Lua calls iter(a,0) to return 1, a[1] (unless a[1=nil); The second iteration calls iter(a,1) returns 2, a[2……until the first nil element.

Iterators with multiple states

In many cases, iterators need to save multiple state information rather than simple state constants and control variables. The simplest method is to use closures, and another method is to encapsulate all state information into a table, which is used as the state constant of the iterator. Because all information can be stored in the table in this case, the iteration function usually does not need a second parameter.

In the following example, we create our own iterator:

array = {"Google", "w3codebox}
function elementIterator(collection)
　　　local index = 0
　　　local count = #collection
　　　--　Closure Function
　　　return function ()
　　　　　　index = index　+　1
　　　　　　if index <= count
　　　　　　then
　　　　　　　　　--　　Return the current element of the iterator
　　　　　　　　　return collection[index]
　　　　　　end
　　　end
end
for element in elementIterator(array)
do
　　　print(element)
end

The output result of the above example is:

Google
w3codebox

In the above examples, we can see that the closure function is used within elementIterator to calculate the size of the collection and output each element.