0Pricing
Lua Academy · Lección

Patrones similares a Promise

Implemente objetos deferred/promise mediante coroutines y callbacks.

Patrones similares a Promise es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 3 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.

¿Qué es una promesa?

Una promesa representa un valor que estará disponible en el futuro. Puede estar pendiente, cumplida (con un valor) o rechazada (con un error).

Tabla de promesa en Lua

Implemente una promesa mínima como una tabla con un estado, un valor y listas de callbacks.

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

resolve y reject

Cumplir una promesa llama a todos los callbacks de resolve. Rechazarla llama a todos los callbacks de 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

Encadenamiento con andThen

Un método :andThen(onFulfill, onReject) devuelve una nueva promesa, lo que permite encadenar operaciones.

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

Promesa respaldada por una corrutina

Combine promesas con corrutinas: una corrutina espera una promesa cediendo la ejecución, y el callback de resolve de la promesa la reanuda.

Promise.all

Espere a que se completen todas las promesas.

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

Resuelva con la primera promesa que se complete, ya sea correctamente o con un rechazo.

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

Propagación de errores en cadenas

Si algún paso de una cadena produce un error, este se propaga al siguiente controlador de rechazo. Los rechazos no gestionados deben registrarse al final de la cadena.

Promesas cancelables

Añada un método :cancel() que cambie la promesa a un estado especial de cancelación e impida que se ejecuten los callbacks.

Promesas diferidas

Una promesa diferida solo inicia su trabajo cuando se le añade el primer andThen; resulta útil para operaciones asíncronas opcionales.

Cuándo utilizar promesas o corrutinas

Las promesas se basan en callbacks y se pueden componer. Las corrutinas hacen que el código asíncrono parezca síncrono. En Lua, las promesas respaldadas por corrutinas ofrecen ambas ventajas: la capacidad de composición de las promesas y la legibilidad del código síncrono.

Pregunta sobre promesas

¿Qué devuelve el método andThen de una promesa?

Repaso: patrones similares a las promesas

Las promesas representan valores pendientes mediante los estados pendiente, cumplida y rechazada. Encadene operaciones con andThen. Combínelas con corrutinas para escribir código de estilo async/await. Utilice all y race para coordinar operaciones paralelas.

Preguntas frecuentes

¿La lección «Patrones similares a Promise» es gratis?

Sí — el texto completo de «Patrones similares a Promise» 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 «Patrones similares a Promise»?

Implemente objetos deferred/promise mediante coroutines y callbacks. 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 3 de 4.

¿Cuánto tiempo toma la lección «Patrones similares a Promise»?

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