Lua Academy · Aula

Padrões semelhantes a promessas

Implemente objetos adiados ou promessas usando corrotinas e retornos de chamada.

Padrões semelhantes a promessas é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

O que é uma promessa?

Uma promessa representa um valor que estará disponível no futuro. Ela pode estar pendente, cumprida (com um valor) ou rejeitada (com um erro).

Tabela de promessa em Lua

Implemente uma promessa mínima como uma tabela com estado, valor e listas de retornos de chamada.

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

Cumprir e rejeitar

Cumprir uma promessa chama todos os retornos de chamada de cumprimento. Rejeitá-la chama todos os retornos de chamada de rejeição.

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

Encadeamento com andThen

O método :andThen(onFulfill, onReject) retorna uma nova promessa, permitindo o encadeamento.

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

Promessa baseada em corrotina

Combine promessas com corrotinas: uma corrotina aguarda uma promessa usando yield, e o retorno de chamada de cumprimento da promessa a retoma.

Promise.all

Aguarde a conclusão de várias promessas.

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

Conclua com a primeira promessa que terminar, seja ela cumprida ou rejeitada.

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

Propagação de erros em cadeias

Se alguma etapa de uma cadeia lançar um erro, ele será propagado para o próximo manipulador de rejeição. As rejeições não tratadas devem ser registradas no final da cadeia.

Promessas canceláveis

Adicione um método :cancel() que faça a transição para um estado especial de cancelamento, impedindo a execução dos retornos de chamada.

Promessas sob demanda

Uma promessa sob demanda só inicia seu trabalho quando o primeiro andThen é associado — útil para operações assíncronas opcionais.

Quando usar promessas ou corrotinas

As promessas são baseadas em retornos de chamada e combináveis. As corrotinas fazem o código assíncrono parecer síncrono. Em Lua, promessas baseadas em corrotinas oferecem ambos: a capacidade de composição das promessas e a legibilidade do código síncrono.

Pergunta sobre promessas

O que o método andThen de uma promessa retorna?

Recapitulação: padrões semelhantes a promessas

As promessas representam valores pendentes com estados pendente/cumprida/rejeitada. Encadeie operações com andThen. Combine-as com corrotinas para escrever código no estilo assíncrono/await. Use all e race para coordenação paralela.

Perguntas Frequentes

A aula “Padrões semelhantes a promessas” é grátis?

Sim — o texto completo de “Padrões semelhantes a promessas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Padrões semelhantes a promessas”?

Implemente objetos adiados ou promessas usando corrotinas e retornos de chamada. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Padrões semelhantes a promessas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Lua Academy?

Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Lua Academy