Lua Academy · Lección

Varargs y el operador ...

Gestione listas de argumentos de longitud variable mediante ... y select().

Varargs y el operador ... 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.

Argumentos variables

Una función de Lua puede aceptar un número variable de argumentos mediante ... (tres puntos) en la lista de parámetros. Dentro de la función, ... representa los argumentos adicionales. Puede usarlo en expresiones, pasarlo a otras funciones o convertirlo en una tabla.

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 variables

select(n, ...) devuelve los argumentos desde la posición n en adelante. select("#", ...) devuelve el recuento total de argumentos, incluidos los valores nil. Es más seguro que #{...}, que se detiene en el primer hueco con 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

Pasar ... a otra función

Puede reenviar directamente los argumentos variables a otra función mediante f(...). Cuando ... aparece como el último argumento de una llamada, se pasan todos los argumentos variables. Esto resulta útil para envolver funciones o registrar información.

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 y table.unpack

Convierta los argumentos variables en una tabla con table.pack(...), que también almacena el recuento en el campo n. Convierta una tabla de nuevo en argumentos variables con table.unpack(t, i, j). Juntas, estas funciones le proporcionan un control total sobre las listas de argumentos variables.

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 fijos y variables combinados

Una función puede tener parámetros fijos y variables. Los parámetros fijos aparecen primero; ... captura el resto. Los parámetros fijos se asignan antes de que el resto se incluya en ....

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 variables en un constructor de tablas

Puede expandir directamente los argumentos variables en un constructor de tablas: {...}. Cuando se usa como último elemento, se incluyen todos los argumentos. Sin embargo, los huecos con nil pueden confundir a #; prefiera table.pack cuando necesite recuentos exactos.

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

Expresiones con argumentos variables

... puede aparecer en cualquier posición de una expresión. En una asignación múltiple, se expande a todos sus valores. En una expresión aritmética, solo se usa el primer valor. Comprender este comportamiento evita errores sutiles al combinar ... con otras expresiones.

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 variables

La función integrada print() de Lua también es una función con argumentos variables. Acepta cualquier cantidad de argumentos, convierte cada uno en una cadena y los separa con tabulaciones. Comprender esto le ayudará a escribir funciones de utilidad similares.

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

Reenviar argumentos con pcall

Combine pcall con argumentos variables para crear un envoltorio genérico de llamadas seguras. El envoltorio acepta una función y cualquier cantidad de argumentos, la llama mediante pcall y devuelve los resultados o un error.

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: ...

Patrón para acumular argumentos variables

Un patrón habitual con argumentos variables consiste en iterar sobre todos los argumentos y acumular un resultado. Puede hacerlo con una tabla local o sumarlos directamente mediante select. Ambos enfoques son válidos; el de la tabla resulta más claro cuando hay muchos 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

Comprobación rápida

¿Qué devuelve select("#", 1, nil, 3)?

Repaso: argumentos variables

Resumen:

function f(...): acepta argumentos variables
select("#", ...): obtiene un recuento seguro que incluye los valores nil
select(n, ...): obtiene los valores desde la posición n
table.pack(...): convierte los argumentos variables en una tabla con el recuento .n
table.unpack(t): convierte una tabla en argumentos variables
... en la última posición se expande por completo; en una posición intermedia produce un valor

Preguntas frecuentes

¿La lección «Varargs y el operador ...» es gratis?

Sí — el texto completo de «Varargs y el operador ...» 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 «Varargs y el operador ...»?

Gestione listas de argumentos de longitud variable mediante ... y select(). 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 «Varargs y el operador ...»?

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

← Volver a Lua Academy