coroutine

Eine Koroutine wird verwendet, um mehrere Aufgaben gleichzeitig aus demselben Skript, das. PL: die Skriptsauszuführen.Solche Aufgaben könnten die Erzeugung von Werten aus Eingaben oder die Arbeit an einer Unterroutine beinhalten, wenn ein größeres Problem gelöst wird.Eine Aufgabe muss nicht einmal einen definierten Endpunkt haben, aber sie muss bestimmte Zeiten definieren, zu denen sie geben (pausieren) kann, damit andere Dinge bearbeitet werden können.

Verwendung von Coroutinen

Eine neue Koroutine kann erstellt werden, indem eine Funktion bereitgestellt wird, um coroutine.create() .Sobald er erstellt wurde, beginnt eine Koroutine nicht zu laufen, bis die erste Anruf an coroutine.resume(), der die Argumente an die Funktion übermittelt, erfolgt.Dieser Aufruf wird zurückgegeben, wenn die Funktion entweder stoppt oder coroutine.yield() anruft, und wenn dies geschieht, gibt coroutine.resume() entweder die von der Funktion zurückgegebenen Werte, die an coroutine.yield() gesendeten Werte oder eine Nachrichtzurück.Wenn es einen Fehler gibt, ist der zweite Rückgabewert der geworfene Fehler.

local function task(...)
	-- Diese Funktion könnte ein bisschen Arbeit für ein bisschen tun und dann einen Wert abgeben
	coroutine.yield("first")  -- Von coroutine.resume() zurückzugeben
	-- Die Funktion wird fortgesetzt, sobald sie wieder aufgenommen wird
	return "second"
end

local taskCoro = coroutine.create(task)
-- Rufen Sie zum ersten Mal die Wiederaufnahme des Aufrufs auf, die die Funktion von Anfang an ausführt
local success, result = coroutine.resume(taskCoro, ...)
print(success, result)  --> true, zuerst (aufgabe namens coroutine.yield()} aufgerufen)
-- Führe die Funktion weiter aus, bis sie aufgibt oder angehalten wird
success, result = coroutine.resume(taskCoro)
print(success, result)  --> true, second (task halted because it returned "second")

Während der Lebensdauer der Coroutine kannst du coroutine.status() anrufen, um ihren Status zu überprüfen:

<th>Bedeutung</th>
  </tr>
</thead>

<tbody>
  <tr>
    <td><b>gesperrt</b></td>

    <td>Die Koroutine wartet darauf, wieder aufgenommen zu werden. Korroutinen beginnen in diesem Zustand und treten ein, wenn ihre Funktion <code>coroutine.yield()</code> aufruft.</td>
  </tr>

  <tr>
    <td><b>läuft</b></td>

    <td>Die Koroutine läuft gerade.</td>
  </tr>

  <tr>
    <td><b>normal</b></td>

    <td>Die Koroutine wartet auf die Ausgabe einer anderen Koroutine; mit anderen Worten, sie hat eine andere Koroutine wieder aufgenommen.</td>
  </tr>

  <tr>
    <td><b>tot</b></td>

    <td>Die Funktion wurde unterbrochen (returned oder thrown einen Fehler). Die Koroutine kann nicht weiter verwendet werden.</td>
  </tr>
</tbody>

Coroutinen einpacken

Wenn Sie mit Coroutinen arbeiten, können Sie auch die Verwendung des Coroutine-Objekts vermeiden und stattdessen eine Wrapper-Funktion verwenden.Eine solche Wrapper-Funktion wird eine bestimmte Koroutine fortsetzen, wenn sie aufgerufen wird, und wird nur die übergebenen Werte zurückgeben.Du kannst dies mit coroutine.wrap() tun:

-- Erstelle eine Koroutine und gib eine Wrapper-Funktion zurück, die sie fortsetzt
local f = coroutine.wrap(task)
-- Fortsetzen der Coroutine, als ob wir coroutine.resume() aufgerufen hätten
local result = f()
-- Wenn ein Fehler auftritt, wird er hier angezeigt!
-- This differs from coroutine.resume() which acts similar to pcall()

Der erste Wert, der von coroutine.resume() zurückgegeben wird, beschreibt, ob eine Koroutine ohne Fehler ausgeführt wurde.Funktionen, die von coroutine.wrap() zurückgegeben werden, tun dies jedoch nicht: stattdessen geben sie die zurückgegebenen oder übergebenen Werte direkt an coroutine.yield() zurück, wenn vorhanden.Sollte ein Fehler während der Ausführung der Koroutinefunktion aufgetreten sein, wird der Fehler auf dem Aufruf der zurückgegebenen Funktion erhoben.

Beispiel für Produzentenmuster

Stell dir eine Aufgabe vor, die Wiederholungen eines Wortes erzeugt: jedes Mal, wenn sie eine Wiederholung erzeugt, wird die nächste mehr produzieren.Zum Beispiel wird die Bereitstellung von Hello produzieren Hello , HelloHello , HelloHelloHello usw.Um dies zu tun, können Sie repeatThis() definieren:

-- Diese Funktion wiederholt ein Wort jedes Mal, wenn seine Koroutine wieder aufgenommen wird
local function repeatThis(word)
	local repetition = ""
	while true do
		-- Machen Sie eine Wiederholung und geben Sie dann das Ergebnis aus
		repetition = repetition .. word
		coroutine.yield(repetition)
	end
end

Um diese Funktion als Koroutine auszuführen, kannst du coroutine.create() verwenden, gefolgt von mehreren Anrufen bei coroutine.resume() :

local repetitionCoro = coroutine.create(repeatThis)
print(coroutine.resume(repetitionCoro, "Hello"))  -- echt, Hallo
print(coroutine.resume(repetitionCoro))           -- echt, HelloHello
print(coroutine.resume(repetitionCoro))           -- true, HelloHelloHello

Für diese Produzentenfunktion kannst du auch coroutine.wrap() verwenden, um eine Funktion zu erhalten, die Werte produziert:

local f = coroutine.wrap(repeatThis)
print(f("Hello"))  -- Hallo
print(f())         -- HalloHello
print(f())         -- HelloHelloHello