Estruturas de controle | Documentação - Central de Criadores Roblox

Estruturas de controle são declarações que gerenciam o fluxo de execução do código Luau. Existem quatro tipos principais de estruturas de controle:

Uma declaração if then else executa o código apenas se uma condição especificada for true. A execução do código não se repete.
Um while loop executa o código apenas se uma condição especificada for true e repete a execução enquanto a condição permanecem true.
Um repeat loop executa o código e repete a execução se a condição for true.
Um for loop executa o código um número fixo de vezes, dependendo de entradas específicas.

A condição para declarações if, while loops e repeat loops pode ser qualquer expressão ou valor Luau. Se um valor não for false ou nil, então Luau o avalia como true em declarações condicionais. Ao contrário de outras linguagens de script, Luau considera tanto zero quanto a string vazia como true.

Declarações if

A declaração básica if testa sua condição. Se a condição for verdadeira, então Luau executa o código entre then e end.

Você pode usar uma declaração elseif para testar condições adicionais se a condição if for falsa. Você pode usar uma declaração else para executar código se todas as condições if e elseif falharem. As partes elseif e else são ambas opcionais, mas você não pode usar nenhuma delas sem uma declaração if inicial.

Em uma cadeia de condições if, elseif e else, Luau testa as condições de cima para baixo, para ao primeiro condição true e executa o código que se segue.


if 2 + 2 == 5 then
	print("Dois mais dois é cinco") -- Não imprime porque a condição é falsa
elseif 2 + 3 == 5 then
	print("Dois mais três é cinco") -- Dois mais três é cinco
else
	print("Todas as condições falharam") -- Não imprime porque a condição anterior é verdadeira
end

While loops

Um loop while—do avalia se uma condição especificada é verdadeira ou falsa. Se a condição for false ou nil, então o loop termina e Luau ignora o código no loop. Se a condição for true, então Luau executa o código no loop e repete o processo.


local tempoRestante = 10

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

print("O cronômetro chegou a zero!")
--[[ Resultado:
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
O cronômetro chegou a zero!
]]

Loops infinitos

Você pode usar um loop while—do para escrever loops de jogo infinitos definindo true como a condição.


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

--[[ Resultado:
Loopando...
Loopando...
Loopando...
Loopando...
...
]]

Sempre inclua um atraso como task.wait() em um loop infinito. Omiti-lo congela o jogo e trava o Studio.

Repeat loops

O loop repeat—until repete até que uma condição seja verdadeira. O teste condicional avalia após o bloco de código ser executado, então o bloco de código sempre executa pelo menos uma vez. Ao contrário de outras linguagens, o escopo de uma variável local declarada dentro de um loop repeat—until inclui a condição.


local contagemAtualGoblin = 18

-- Spawn goblins até um máximo de 25 no jogo
repeat
	spawnGoblin()
	contagemAtualGoblin += 1
	print("Contagem atual de goblins: " .. contagemAtualGoblin)
until contagemAtualGoblin == 25

print("Goblins repopulados!")

--[[ Resultado:
Contagem atual de goblins: 19
Contagem atual de goblins: 20
Contagem atual de goblins: 21
Contagem atual de goblins: 22
Contagem atual de goblins: 23
Contagem atual de goblins: 24
Contagem atual de goblins: 25
Goblins repopulados!
]]

For loops

Um for loop executa o código um número fixo de vezes, seja com base em um contador numérico ou no número de itens em uma coleção.

For loops numéricos

Um loop for—do determina o número de vezes que o loop executa usando um contador. O loop é declarado com um valor inicial, um valor final e um incremento opcional.

Luau define o contador igual ao valor inicial, executa o bloco de código no loop for e, em seguida, adiciona o incremento ao contador. Se o incremento for positivo, o processo se repete até o contador ser igual ou maior que o valor final. Se o incremento for negativo, o processo se repete até o contador ser igual ou menor que o valor final.

O incremento opcional é 1 por padrão. Ele não precisa ser um número inteiro.


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

--[[ Resultado:
1
2
3
]]

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

--[[ Resultado:
1
3
5
]]

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

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

For loops genéricos

O loop for genérico itera sobre itens em uma coleção em vez de uma sequência de números. Com loops for genéricos, você pode executar código para cada item na coleção e pode usar facilmente cada item no código.

Loops for precisam de uma função ou iterador para iterar sobre diferentes tipos de coleções. A função global ipairs() retorna um iterador para arrays e a função global pairs() retorna um iterador para dicionários. A biblioteca string fornece string.gmatch() para iterar sobre strings.

Iteração generalizada

Em Luau, você pode iterar sobre uma tabela usando a palavra-chave in diretamente na tabela, em vez de usar uma função iteradora como ipairs():


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

A iteração generalizada também permite que você use o metamétodo __iter para criar uma função iteradora personalizada. Este exemplo elaborado itera sobre um array na ordem inversa, do seu último elemento para o primeiro:


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

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

		return function()
			i -= 1

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

setmetatable(minhaTabela, meuMetatabela)

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

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

Arrays

A função ipairs() retorna um iterador que itera pelos índices numéricos em uma tabela e retorna um índice e um valor para cada elemento. Isso a torna apropriada para arrays, onde todos os índices são numéricos.


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

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

Dicionários

A função pairs() retorna um iterador que itera por todos os índices (incluindo índices numéricos) em uma tabela e retorna uma chave e um valor para cada entrada no dicionário. A ordem de tráfego dos elementos em uma tabela de dicionários é arbitrária. Isso a torna apropriada para iterar sobre dicionários, onde os itens são armazenados fora de ordem com índices não numéricos.


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

--[[ Resultado:
Olá b
true d
false e
Mundo f
5 c
1 a
]]

Quebrar loops

Para forçar um loop a terminar, use a palavra-chave break. O seguinte exemplo de código mostra como quebrar um loop while—do infinito.


local segundosDecorridos = 0
local timeout = 5

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

	if segundosDecorridos == timeout then
		break
	end
end

print("Cinco segundos decorridos. Hora de seguir em frente!")

--[[ Resultado:
1
2
3
4
5
Cinco segundos decorridos. Hora de seguir em frente!
]]

Continuar loops

Para forçar um loop a iterar e começar novamente, use a palavra-chave continue. Um loop for irá iterar o contador; while e repeat—until irão verificar a condição do loop antes de continuar. O seguinte exemplo de código obtém todos os filhos de uma Instance de uma ClassName específica.


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

	return children
end