Estructuras de control

Estructuras de control son declaraciones que gestionan el flujo de ejecución del código Luau. Hay cuatro tipos principales de estructuras de control:

• Una declaración de if then else ejecuta código solo si una condición específica es true. La ejecución del código no se repite.
• Un bucle while ejecuta código solo si una condición específica es true, y repite la ejecución mientras la condición siga siendo true.
• Un bucle repeat ejecuta código, y repite la ejecución si la condición es true.
• Un bucle for ejecuta código un número determinado de veces dependiendo de las entradas especificadas.

La condición para las declaraciones if, los bucles while y los bucles repeat puede ser cualquier expresión o valor de Luau. Si un valor no es false o nil, entonces Luau lo evalúa como true en declaraciones condicionales. A diferencia de otros lenguajes de script, Luau considera tanto el cero como la cadena vacía como true.

Declaraciones if

La declaración básica if prueba su condición. Si la condición es verdadera, entonces Luau ejecuta el código entre then y end.

Puedes usar una declaración elseif para probar condiciones adicionales si la condición if es falsa. Puedes usar una declaración else para ejecutar código si todas las condiciones if y elseif fallan. Las partes elseif y else son opcionales, pero no puedes usar ninguna de ellas sin una declaración inicial if.

En una cadena de condiciones if, elseif y else, Luau prueba las condiciones de arriba hacia abajo, se detiene en la primera condición true, y ejecuta el código que le sigue.

if 2 + 2 == 5 then
	print("Dos más dos es cinco") -- No se imprime porque la condición es falsa
elseif 2 + 3 == 5 then
	print("Dos más tres es cinco") -- Dos más tres es cinco
else
	print("Todas las condiciones fallaron") -- No se imprime porque la condición anterior es verdadera
end

Bucles while

Un bucle while—do evalúa si una condición específica es verdadera o falsa. Si la condición es false o nil, entonces el bucle termina, y Luau salta el código en el bucle. Si la condición es true, entonces Luau ejecuta el código en el bucle y repite el proceso.

local tiempoRestante = 10

while tiempoRestante > 0 do
	print("Segundos restantes: " .. tiempoRestante)
	task.wait(1)
	tiempoRestante -= 1
end

print("¡El temporizador llegó a cero!")
--[[ Salida resultante:
Segundos restantes: 10
Segundos restantes: 9
Segundos restantes: 8
Segundos restantes: 7
Segundos restantes: 6
Segundos restantes: 5
Segundos restantes: 4
Segundos restantes: 3
Segundos restantes: 2
Segundos restantes: 1
¡El temporizador llegó a cero!
]]

Bucles infinitos

Puedes usar un bucle while—do para escribir bucles de juego infinitos estableciendo true como condición.

while true do
	print("Bucle...")
	task.wait(0.5)
end

--[[ Salida resultante:
Bucle...
Bucle...
Bucle...
Bucle...
...
]]

Bucles repeat

El bucle repeat—until repite hasta que una condición sea verdadera. La prueba condicional se evalúa después de que se ejecute el bloque de código, por lo que el bloque de código siempre se ejecuta al menos una vez. A diferencia de otros lenguajes, el alcance de una variable local declarada dentro de un bucle repeat—until incluye la condición.

local conteoActualDeDuendes = 18

-- Generar duendes hasta un máximo de 25 en el juego
repeat
	spawnGoblin()
	conteoActualDeDuendes += 1
	print("Conteo actual de duendes: " .. conteoActualDeDuendes)
until conteoActualDeDuendes == 25

print("¡Duendes repoblados!")

--[[ Salida resultante:
Conteo actual de duendes: 19
Conteo actual de duendes: 20
Conteo actual de duendes: 21
Conteo actual de duendes: 22
Conteo actual de duendes: 23
Conteo actual de duendes: 24
Conteo actual de duendes: 25
¡Duendes repoblados!
]]

Bucles for

Un bucle for ejecuta código un número determinado de veces, ya sea basado en un contador numérico o en el número de elementos en una colección.

Bucles for numéricos

Un bucle for—do determina el número de veces que se ejecutará el bucle utilizando un contador. El bucle se declara con un valor de inicio, un valor final y un incremento opcional.

Luau establece el contador igual al valor de inicio, ejecuta el bloque de código en el bucle for, luego agrega el incremento al contador. Si el incremento es positivo, el proceso se repite hasta que el contador sea igual o mayor que el valor final. Si el incremento es negativo, el proceso se repite hasta que el contador sea igual o menor que el valor final.

El incremento opcional tiene como valor predeterminado 1. No tiene que ser un número entero.

for contador = 1, 3 do
	print(contador)
end

--[[ Salida resultante:
1
2
3
]]

for contador = 1, 6, 2 do
	print(contador)
end

--[[ Salida resultante:
1
3
5
]]

for contador = 2, 0, -0.5 do
	print(contador)
end

--[[ Salida resultante:
2
1.5
1
0.5
0
]]

Bucles for genéricos

El bucle for genérico itera sobre elementos en una colección en lugar de una secuencia de números. Con los bucles for genéricos, puedes ejecutar código para cada elemento en la colección, y puedes usar fácilmente cada elemento en el código.

Los bucles for necesitan una función o un iterador para iterar sobre diferentes tipos de colecciones. El global ipairs() devuelve un iterador para arreglos, y el global pairs() devuelve un iterador para diccionarios. La biblioteca string proporciona string.gmatch() para iterar sobre cadenas.

Iteración generalizada

En Luau, puedes iterar sobre una tabla usando la palabra clave in directamente en la tabla, en lugar de usar una función iteradora como ipairs():

for i, v in {1, 2, 3, 4, 5} do
	print(i, v)
end

La iteración generalizada también te permite usar el metamétodo __iter para crear una función iteradora personalizada. Este ejemplo artificial itera sobre un arreglo en orden inverso, desde su último elemento hasta el primero:

local miTabla = {1, 2, 3, 4, 5}

miMetatable = {
	__iter = function(t)
		local i = #t + 1

		return function()
			i -= 1

			if i > 0 then
				return i, t[i]
			end
		end
	end,
}

setmetatable(miTabla, miMetatable)

for i, v in miTabla do
	print(i, v)
end

--[[ Salida resultante:
5 5
4 4
3 3
2 2
1 1
]]

Arreglos

La función ipairs() devuelve un iterador que itera a través de índices numéricos en una tabla y devuelve un índice y un valor para cada elemento. Esto lo hace apropiado para arreglos, donde todos los índices son numéricos.

local arreglo = {"a", "b", "c", "d", "e"}
for indice, valor in ipairs(arreglo) do
	print(indice, valor)
end

--[[ Salida resultante:
1 a
2 b
3 c
4 d
5 e
]]

Diccionarios

La función pairs() devuelve un iterador que itera a través de todos los índices (incluyendo índices numéricos) en una tabla y devuelve una clave y un valor para cada entrada en el diccionario. El orden al recorrer los elementos en una tabla de diccionarios es arbitrario. Esto lo hace apropiado para iterar sobre diccionarios, donde los elementos se almacenan fuera de orden con índices no numéricos.

local diccionario = {
	[1] = "a",
	["Hola"] = "b",
	[5] = "c",
	[true] = "d",
	["Mundo"] = "f",
	[false] = "e"
}
for clave, valor in pairs(diccionario) do
	print(clave, valor)
end

--[[ Salida resultante:
Hola b
true d
false e
Mundo f
5 c
1 a
]]

Romper bucles

Para forzar que un bucle termine, usa la palabra clave break. El siguiente ejemplo de código muestra cómo romper un bucle while—do infinito.

local segundosTranscurridos = 0
local tiempoAgotado = 5

while true do
	task.wait(1)
	segundosTranscurridos += 1
	print("Segundos transcurridos:", segundosTranscurridos)

	if segundosTranscurridos == tiempoAgotado then
		break
	end
end

print("Cinco segundos transcurridos. ¡Es hora de seguir adelante!")

--[[ Salida resultante:
1
2
3
4
5
Cinco segundos transcurridos. ¡Es hora de seguir adelante!
]]

Continuar bucles

Para forzar que un bucle itere y comience de nuevo, usa la palabra clave continue. Un bucle for iterará el contador; while y repeat—until verificarán la condición del bucle antes de continuar. El siguiente ejemplo de código obtiene todos los hijos de una Instance de un ClassName específico.

local function ObtenerHijosDeClase(parent: Instance, className: string): {Instance}
	local hijos = {}
	for _, hijo in parent:GetChildren() do
		if hijo.ClassName ~= className then continue end  -- Itera el bucle
		table.insert(hijos, hijo)
	end

	return hijos
end