Lua Academy · Lezione

Pattern simili alle promise

Implementi oggetti deferred/promise usando coroutine e callback.

Pattern simili alle promise è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Che cos'è una promise

Una promise rappresenta un valore che sarà disponibile in futuro. Può essere pending, fulfilled (con un valore) oppure rejected (con un errore).

Tabella promise in Lua

Implementi una promise minima come una tabella contenente stato, valore ed elenchi di callback.

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

resolve e reject

Il completamento di una promise richiama tutti i callback di resolve. Il suo rifiuto richiama tutti i callback di reject.

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

Concatenamento con andThen

Un metodo :andThen(onFulfill, onReject) restituisce una nuova promise, consentendo il concatenamento.

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

Promise basata su coroutine

Combini le promise con le coroutine: una coroutine attende una promise eseguendo yield e il callback di resolve della promise la riprende.

Promise.all

Attenda che più promise siano state completate.

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

Restituisca il risultato della prima promise completata (fulfilled o rejected).

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

Propagazione degli errori nelle catene

Se un passaggio della catena genera un errore, l'errore viene propagato al gestore del rifiuto successivo. I rifiuti non gestiti dovrebbero essere registrati alla fine della catena.

Promise annullabili

Aggiunga un metodo :cancel() che trasferisca la promise in uno stato speciale di annullamento, impedendo l'esecuzione dei callback.

Promise lazy

Una promise lazy avvia il proprio lavoro solo quando viene associato il primo andThen — utile per le operazioni asincrone facoltative.

Quando utilizzare promise o coroutine

Le promise sono basate sui callback e possono essere composte. Le coroutine fanno apparire il codice asincrono come sincrono. In Lua, le promise basate sulle coroutine offrono entrambi i vantaggi: la componibilità delle promise e la leggibilità del codice sincrono.

Domanda sulle promise

Che cosa restituisce il metodo andThen di una promise?

Riepilogo: pattern simili alle promise

Le promise rappresentano valori in sospeso e possono trovarsi negli stati pending/fulfilled/rejected. Concatenare le operazioni con andThen. Combinarle con le coroutine per ottenere codice nello stile async/await. Utilizzare all e race per il coordinamento parallelo.

Domande Frequenti

La lezione «Pattern simili alle promise» è gratuita?

Sì — il testo completo di «Pattern simili alle promise» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Pattern simili alle promise»?

Implementi oggetti deferred/promise usando coroutine e callback. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Pattern simili alle promise»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Lua Academy