coroutine

Eine Coroutine wird verwendet, um mehrere Aufgaben gleichzeitig aus dem selben Skript, das. PL: die Skriptsauszuführen. Solche Aufgaben können die Produktion von Werte aus Eingaben oder die Ausführung von Arbeit auf einer Subroutine umfassen, wenn ein größeres Problem gelöst wird. Ein Task muss nicht ein bestimmtes Endpunkt haben, aber er muss einen bestimmten Zeitpunkt definieren, zu dem er wird (暂停) ausgeführt, um andere Dinge zu arbeiten.

Verwendung von Coroutines

Eine neue Koroutine kann erstellt werden, indem eine Funktion zu coroutine.create() bereitgestellt wird. Nachdem eine Koroutine erstellt wurde, beginnt eine Koroutine nicht zu laufen, bis

local function task(...)
	-- Diese Funktion kann ein wenig Arbeit für einige Arbeit erledigen und dann einen Wert liefern
	coroutine.yield("first")  -- Zurückgegeben von coroutine.resume()
	-- Die Funktion wird wieder aufgenommen, sobald sie wieder aufgenommen wird
	return "second"
end

local taskCoro = coroutine.create(task)
-- Rufen Sie zum ersten Mal die Rückruf funktion auf, die die Funktion vom Anfang an ausführt
local success, result = coroutine.resume(taskCoro, ...)
print(success, result)  --> true, first (task namens coroutine.yield()}
-- Führen Sie die Funktion weiter aus, bis sie entweder läuft 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 können Sie coroutine.status() aufrufen, um seinen Statuszu überprüfen:

<tbody>
  <tr>
    <td><b>gefederte</b></td> <td>Die Coroutine wartet darauf, wieder aufgenommen zu werden. Coroutines beginnen in diesem Zustand und geben sie 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 Coroutine wartet auf die Ausgabe einer anderen Coroutine; mit anderen Worten, sie hat eine andere Coroutine wieder aufgenommen.</td>
  </tr>

  <tr>
    <td><b>tot</b></td> <td>Die Funktion wurde angehalten (Fehler zurückgegeben oder Fehler geworfen). Die Coroutine kann nicht weiter verwendet werden.</td>
  </tr>
</tbody>

Wrap-Koroutinen

Wenn Sie mit Coroutinen arbeiten, können Sie auch die Verwendung des Coroutine-Objekts verlassen und stattdessen eine Wrap-Funktion verwenden. Eine solche Wrap-Funktion wird eine bestimmte Coroutine wieder aufrufen und nur die produzierten Werte zurückgeben. Sie können dies mit coroutine.wrap() tun:

-- Erstellen Sie eine Coroutine und geben Sie eine Wrap-Funktion zurück, die sie wieder aufruft
local f = coroutine.wrap(task)
-- Fassen Sie die Coroutine zusammen, als ob wir coroutine.resume() aufrufen
local result = f()
-- Wenn ein Fehler auftritt, wird er hier aufgeführt!
-- This differs from coroutine.resume() which acts similar to pcall()

Der erste Wert, der von coroutine.resume() beschreibt, ob eine Coroutine ohne Fehler ausgeführt wird. Funktionen, die von coroutine.wrap() zurückgegeben werden, werden dies jedoch nicht tun: Stattdessen geben sie die zurückgegebenen Werte oder die übergegebenen Werte direkt an coroutine.yield() zurück, wenn vorhanden. Wenn ein

Beispiel für Produzentenmuster

Stellen Sie sich eine Aufgabe vor, die Wiederholungen eines Wortes erstellt: Jedes Mal, wenn es eine Wiederholung erstellt, produziert die nächste, um eine weitere zu erzeugen. Zum Beispiel, wenn Sie Hello bereitstellen, wird Hello , HelloHello , 1> HelloHelloHello1> , usw. Um dies zu tun, können Sie definieren

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

Um diese Funktion als Routine auszuführen, können Sie coroutine.create() gefolgt von mehreren Aufrufen zu coroutine.resume() verwenden:

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

Für diese Produzentenfunktion können Sie auch coroutine.wrap() verwenden, um eine Funktion zu erhalten, die Werte produziert:

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