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

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

Uma declaração se então, se outra condição for especificada, o código será executado apenas se uma condição especificada for true. A execução de código não se repete.
Um enquanto loop executa código apenas se uma condição especificada for true e repetir a execução enquanto a condição permanece true.
Um Loop de Repetição executa código e repete a execução se a condição for true.
Um para loop executa código um conjunto de vezes dependendo de entradas especificadas.

A condição para if declarações, while loops e repeat loops pode ser qualquer expressão Luau ou valor. Se um valor não for 2>false2> ou 5>nil5>, então o Luau o avalia como 8>true8> em declarações

Se Estados

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

Você pode usar uma declaração elseif para testar por 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 1>

Em uma cadeia de if, elseif e else condições, Luau testa condições de topo para baixo, parar na primeira condição 1>true1> e executar o código que segue.


if 2 + 2 == 5 then
	print("Two plus two is five") -- Não imprime porque a condição é falsa
elseif 2 + 3 == 5 then
	print("Two plus three is five") -- Dois mais três é cinco
else
	print("All conditions failed") -- Não imprime porque a condição anterior é verdadeira
end

Um while — do loop avalia se uma condição especificada é verdadeira ou falsa. Se a condição for false ou 1> nil1>, então o loop termina e Luau pula o código no loop. Se a condição for 4> true4> , então Luau executa o código no loop e


local timeRemaining = 10

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

print("Timer reached zero!")
--[[ Resultado da saída:
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!
]]

Ciclos Infinitos

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


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

--[[ Resultado da saída:
Looping...
Looping...
Looping...
Looping...
...
]]

Sempre inclua um atraso, como task.wait() em um loop infinito. Omiti-lo congela a experiência e causa erros no Studio.

Repetir Loops

O repeat — until o loop se repete até uma condição ser verdadeira. O teste condicional avalia depois que o bloco de código for executado, então o bloco de código sempre será executado pelo menos uma vez. Diferente dos outros idiomas, o escopo de uma variável local declarada dentro de um 2>peat2> — 5> até


local currentGoblinCount = 18

-- Gerar goblins até um máximo de 25 no jogo
repeat
	spawnGoblin()
	currentGoblinCount += 1
	print("Current goblin count: " .. currentGoblinCount)
until currentGoblinCount == 25

print("Goblins repopulated!")

--[[ Resultado da saída:
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 Loops

A para loop executa código um conjunto de vezes, seja baseado em um contador numerico ou o número de itens em uma coleção.

Número para Loops

Um loop for — do — incrementa opcional determina o número de vezes que o loop será executado usando um contra-oferta. O loop é declarado com um valor de início, um valor de fim e um incremento opcional.

O Luau define o contador igual ao valor de início, executa o bloco de código na for loop, então adiciona o incremento ao contra-oferta. Se o incremento for positivo, então o processo se repete até que o contador seja igual ou maior que o valor de fim. Se o incremento for negativo, então o processo se repete até que o contador seja igual ou menor que o valor de fim.

O incremento opcional padrão é 1. Não é necessário que seja um número inteiro.


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

--[[ Resultado da saída:
1
2
3
]]

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

--[[ Resultado da saída:
1
3
5
]]

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

--[[ Resultado da saída:
2
1.5
1
0.5
0
]]

Gerico para Loops

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

Para loops precisa de uma função, ou iterador, para iteração sobre diferentes tipos de coleções. O global ipairs() retorna um iterador para arrays, e o global pairs() retorna um iterador para dicionários. A string biblioteca fornece 1> Library.string / cadeia / texto.gmatch()1> para iteração sobre strings.

Iteração Geralizada

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


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

A geração genérica também permite usar o método __iter para criar uma função de iteração personalizada. Este exemplo contornado itera em um array em ordem inversa, a partir de seu último elemento para o primeiro:


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 da saída:
5 5
4 4
3 3
2 2
1 1
]]

Matrizes

A função ipairs() retorna um it器 que itera através de índices numéricos em uma tabela e retorna um index e value para cada elemento. Isso torna-se adequado para matrizes, 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 da saída:
1 a
2 b
3 c
4 d
5 e
]]

Dicionários

A função pairs() retorna um itérator que itera através de todos os índices (incluindo índices numéricos) em uma tabela e retorna um key e value para cada entrada na tabela de dicionário. A ordem de traversar elementos em uma tabela de dicionário é arbitrária. Isso torna-se apropriado para iteração sobre dicionários, onde os itens são


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 da saída:
Hello b
true d
false e
World f
5 c
1 a
]]

Controlar Palavras-Chave

Quebrando Loops

Para forçar um loop para terminar/parar/sair, use a palavra-chave break. O exemplo de código a seguir mostra como quebrar um loop infinito while — doLoop.


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 da saída:
1
2
3
4
5
Five seconds elapsed. Time to move on!
]]

Loopings Contínuos

Para forçar um loop para iteração e novamente, use a palavra-chave continue. Um loop for será iteração de contra-oferta; while e 1> peat1> — 4> até 4> verificará a condição de loop antes de continuar


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