Lua Academy · Lektion

Async/await med coroutiner

Opret async()- og await()-hjælpefunktioner, der suspenderer og genoptager coroutiner.

Lektion 2 af 413 trin

Async/await med coroutiner er en gratis Lua Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lua Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lua Academy-kurset indeholder 4 lektioner i alt.

Idéen bag async/await

Async/await er en programmeringsmodel, hvor asynkrone handlinger ser ud som synkron kode. I Lua leverer coroutines mekanismen til at give kontrollen tilbage og genoptage arbejdet, så modellen kan implementeres naturligt.

await-funktion

await(future) giver kontrollen tilbage fra den aktuelle coroutine og gemmer et callback, der genoptager den, når det fremtidige resultat er fuldført.

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

Wrapper til async-funktion

async(fn) pakker en funktion ind, så den kører i en ny coroutine, som administreres af planlæggeren.

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

Simpelt objekt for fremtidigt resultat

Et fremtidigt resultat repræsenterer et resultat, der afventer. Fuldfør det senere, så genoptages alle ventende coroutines.

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 i praksis

Skriv asynkron kode, der ser sekventiel ud, men internt giver kontrollen tilbage og genoptager arbejdet.

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

Videregivelse af fejl

Send fejl videre gennem det fremtidige resultat: Hvis handlingen mislykkes, skal du genoptage coroutinen med et fejlflag og fejlmeddelelsen.

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

Sekventiel kontra parallel

Brug await i rækkefølge til afhængige handlinger. Opret begge coroutines for uafhængige handlinger, og afvent et fremtidigt resultat, der samler dem.

Mønstret Promise.all

Kør flere asynkrone opgaver, og vent på, at de alle fuldføres, ved hjælp af et fremtidigt resultat med en tæller.

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

Annullering

Implementér annullering ved at markere coroutinen som annulleret, før den genoptages. Coroutinen kontrollerer flaget og returnerer tidligt.

Integration med I/O

Integrér med ikke-blokerende I/O: Når et I/O-kald ville blokere, skal du give kontrollen tilbage og registrere et callback, der genoptager arbejdet, når data er tilgængelige.

Sammenligning med callback-stilen

Async/await med coroutines er markant mere læseligt end indlejrede callbacks. Fejlhåndtering med pcall er også mere overskuelig end fejlparametre i callbacks.

Spørgsmål om async/await

Hvad gør await(future) i et asynkront system baseret på coroutines?

Besvar den i den interaktive lektion

Opsummering: Async/await med coroutines

Implementér async/await med coroutines ved at pakke asynkrone handlinger ind som fremtidige resultater, der genoptager den coroutine, som har givet kontrollen tilbage, når handlingen er fuldført. Resultatet er kode, der ser sekventiel ud, men faktisk ikke blokerer.

Gratis at komme i gang

Lær Lua med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 40
Lektioner: 159

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Async/await med coroutiner” gratis?

Ja — alle 3 lektioner i læringssporet Lua Academy, inklusive “Async/await med coroutiner”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lua Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Async/await med coroutiner”?

Opret async()- og await()-hjælpefunktioner, der suspenderer og genoptager coroutiner. Du øver dig i Lua Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Lua Academy?

Der kræves ingen tidligere erfaring. Lua Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Async/await med coroutiner”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Lua Academy-lektion?

Ja. Alle Lua Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Lua Academy