Lua Academy · Lección

Múltiples valores de retorno

Devuelva y capture varios valores en una sola llamada a función.

Múltiples valores de retorno 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.

Devolver varios valores

A diferencia de la mayoría de los lenguajes, las funciones de Lua pueden devolver de forma nativa varios valores mediante una sola instrucción return. Los valores múltiples se separan por comas después de return. Esto evita la necesidad de usar objetos contenedores o parámetros de salida.

local function divmod(a, b)
  return math.floor(a / b), a % b
end

local quotient, remainder = divmod(17, 5)
print(quotient, remainder)   -- 3  2

Ajustar los valores devueltos

Lua ajusta los valores devueltos para que coincidan con la cantidad de receptores. Los valores adicionales se descartan y los valores faltantes se convierten en nil. Este ajuste ocurre cuando una llamada a una función no es la última expresión de una lista; en esa posición, solo se conserva el primer valor.

local function triple()
  return 10, 20, 30
end

local a, b, c = triple()
print(a, b, c)      -- 10  20  30

local x, y = triple()
print(x, y)         -- 10  20  (30 discarded)

local p = triple()
print(p)            -- 10  (only first when 1 var)

Ajuste en una posición intermedia

Cuando una llamada a una función aparece en el medio de una lista de expresiones (no en la última posición), Lua la trunca a un solo valor. Solo la última expresión de la lista puede producir varios valores.

local function pair()
  return 1, 2
end

-- pair() in middle: only 1 value used
local t = {pair(), pair()}
print(#t, t[1], t[2], t[3])  -- 3  1  1  2
-- first pair() gives just 1; last pair() gives 1,2

-- pair() at end: all values used
local t2 = {10, pair()}
print(#t2, t2[1], t2[2], t2[3])  -- 3  10  1  2

Los paréntesis fuerzan un solo valor

Encerrar una llamada a una función entre paréntesis fuerza que devuelva exactamente un valor. Esto resulta útil cuando solo desea el primer valor devuelto, independientemente de cuántos valores produzca la función.

local function coords()
  return 10, 20, 30
end

print(coords())    -- 10  20  30  (all three)
print((coords()))  -- 10  (parentheses: single value only)

local x = (coords())
print(x)           -- 10

Valores devueltos por string.find

Muchas funciones de la biblioteca estándar usan varios valores devueltos. string.find devuelve las posiciones inicial y final de una coincidencia (además de las capturas). math.modf devuelve las partes entera y fraccionaria. Comprender estos patrones le ayudará a usar la biblioteca estándar con soltura.

local s = "hello world"
local start, finish = string.find(s, "world")
print(start, finish)   -- 7  11

-- math.modf: integer and fractional parts
local int, frac = math.modf(3.75)
print(int, frac)       -- 3   0.75

Capturar con table.pack

table.pack(...) captura todos los argumentos (o valores devueltos mediante ...) en una tabla. La tabla incluye un campo n con el recuento total, incluidos los valores nil. Esto conserva el recuento exacto, a diferencia de #, que se detiene en el primer hueco.

local function getData()
  return "Alice", 30, nil, true
end

local t = table.pack(getData())
print(t.n)         -- 4
print(t[1])        -- Alice
print(t[2])        -- 30
print(t[3])        -- nil
print(t[4])        -- true

table.unpack para expandir valores

table.unpack(t, i, j) devuelve los elementos de una tabla como valores individuales. Es la operación inversa de table.pack. Úselo para pasar el contenido de una tabla como argumentos a una función o para expandir valores en una instrucción return.

local args = {10, 20, 30}

local function sum3(a, b, c)
  return a + b + c
end

print(sum3(table.unpack(args)))  -- 60

-- Use in return
local function passThrough(t)
  return table.unpack(t)
end
print(passThrough({5, 6, 7}))   -- 5  6  7

Devoluciones en estilo de error

Una convención habitual de Lua consiste en devolver nil, errorMessage cuando se produce un error y el resultado cuando la operación tiene éxito. El código que realiza la llamada comprueba el primer valor devuelto: si es nil, se produjo un error. Esto evita usar excepciones en los casos de fallo esperados.

local function openConfig(path)
  local f = io.open(path, "r")
  if not f then
    return nil, "cannot open: " .. path
  end
  local content = f:read("*a")
  f:close()
  return content
end

local data, err = openConfig("config.lua")
if not data then
  print("Error:", err)
end

Intercambiar valores con varias devoluciones

Los valores devueltos múltiples resuelven elegantemente el problema del intercambio. El lado derecho se evalúa antes de la asignación, por lo que a, b = b, a intercambia correctamente los valores sin necesidad de una variable temporal.

local a, b = 5, 10
print(a, b)   -- 5  10

a, b = b, a
print(a, b)   -- 10  5

-- Works for three-way rotation too
local x, y, z = 1, 2, 3
x, y, z = z, x, y
print(x, y, z)  -- 3  1  2

Convención de devolución de pcall

pcall(f, ...) también utiliza varios valores devueltos: el primero es un booleano (true si la operación tiene éxito y false si se produce un error), y los valores posteriores son los valores devueltos por f o el mensaje de error. Compruebe siempre la primera devolución antes de usar las demás.

local function risky(x)
  if x < 0 then error("negative input") end
  return math.sqrt(x)
end

local ok, result = pcall(risky, 16)
print(ok, result)   -- true  4.0

ok, result = pcall(risky, -1)
print(ok, result)   -- false  input:2: negative input

Comprobación rápida

¿Qué muestra print((string.find("hello", "ll")))?

Repaso: varios valores devueltos

Conclusiones principales:

Devuelva varios valores: return a, b, c
Los valores adicionales se descartan y los faltantes se convierten en nil
Las llamadas en posiciones intermedias se truncan a 1 valor
(f()) fuerza exactamente 1 valor
table.pack/table.unpack permiten trabajar con listas dinámicas de valores
Convención: devolver nil, errmsg cuando se produce un error

Preguntas frecuentes

¿La lección «Múltiples valores de retorno» es gratis?

Sí — el texto completo de «Múltiples valores de retorno» 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 «Múltiples valores de retorno»?

Devuelva y capture varios valores en una sola llamada a función. 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 «Múltiples valores de retorno»?

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