0Pricing
Lua Academy · Lección

Async/await con coroutines

Cree helpers async() y await() que suspendan y reanuden coroutines.

Async/await con coroutines es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

La idea de async/await

async/await es un modelo de programación en el que las operaciones asíncronas se escriben como si fueran código síncrono. En Lua, las corrutinas proporcionan de forma natural el mecanismo de ceder y reanudar necesario para implementarlo.

Función await

await(future) hace que la corrutina actual ceda la ejecución y almacena un callback que la reanuda cuando se completa el future.

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

Contenedor de la función async

async(fn) envuelve una función para que se ejecute en una nueva corrutina gestionada por el planificador.

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

Objeto future simple

Un future representa un resultado pendiente. Complételo más adelante para reanudar todas las corrutinas que estén esperándolo.

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 en la práctica

Escriba código asíncrono que parezca secuencial, aunque internamente ceda y reanude la ejecución.

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

Propagación de errores

Transmita los errores a través del future: si la operación falla, reanude la corrutina con un indicador de error y el mensaje correspondiente.

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

Secuencial frente a paralelo

Utilice await en secuencia para operaciones dependientes. Para operaciones independientes, inicie ambas corrutinas y espere un future de unión.

Patrón Promise.all

Ejecute varias tareas asíncronas y espere a que todas terminen mediante un future con un contador.

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

Cancelación

Implemente la cancelación marcando la corrutina como cancelada antes de reanudarla. La corrutina comprueba la marca y termina de inmediato.

Integración con E/S

Integre E/S no bloqueante: cuando una llamada de E/S pueda bloquearse, ceda la ejecución y registre un callback para reanudarla cuando haya datos disponibles.

Comparación con el estilo basado en callbacks

async/await con corrutinas es mucho más legible que los callbacks anidados. El manejo de errores con pcall también es más claro que utilizar parámetros de error en los callbacks.

Pregunta sobre async/await

¿Qué hace await(future) en un sistema asíncrono basado en corrutinas?

Repaso: async/await con corrutinas

Implemente async/await con corrutinas envolviendo las operaciones asíncronas como futures que reanudan la corrutina suspendida al completarse. El resultado es un código de aspecto secuencial que en realidad no bloquea la ejecución.

Preguntas frecuentes

¿La lección «Async/await con coroutines» es gratis?

Sí — el texto completo de «Async/await con coroutines» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Async/await con coroutines»?

Cree helpers async() y await() que suspendan y reanuden coroutines. Practicas Lua Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Lua Academy?

No se requiere experiencia previa. Lua Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Async/await con coroutines»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Lua Academy?

Sí. Cada lección de Lua Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Construcción de un bucle de eventos sencillo
  2. Async/await con coroutines
  3. Patrones similares a Promise
  4. E/S no bloqueante con luasocket
← Volver a Lua Academy