Lua Academy · Leçon

Async/Await avec des coroutines

Créez des fonctions auxiliaires async() et await() qui suspendent et reprennent les coroutines.

Leçon 2 sur 413 étapes

Async/Await avec des coroutines est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Le concept de l’asynchrone et de l’attente

La programmation asynchrone est un modèle dans lequel les opérations asynchrones ressemblent à du code synchrone. Dans Lua, les coroutines fournissent naturellement le mécanisme yield/resume nécessaire à sa mise en œuvre.

Fonction d’attente

await(future) suspend la coroutine actuelle et enregistre une fonction de rappel qui la relance lorsque l’objet futur est terminé.

local function await(future)
  local co = coroutine.running()
  future.onComplete = function(result)
    coroutine.resume(co, result)
  end
  return coroutine.yield()
end

Enveloppe de fonction asynchrone

async(fn) enveloppe une fonction afin qu’elle s’exécute dans une nouvelle coroutine gérée par l’ordonnanceur.

local function async(fn)
  return function(...)
    local co = coroutine.create(fn)
    local ok, err = coroutine.resume(co, ...)
    if not ok then print("async error:", err) end
    return co
  end
end

Objet futur simple

Un objet futur représente un résultat en attente. Terminez-le plus tard pour relancer toutes les coroutines en attente.

local function newFuture()
  local f = {done=false, value=nil, waiters={}}
  f.complete = function(val)
    f.done = true; f.value = val
    for _, cb in ipairs(f.waiters) do cb(val) end
  end
  f.andThen = function(cb)
    if f.done then cb(f.value)
    else f.waiters[#f.waiters+1] = cb end
  end
  return f
end

L’attente en pratique

Écrivez du code asynchrone à l’apparence séquentielle, qui utilise en interne yield et resume.

local fetchData = async(function(url)
  local result = await(httpGet(url))  -- yields
  local parsed = await(parseJSON(result))  -- yields again
  print("Got:", parsed.name)
end)
fetchData("http://example.com/api")

Propagation des erreurs

Transmettez les erreurs par l’objet futur : si l’opération échoue, relancez la coroutine avec un indicateur d’erreur et le message d’erreur.

local function awaitSafe(future)
  local co = coroutine.running()
  future.onComplete = function(ok, result)
    coroutine.resume(co, ok, result)
  end
  return coroutine.yield()
end

Séquentiel ou parallèle

Utilisez await successivement pour les opérations dépendantes. Pour les opérations indépendantes, lancez les deux coroutines et attendez un objet futur de jonction.

Modèle Promise.all

Exécutez plusieurs tâches asynchrones et attendez qu’elles soient toutes terminées à l’aide d’un objet futur avec compteur.

local function all(futures)
  local results = {}
  local count = #futures
  local combined = newFuture()
  for i, f in ipairs(futures) do
    f:andThen(function(v)
      results[i] = v
      count = count - 1
      if count == 0 then combined.complete(results) end
    end)
  end
  return combined
end

Annulation

Implémentez l’annulation en marquant la coroutine comme annulée avant de la relancer. La coroutine vérifie l’indicateur et se termine prématurément.

Intégration aux E/S

Intégrez des E/S non bloquantes : lorsqu’un appel d’E/S risque de bloquer, utilisez yield et enregistrez une fonction de rappel qui relancera la coroutine lorsque les données seront disponibles.

Comparaison avec le style à base de fonctions de rappel

Le style asynchrone avec coroutines est bien plus lisible que des fonctions de rappel imbriquées. La gestion des erreurs avec pcall est également plus claire que des paramètres d’erreur transmis aux fonctions de rappel.

Question sur l’asynchrone et l’attente

Que fait await(future) dans un système asynchrone fondé sur les coroutines ?

Réponds-y dans la leçon interactive

Récapitulatif : asynchrone et attente avec des coroutines

Implémentez l’asynchrone et l’attente avec des coroutines en enveloppant les opérations asynchrones dans des objets futurs qui relancent la coroutine suspendue à leur achèvement. Vous obtenez un code à l’apparence séquentielle, mais qui est en réalité non bloquant.

Gratuit pour commencer

Apprends Lua avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 40
Leçons: 159

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Async/Await avec des coroutines » est-elle gratuite ?

Oui — le texte complet de « Async/Await avec des coroutines » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Async/Await avec des coroutines » ?

Créez des fonctions auxiliaires async() et await() qui suspendent et reprennent les coroutines. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Async/Await avec des coroutines » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Construire une boucle d’événements simple
Async/Await avec des coroutines
Modèles semblables aux promesses
E/S non bloquantes avec luasocket

← Retour à Lua Academy