0Pricing
Lua Academy · Lektion

Async/Await mit Coroutinen

Erstellen Sie async()- und await()-Hilfsfunktionen, die Coroutinen anhalten und fortsetzen

Async/Await mit Coroutinen ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Das Async/Await-Konzept

Async/await ist ein Programmiermodell, bei dem asynchrone Operationen wie synchroner Code aussehen. In Lua stellen Coroutines den Mechanismus zum Ausführen von Yield und Resume bereit, mit dem sich dieses Modell natürlich implementieren lässt.

Die Funktion await

await(future) führt in der aktuellen Coroutine einen Yield aus und speichert einen Callback, der sie fortsetzt, sobald das Future abgeschlossen ist.

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

Wrapper-Funktion async

async(fn) verpackt eine Funktion so, dass sie in einer neuen, vom Scheduler verwalteten Coroutine ausgeführt wird.

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

Einfaches Future-Objekt

Ein Future steht für ein ausstehendes Ergebnis. Schließen Sie es später ab; dadurch werden alle wartenden Coroutines fortgesetzt.

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 in der Praxis

Schreiben Sie asynchronen Code, der wie sequenzieller Code aussieht, intern aber Yield und Resume verwendet.

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

Fehlerweitergabe

Geben Sie Fehler über das Future weiter: Wenn die Operation fehlschlägt, setzen Sie die Coroutine mit einem Fehler-Flag und der Fehlermeldung fort.

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

Sequenziell oder parallel

Verwenden Sie await sequenziell für voneinander abhängige Operationen. Starten Sie für unabhängige Operationen beide Coroutines und warten Sie auf ein Join-Future.

Promise.all-Muster

Führen Sie mehrere asynchrone Tasks aus und warten Sie mithilfe eines Zähler-Futures, bis alle abgeschlossen sind.

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

Abbruch

Implementieren Sie den Abbruch, indem Sie die Coroutine vor dem Fortsetzen als abgebrochen markieren. Die Coroutine prüft das Flag und kehrt vorzeitig zurück.

Integration mit I/O

Integrieren Sie nicht blockierendes I/O: Wenn ein I/O-Aufruf blockieren würde, führen Sie einen Yield aus und registrieren Sie einen Callback, der die Coroutine fortsetzt, sobald Daten verfügbar sind.

Vergleich mit dem Callback-Stil

Async/await mit Coroutines ist deutlich besser lesbar als verschachtelte Callbacks. Auch die Fehlerbehandlung mit pcall ist übersichtlicher als Fehlerparameter in Callbacks.

Async/Await-Frage

Was bewirkt await(future) in einem asynchronen System auf Coroutine-Basis?

Zusammenfassung: Async/Await mit Coroutines

Implementieren Sie Async/await mit Coroutines, indem Sie asynchrone Operationen als Futures verpacken, die die pausierte Coroutine nach Abschluss fortsetzen. Das Ergebnis ist Code, der sequenziell aussieht, tatsächlich aber nicht blockierend ausgeführt wird.

Häufig gestellte Fragen

Ist die Lektion „Async/Await mit Coroutinen“ kostenlos?

Ja — der vollständige Text von „Async/Await mit Coroutinen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Async/Await mit Coroutinen“?

Erstellen Sie async()- und await()-Hilfsfunktionen, die Coroutinen anhalten und fortsetzen Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Async/Await mit Coroutinen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Eine einfache Ereignisschleife erstellen
  2. Async/Await mit Coroutinen
  3. Promise-ähnliche Muster
  4. Nicht blockierende E/A mit luasocket
← Zurück zu Lua Academy