coroutine

Una coroutine viene utilizzata per eseguire più compiti contemporaneamente all'interno dello stesso script.Tali compiti potrebbero includere la produzione di valori da input o l'esecuzione di lavori su una sottoroutine quando si risolve un problema più grande.Un'attività non ha nemmeno bisogno di avere un punto di fine definito, ma deve definire particolari tempi in cui produce (pausa) per lasciare che altre cose vengano lavorate.

Utilizzo delle coroutine

Una nuova coroutine può essere creata fornendo una funzione a coroutine.create() .Una volta creato, una coroutine non inizia a funzionare fino alla prima chiamata a coroutine.resume() che passa gli argomenti alla funzione.Questa chiamata restituisce quando la funzione si ferma o chiama coroutine.yield() e, quando ciò accade, coroutine.resume() restituisce i valori restituiti dalla funzione, i valori inviati a coroutine.yield() o un Messaggiodi errore.Se commette un errore, il secondo valore di ritorno è l'errore lanciato.

local function task(...)
	-- Questa funzione potrebbe fare un po' di lavoro per un po', quindi produrre un po' di valore
	coroutine.yield("first")  -- Da restituire da coroutine.resize()
	-- La funzione continua una volta ripresa di nuovo
	return "second"
end

local taskCoro = coroutine.create(task)
-- Chiama il ripristino per la prima volta, che esegue la funzione dall'inizio
local success, result = coroutine.resume(taskCoro, ...)
print(success, result)  --> vero, prima (task chiamato coroutine.yield())
-- Continua ad eseguire la funzione fino a quando non produce o si ferma
success, result = coroutine.resume(taskCoro)
print(success, result)  --> true, second (task halted because it returned "second")

Durante la vita della coroutine, puoi chiamare coroutine.status() per ispezionare il suo Stato:

<th>Significato</th>
  </tr>
</thead>

<tbody>
  <tr>
    <td><b>sospeso</b></td>

    <td>La coroutine è in attesa di essere ripresa. Le coroutine iniziano in questo stato e entrano quando la loro funzione chiama <code>coroutine.yield()</code> .</td>
  </tr>

  <tr>
    <td><b>esecuzione</b></td>

    <td>La coroutine è in esecuzione proprio ora.</td>
  </tr>

  <tr>
    <td><b>normale</b></td>

    <td>La coroutine sta aspettando il rendimento di un'altra coroutine; in altre parole, ha ripreso un'altra coroutine.</td>
  </tr>

  <tr>
    <td><b>morto</b></td>

    <td>La funzione è stata interrotta (restituita o lanciata un'errore). La coroutine non può essere utilizzata ulteriormente.</td>
  </tr>
</tbody>

Involucro delle coroutine

Quando lavori con le coroutine, puoi anche rinunciare all'uso dell'oggetto coroutine e invece usare una funzione wrapper.Una funzione wrapper del genere riprenderà una particolare coroutine quando viene chiamata e restituirà solo i valori ottenuti.Puoi farlo usando coroutine.wrap() :

-- Crea una coroutine e restituisce una funzione wrapper che la riprende
local f = coroutine.wrap(task)
-- Riprendi la coroutine come se chiamassimo coroutine.resume()
local result = f()
-- Se si verifica un errore verrà sollevata qui!
-- This differs from coroutine.resume() which acts similar to pcall()

Il primo valore restituito da coroutine.resume() descrive se una coroutine è stata eseguita senza errori.Tuttavia, le funzioni restituite da coroutine.wrap() non faranno ciò: invece, restituiranno direttamente i valori restituiti o passati a coroutine.yield(), se presenti.Se si è verificato un errore durante l'esecuzione della funzione coroutine, l'errore viene sollevato durante la chiamata della funzione restituita.

Esempio di modello produttore

Immagina un compito che produce ripetizioni di una parola: ogni volta che produce una ripetizione, la successiva ne produrrà un'altra.Ad esempio, fornire Hello produrrà Hello , HelloHello , HelloHelloHello , ecc.Per farlo, puoi definire repeatThis() :

-- Questa funzione ripete una parola ogni volta che la sua coroutine viene ripresa
local function repeatThis(word)
	local repetition = ""
	while true do
		-- Fai una ripetizione poi ottieni il Risultato
		repetition = repetition .. word
		coroutine.yield(repetition)
	end
end

Per eseguire questa funzione come coroutine, puoi usare coroutine.create() seguita da più chiamate a coroutine.resume() :

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

Per questa funzione produttore, puoi anche usare coroutine.wrap() per ottenere una funzione che produce valori:

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