coroutine

Une coroutine est utilisée pour exécuter plusieurs tâches à la fois à partir du même script. De telles tâches peuvent inclure la production de valeurs à partir des entrées ou l'exécution d'un travail sur une subroutine lors de la résolution d'un problème plus important. Une tâche n'a même pas besoin d'avoir un point d'arrêt défini, mais il doit définir des temps spécifiques à laquelle il lève (pause) pour permettre à d'

Utilisation des Coroutines

Une nouvelle coroutine peut être créée en fournissant une fonction à coroutine.create() . Une fois créée, une coroutine ne démarre pas courir jusqu'à ce que la première appel à Library.

local function task(...)
	-- Cette fonction peut faire un peu de travail, puis produire une certaine valeur
	coroutine.yield("first")  -- Renvoyé par coroutine.resume()
	-- La fonction se poursuit une fois qu'elle a repris
	return "second"
end

local taskCoro = coroutine.create(task)
-- Appeler resume pour la première fois, qui exécute la fonction depuis le début
local success, result = coroutine.resume(taskCoro, ...)
print(success, result)  --> vrai, d'abord (tâche appelée coroutine.yield()
-- Continuez à exécuter la fonction jusqu'à ce qu'elle génère ou arrête
success, result = coroutine.resume(taskCoro)
print(success, result)  --> true, second (task halted because it returned "second")

Pendant la durée de la vie de la coroutine, vous pouvez appeler coroutine.status() pour inspecter son statut :

<tbody>
  <tr>
    <td><b>suspendu</b></td> <td>La coroutine est en attente d'être reprise. Les corutines commencent dans cet état et entrent quand leur fonction s'appelle <code>coroutine.yield()</code>.</td>
  </tr>

  <tr>
    <td><b>courir</b></td>
    <td>La coroutine s'exécute en ce moment.</td>
  </tr>

  <tr>
    <td><b>normal</b></td> <td>La coroutine attend l'exécution d'une autre coroutine ; en d'autres termes, elle a repris une autre coroutine.</td>
  </tr>

  <tr>
    <td><b>mort</b></td> <td>La fonction s'est arrêtée (erreur renvoyée ou exception lancée). La coroutine ne peut pas être utilisée de plus.</td>
  </tr>
</tbody>

Wrap Coroutines

Lorsque vous travaillez avec des coroutines, vous pouvez également renoncer à l'utilisation de l'objet coroutine et utiliser une fonctionnalitéWrap. Une telle fonctionnalitéWrap reprendra une certaine coroutine lorsqu'elle est appelée et ne retournera que les valeurs produites. Vous pouvez le faire en utilisant coroutine.wrap() :

-- Créez une routine et rennez une fonction de rappel qui la reprend
local f = coroutine.wrap(task)
-- Résumez la coroutine comme si nous appelions coroutine.resume()
local result = f()
-- Si une erreur se produit, il sera souligné ici !
-- This differs from coroutine.resume() which acts similar to pcall()

La première valeur renvoyée par coroutine.resume() décrit si une coroutine s'est exécutée sans erreurs. Cependant, les fonctions renvoyées par coroutine.wrap() ne le feront pas : au lieu de cela, elles renvoient directement les valeurs renvoyées ou transmises à coroutine.yield(), si nécessaire. Si une erreur s'

Exemple de modèle de producteur

Imaginez une tâche qui produit des répétitions d'un mot : chaque fois qu'elle produit une répétition, la suivante produira une autre. Par exemple, fournir Hello produira Hello, HelloHello, 1> HelloHello1>, etc. Pour ce faire, vous pouvez définir 4> peatThis4> :

-- Cette fonction répète un mot à chaque fois que sa routine est reprise
local function repeatThis(word)
	local repetition = ""
	while true do
		-- Faites une répétition puis générez le resultats
		repetition = repetition .. word
		coroutine.yield(repetition)
	end
end

Pour exécuter cette fonction comme une coroutine, vous pouvez utiliser coroutine.create() suivi de plusieurs appels à coroutine.resume() :

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

Pour cette fonction de producteur, vous pouvez également utiliser coroutine.wrap() pour obtenir une fonction qui produit des valeurs :

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