Lua Academy · Aula

Argumentos variáveis e o operador ...

Trate listas de argumentos de tamanho variável usando ... e select().

Argumentos variáveis e o operador ... é 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.

Argumentos Variáveis

Uma função de Lua pode aceitar uma quantidade variável de argumentos usando ... (três pontos) na lista de parâmetros. Dentro da função, ... representa os argumentos extras. Você pode usá-lo em expressões, passá-lo para outras funções ou convertê-lo em uma tabela.

local function sum(...)
  local total = 0
  for _, v in ipairs({...}) do
    total = total + v
  end
  return total
end

print(sum(1, 2, 3))        -- 6
print(sum(10, 20, 30, 40)) -- 100

select() para Argumentos Variáveis

select(n, ...) retorna os argumentos a partir da posição n. select("#", ...) retorna a quantidade total de argumentos, incluindo valores nil. Isso é mais seguro do que #{...}, que para no primeiro espaço vazio com nil.

local function inspect(...)
  local n = select("#", ...)
  print("count:", n)
  for i = 1, n do
    print(i, select(i, ...))
  end
end

inspect("a", "b", nil, "d")
-- count: 4
-- 1  a
-- 2  b
-- 3  nil
-- 4  d

Passando ... para Outra Função

Você pode encaminhar argumentos variáveis diretamente para outra função com f(...). Quando ... aparece como o último argumento de uma chamada, todos os argumentos variáveis são passados. Isso é útil para envolver funções ou registrar informações.

local function log(level, ...)
  io.write("[" .. level .. "] ")
  print(...)
end

log("INFO", "Server started on port", 8080)
log("ERROR", "File not found:", "config.lua")
-- [INFO] Server started on port  8080
-- [ERROR] File not found:  config.lua

table.pack e table.unpack

Converta argumentos variáveis em uma tabela com table.pack(...), que também armazena a quantidade no campo n. Converta uma tabela novamente em argumentos variáveis com table.unpack(t, i, j). Juntas, essas funções oferecem controle completo sobre listas de argumentos variáveis.

local function pack_and_show(...)
  local packed = table.pack(...)
  print("n =", packed.n)
  for i = 1, packed.n do
    print(i, packed[i])
  end
end

pack_and_show(10, nil, 30)
-- n = 3
-- 1  10
-- 2  nil
-- 3  30

Argumentos Fixos e Variáveis Misturados

Uma função pode ter parâmetros fixos e variáveis. Os parâmetros fixos vêm primeiro; ... captura o restante. Os parâmetros fixos são atribuídos antes que o restante seja colocado em ....

local function printf(fmt, ...)
  io.write(string.format(fmt, ...))
end

printf("Hello, %s! You are %d years old.\n", "Alice", 30)
printf("Pi is approximately %.4f\n", math.pi)

local function firstAndRest(first, ...)
  print("first:", first)
  print("rest count:", select("#", ...))
end
firstAndRest(1, 2, 3, 4)

Argumentos Variáveis no Construtor de Tabela

Você pode inserir argumentos variáveis diretamente em um construtor de tabela: {...}. Quando usado como o último elemento, todos os argumentos são incluídos. No entanto, espaços vazios com nil podem confundir # — prefira table.pack quando precisar de quantidades exatas.

local function toArray(...)
  return {...}  -- collect all args as array
end

local arr = toArray("x", "y", "z")
for i, v in ipairs(arr) do
  print(i, v)
end
-- 1  x
-- 2  y
-- 3  z

Expressões com Argumentos Variáveis

... pode aparecer em qualquer posição de uma expressão. Em uma atribuição múltipla, ele se expande para todos os seus valores. Em uma expressão aritmética, somente o primeiro valor é usado. Entender esse comportamento evita erros sutis ao misturar ... com outras expressões.

local function first(...)
  local x = ...
  return x
end

print(first(10, 20, 30))  -- 10  (only first)

local function addFirst(n, ...)
  local x = ...
  return n + x
end
print(addFirst(5, 3, 99)) -- 8  (3 is first ...)

print() Usa Argumentos Variáveis

O print() integrado de Lua é, por si só, uma função com argumentos variáveis. Ele aceita qualquer quantidade de argumentos, converte cada um em uma string e os separa com tabulações. Entender isso ajuda você a escrever funções utilitárias semelhantes.

-- print is vararg
print(1, 2, 3)           -- 1  2  3
print("a", nil, "b")     -- a  nil  b
print()                  -- (empty line)

-- Reimplementing a simple print-like function
local function myprint(...)
  local parts = {}
  for i = 1, select("#", ...) do
    parts[i] = tostring(select(i, ...))
  end
  io.write(table.concat(parts, "\t") .. "\n")
end
myprint(10, nil, 30)

Encaminhamento com pcall

Combine pcall com argumentos variáveis para criar um invólucro genérico de chamada segura. O invólucro aceita uma função e quaisquer argumentos, chama-a por meio de pcall e retorna os resultados ou um erro.

local function safeCall(fn, ...)
  local ok, result = pcall(fn, ...)
  if ok then
    return result
  else
    print("Error:", result)
    return nil
  end
end

local function divide(a, b)
  assert(b ~= 0, "division by zero")
  return a / b
end

print(safeCall(divide, 10, 2))   -- 5.0
print(safeCall(divide, 10, 0))  -- Error: ...

Padrão de Acumulação de Argumentos Variáveis

Um padrão comum para argumentos variáveis consiste em percorrer todos os argumentos e acumular um resultado. Isso pode ser feito com uma tabela local ou somando diretamente com select. As duas abordagens são válidas; a abordagem com tabela é mais limpa para muitos argumentos.

local function average(...)
  local n = select("#", ...)
  if n == 0 then return 0 end
  local total = 0
  for i = 1, n do
    total = total + select(i, ...)
  end
  return total / n
end

print(average(10, 20, 30, 40))  -- 25.0
print(average(5))               -- 5.0

Verificação Rápida

O que select("#", 1, nil, 3) retorna?

Recapitulação: Argumentos Variáveis

Resumo:

function f(...) — aceita argumentos variáveis
select("#", ...) — contagem segura, incluindo valores nil
select(n, ...) — valores a partir da posição n
table.pack(...) — converte argumentos variáveis em uma tabela com a quantidade em .n
table.unpack(t) — converte uma tabela em argumentos variáveis
... na última posição expande-se completamente; na posição intermediária fornece um valor

Perguntas Frequentes

A aula “Argumentos variáveis e o operador ...” é grátis?

Sim — o texto completo de “Argumentos variáveis e o operador ...” é 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 “Argumentos variáveis e o operador ...”?

Trate listas de argumentos de tamanho variável usando ... e select(). 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 “Argumentos variáveis e o operador ...”?

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