Estructuras de control | Documentación del Centro de creación de Roblox

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

Una declaración si luego de otra ejecuta código solo si una condición especificada es true . La ejecución del código no se repite.
Un bucle while ejecuta código solo si una condición especificada es , y repite la ejecución mientras la condición siga siendo .
Un bucle de repetición repite el código y repite la ejecución si la condición es true.
Un para bucle ejecuta código una cantidad determinada de veces dependiendo de las entradas especificadas.

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

Si declaraciones

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 ambas opcionales, pero no puedes usar ninguna sin una declaración inicial if .

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


if 2 + 2 == 5 then
	print("Two plus two is five") -- No imprime porque la condición es falsa
elseif 2 + 3 == 5 then
	print("Two plus three is five") -- Dos más tres es cinco
else
	print("All conditions failed") -- No imprime porque la condición anterior es verdadera
end

Mientras bucles

Un bucle while — do evalúa si una condición especificada es verdadera o falsa.Si la condición es false o nil , entonces se termina el bucle y Luau omite 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 timeRemaining = 10

while timeRemaining > 0 do
	print("Seconds remaining: " .. timeRemaining)
	task.wait(1)
	timeRemaining -= 1
end

print("Timer reached zero!")
--[[ Resultado de Salida:
Seconds remaining: 10
Seconds remaining: 9
Seconds remaining: 8
Seconds remaining: 7
Seconds remaining: 6
Seconds remaining: 5
Seconds remaining: 4
Seconds remaining: 3
Seconds remaining: 2
Seconds remaining: 1
Timer reached zero!
]]

Bucles infinitos

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


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

--[[ Resultado de Salida:
Looping...
Looping...
Looping...
Looping...
...
]]

Siempre incluya un retraso como task.wait() en un bucle infinito. Omitirlo congela la experiencia y bloquea Studio.

Repetir bucles

El bucle repeat — until se repite hasta que una condición sea verdadera.La prueba condicional 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 idiomas, el alcance Luau de una variable local declarada dentro de un repeat - until bucle incluye la condición.


local currentGoblinCount = 18

-- Genera duendes hasta un máximo de 25 en el juego
repeat
	spawnGoblin()
	currentGoblinCount += 1
	print("Current goblin count: " .. currentGoblinCount)
until currentGoblinCount == 25

print("Goblins repopulated!")

--[[ Resultado de Salida:
Current goblin count: 19
Current goblin count: 20
Current goblin count: 21
Current goblin count: 22
Current goblin count: 23
Current goblin count: 24
Current goblin count: 25
Goblins repopulated!
]]

Para bucles

Un bucle A 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 .

Numérico para bucles

Un bucle for — do determina el número de veces para ejecutar el bucle usando un contraoferta.El bucle se declara con un valor de inicio, un valor de final y un incremento opcional.

Luau establece el contador igual al valor de inicio, ejecuta el bloque de código en el bucle for y luego agrega el contraofertaal contador.Si el incremento es positivo, el proceso se repite hasta que el contador sea igual o mayor al 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 se establece por defecto en 1. No necesita ser un número entero.


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

--[[ Resultado de Salida:
1
2
3
]]

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

--[[ Resultado de Salida:
1
3
5
]]

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

--[[ Resultado de Salida:
2
1.5
1
0.5
0
]]

Genérico para bucles

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

Para los bucles se necesita una función o iterador para iterar sobre diferentes tipos de colecciones.El global ipairs() devuelve un iterador para arrays, 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 sobre 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 método __iter metamétodo para crear una función de iterador personalizado.Este ejemplo forzado itera sobre un array en orden inverso, desde su último elemento a su primer:


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

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

		return function()
			i -= 1

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

setmetatable(myTable, myMetatable)

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

--[[ Resultado de Salida:
5 5
4 4
3 3
2 2
1 1
]]

Arreglos

La función ipairs() devuelve un iterador que recorre los índices numéricos en una tabla y devuelve un index y value para cada elemento.Esto lo hace apropiado para los arrays, donde todos los índices son numéricos.


local array = {"a", "b", "c", "d", "e"}
for index, value in ipairs(array) do
	print(index, value)
end

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

Diccionarios

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


local dictionary = {
	[1] = "a",
	["Hello"] = "b",
	[5] = "c",
	[true] = "d",
	["World"] = "f",
	[false] = "e"
}
for key, value in pairs(dictionary) do
	print(key, value)
end

--[[ Resultado de Salida:
Hello b
true d
false e
World f
5 c
1 a
]]

Romper bucles

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


local secondsElapsed = 0
local timeout = 5

while true do
	task.wait(1)
	secondsElapsed += 1
	print("Seconds elapsed:", secondsElapsed)

	if secondsElapsed == timeout then
		break
	end
end

print("Five seconds elapsed. Time to move on!")

--[[ Resultado de Salida:
1
2
3
4
5
Five seconds elapsed. Time to move on!
]]

Continuar los bucles

Para forzar a un bucle a iterar y comenzar de nuevo, use la palabra clave continue.Un bucle for itera el contraoferta; while y repeat — until comprobará la condición del bucle antes de continuar.El siguiente ejemplo de código obtiene todos los hijos de un Instance de un específico ClassName.


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

	return children
end