0Pricing
Lua Academy · Leçon

Modèles semblables aux promesses

Implémentez des objets différés ou semblables aux promesses avec des coroutines et des fonctions de rappel.

Modèles semblables aux promesses est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Qu’est-ce qu’une promesse ?

Une promesse représente une valeur qui sera disponible ultérieurement. Elle peut être en attente, résolue (avec une valeur) ou rejetée (avec une erreur).

Table Lua pour les promesses

Implémentez une promesse minimale sous la forme d’une table contenant un état, une valeur et des listes de fonctions de rappel.

local function newPromise()
  return {
    state    = "pending",
    value    = nil,
    _resolve = {},
    _reject  = {},
  }
end

Résoudre et rejeter

Résoudre une promesse appelle toutes les fonctions de rappel de résolution. La rejeter appelle toutes les fonctions de rappel de rejet.

local function resolve(p, value)
  if p.state ~= "pending" then return end
  p.state = "fulfilled"; p.value = value
  for _, cb in ipairs(p._resolve) do cb(value) end
end
local function reject(p, reason)
  if p.state ~= "pending" then return end
  p.state = "rejected"; p.value = reason
  for _, cb in ipairs(p._reject) do cb(reason) end
end

Chaînage avec andThen

Une méthode :andThen(onFulfill, onReject) renvoie une nouvelle promesse, ce qui permet le chaînage.

function promise:andThen(onFulfill, onReject)
  local next = newPromise()
  self._resolve[#self._resolve+1] = function(v)
    local ok, result = pcall(onFulfill, v)
    if ok then resolve(next, result)
    else reject(next, result) end
  end
  if onReject then
    self._reject[#self._reject+1] = function(e)
      local ok, result = pcall(onReject, e)
      if ok then resolve(next, result)
      else reject(next, result) end
    end
  end
  return next
end

Promesse reposant sur une coroutine

Combinez les promesses avec les coroutines : une coroutine attend une promesse en utilisant yield, et la fonction de rappel de résolution de la promesse la relance.

Promise.all

Attendez que plusieurs promesses soient toutes terminées.

local function all(promises)
  local results = {}
  local count = #promises
  local combined = newPromise()
  for i, p in ipairs(promises) do
    p:andThen(function(v)
      results[i] = v; count = count - 1
      if count == 0 then resolve(combined, results) end
    end, function(e) reject(combined, e) end)
  end
  return combined
end

Promise.race

Résolvez la promesse qui se termine en premier, qu’elle soit résolue ou rejetée.

local function race(promises)
  local combined = newPromise()
  for _, p in ipairs(promises) do
    p:andThen(
      function(v) resolve(combined, v) end,
      function(e) reject(combined, e) end
    )
  end
  return combined
end

Propagation des erreurs dans les chaînes

Si une étape d’une chaîne lève une erreur, celle-ci est transmise au gestionnaire de rejet suivant. Les rejets non gérés doivent être consignés à la fin de la chaîne.

Promesses annulables

Ajoutez une méthode :cancel() qui fait passer la promesse à un état spécial d’annulation et empêche l’exécution des fonctions de rappel.

Promesses différées

Une promesse différée ne commence son travail que lorsqu’un premier andThen lui est associé — ce qui est utile pour les opérations asynchrones facultatives.

Quand utiliser les promesses plutôt que les coroutines

Les promesses sont fondées sur des fonctions de rappel et se composent facilement. Les coroutines donnent au code asynchrone une apparence synchrone. En Lua, les promesses reposant sur des coroutines offrent les deux : la composabilité des promesses et la lisibilité du code synchrone.

Question sur les promesses

Que renvoie la méthode andThen d’une promesse ?

Récapitulatif : modèles de type promesse

Les promesses représentent des valeurs en attente et possèdent les états en attente, résolue et rejetée. Enchaînez les opérations avec andThen. Combinez-les avec les coroutines pour écrire du code de style asynchrone avec attente. Utilisez all et race pour coordonner les opérations parallèles.

Questions Fréquemment Posées

La leçon « Modèles semblables aux promesses » est-elle gratuite ?

Oui — le texte complet de « Modèles semblables aux promesses » 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 « Modèles semblables aux promesses » ?

Implémentez des objets différés ou semblables aux promesses avec des coroutines et des fonctions de rappel. 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 3 sur 4.

Combien de temps prend la leçon « Modèles semblables aux promesses » ?

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

  1. Construire une boucle d’événements simple
  2. Async/Await avec des coroutines
  3. Modèles semblables aux promesses
  4. E/S non bloquantes avec luasocket
← Retour à Lua Academy