coroutine

Koroutine są używane do wykonania wielu zadań w jednym czasie z tego samego skryptu. Takie zadania mogą obejmować produkcję wartości z wejść lub wykonanie pracy na subroutine, gdy rozwiązuje się większy problem. Zadanie nie musi nawet mieć zdefiniowanego punktu końca, ale musi zdefiniować określone czasy, w których wynika (wstr

Używanie korutyn

Nową rutynę można utworzyć poprzez zapewnienie funkcji do coroutine.create(). Po utworzeniu rutyny nie zaczyna się ona wykonuje,

local function task(...)
	-- Ta funkcja może zrobić trochę pracy, a następnie wydać trochę wartości
	coroutine.yield("first")  -- Zwrócony przez coroutine.resume()
	-- Funkcja ta nadal działa po wznowieniu
	return "second"
end

local taskCoro = coroutine.create(task)
-- Zadzwoń do funkcji po raz pierwszy, co uruchomuje funkcję od początku
local success, result = coroutine.resume(taskCoro, ...)
print(success, result)  --> prawdziwy, pierwszy (zadanie nazywa się coroutine.yield()}
-- Kontynuuj działanie funkcji, aż wyprodukuje lub zatrzyma
success, result = coroutine.resume(taskCoro)
print(success, result)  --> true, second (task halted because it returned "second")

Podczas życia koroutine możesz wezwieć coroutine.status() aby sprawdzić jego stan:

<tbody>
  <tr>
    <td><b>w zawieszeniu</b></td> <td>Korutyna jest w czekaniu na wznowienie. Korutyny zaczynają się w tym stanie i wchodzą, gdy ich funkcja wzywa <code>coroutine.yield()</code>.</td>
  </tr>

  <tr>
    <td><b>biegnące</b></td>
    <td>Korutyna jest teraz uruchomiona.</td>
  </tr>

  <tr>
    <td><b>zwykły</b></td> <td>Koroutine czeka na wynik innej koroutinej; innymi słowy, ponownie uruchomiła inną koroutinej.</td>
  </tr>

  <tr>
    <td><b>martwy</b></td> <td>Funkcja została zatrzymana (zwrócono lub rzucono błąd). Koroutine nie może być dalej używany.</td>
  </tr>
</tbody>

Wrapping Coroutines

Podczas pracy z korozyjami możesz również zrezygnować z użycia obiektu korozyjnego i zamiast tego użyć funkcji zapasu. Takie funkcje zapasu będą odtwarzać określony korozyjny obiekt, gdy zostanie on wywołany, i zwrócą tylko zwracane wartości. Możesz to zrobić używając coroutine.wrap() :

-- Utwórz funkcję rutyny i zwróć funkcję wrzutnię, która ją ponownie uruchomi
local f = coroutine.wrap(task)
-- Podsumuj rutynę, jakbyśmy nazywali rutynę resetową.
local result = f()
-- Jeśli nastąpi błąd, zostanie on podniesiony tutaj!
-- This differs from coroutine.resume() which acts similar to pcall()

Pierwsza wartość zwrócona z coroutine.resume() opisuje, czy rutyna została uruchomiona bez błędów. Funkcje zwracane przez coroutine.wrap() nie zrobią tego, ponieważ bezpośrednio zwracają wartości zwrócone lub przesłane do coroutine.yield(),

Przykład wzoru producenta

Pomyśl zadanie, które wytwarza powtórzenia słowa: każdym razem, gdy wytwarza powtórzenie, następne będzie wytwarzać jeszcze jedno. Na przykład, zapewnienie Hello będzie wytwarzać Hello, HelloHello, itp. Aby to zrobić, możesz zdefiniować

-- Funkcja ta powtarza słowo za każdym razem, gdy jej rutyna zostanie wznowiona
local function repeatThis(word)
	local repetition = ""
	while true do
		-- Zrób jedną powtórzenie, a następnie wygeneruj wynik
		repetition = repetition .. word
		coroutine.yield(repetition)
	end
end

Aby uruchomić tę funkcję jako rutynę, możesz użyć coroutine.create() następującego przez wiele wezwów do coroutine.resume() :

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

Dla tej funkcji producenta możesz również użyć coroutine.wrap() , aby uzyskać funkcję, która wytwarza wartości:

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