Lua Academy · Lezione

Async/await con le coroutine

Crei gli helper async() e await() che sospendono e riprendono le coroutine.

Async/await con le coroutine è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Il concetto di async/await

Async/await è un modello di programmazione in cui le operazioni asincrone hanno l'aspetto di codice sincrono. In Lua, le coroutine forniscono il meccanismo di yield/ripresa necessario per implementarlo in modo naturale.

Funzione await

await(future) esegue yield sulla coroutine corrente e memorizza un callback che la riprende quando il future viene completato.

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

Wrapper per funzioni async

async(fn) esegue il wrapping di una funzione in modo che venga eseguita in una nuova coroutine gestita dallo scheduler.

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

Oggetto future semplice

Un future rappresenta un risultato in sospeso. Lo completi in un secondo momento per riprendere tutte le coroutine in attesa.

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

await nella pratica

Scriva codice asincrono dall'aspetto sequenziale che internamente esegue yield e riprende l'esecuzione.

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")

Propagazione degli errori

Trasmetta gli errori attraverso il future: se l'operazione non riesce, riprenda la coroutine con un flag di errore e il messaggio dell'errore.

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

Sequenziale e parallelo

Utilizzi await in sequenza per le operazioni dipendenti. Per le operazioni indipendenti, avvii entrambe le coroutine ed esegua await su un future di join.

Pattern Promise.all

Esegua più attività asincrone e attenda che siano tutte completate utilizzando un future con contatore.

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

Annullamento

Implementi l'annullamento contrassegnando la coroutine come annullata prima di riprenderla. La coroutine controlla il flag e termina in anticipo.

Integrazione con l'I/O

Integra l'I/O non bloccante: quando una chiamata I/O bloccherebbe l'esecuzione, esegua yield e registri un callback per riprendere l'esecuzione quando i dati sono disponibili.

Confronto con lo stile a callback

Async/await con le coroutine è molto più leggibile dei callback annidati. Anche la gestione degli errori con pcall è più chiara rispetto ai parametri di errore dei callback.

Domanda su async/await

Che cosa fa await(future) in un sistema async basato sulle coroutine?

Riepilogo: async/await con le coroutine

Implementi async/await con le coroutine eseguendo il wrapping delle operazioni asincrone come future che, al completamento, riprendono la coroutine sospesa con yield. Il risultato è codice dall'aspetto sequenziale che in realtà non blocca l'esecuzione.

Domande Frequenti

La lezione «Async/await con le coroutine» è gratuita?

Sì — il testo completo di «Async/await con le coroutine» è 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 «Async/await con le coroutine»?

Crei gli helper async() e await() che sospendono e riprendono le coroutine. 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 2 di 4.

Quanto tempo richiede la lezione «Async/await con le coroutine»?

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