Estruturas de controle

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

• Uma declaração se então outra executa código somente se uma condição especificada for true. A execução do código não se repete.
• Um ciclo while executa código somente se uma condição especificada for , e repete a execução enquanto a condição permanece .
• Um ciclo de repetição repete o código e repete a execução se a condição for true.
• Um para loop executa código um número definido de vezes dependendo de entradas especificadas.

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

Se declarações

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 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 peças elseif e else são ambas opcionais, mas você não pode usar nenhuma delas sem uma declaração inicial if .

Em uma cadeia de if , elseif e else condições, Luau testa as condições de cima para baixo, para para na primeira condição true e executa o código que a 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

Enquanto loops

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

local timeRemaining = 10

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

print("Timer reached zero!")
--[[ saídaresultante:
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 ciclo while — do para escrever ciclos de jogo infinitos definindo true como a condição.

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

--[[ saídaresultante:
Looping...
Looping...
Looping...
Looping...
...
]]

Repetir ciclos

O ciclo repeat — until repete até que uma condição seja verdadeira.O teste condicional avalia depois de o bloco de código executar, então o bloco de código sempre é executado pelo menos uma vez.Ao contrário de outros idiomas, o escopo Luau de uma variável local declarada dentro de um repeat - until loop inclui a condição.

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!")

--[[ saídaresultante:
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

Um ciclo for executa código um número definido de vezes, baseado em um contador numérico ou no número de itens em uma coleção .

Numeric para loops

Um ciclo for — do determina o número de vezes para executar o ciclo usando um contra-oferta.O loop é declarado com um valor de início, valor de fim e incremento opcional.

Luau define o contador igual ao valor de início, executa o bloco de código no loop for e, em seguida, adiciona o incremento ao contra-oferta.Se o incremento for positivo, o processo se repetirá até que o contador seja igual ou maior que o valor final.Se o incremento for negativo, o processo se repetirá até que o contador seja igual ou menor que o valor final.

O incremento opcional padrão para 1 . Não precisa ser um número inteiro.

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

--[[ saídaresultante:
1
2
3
]]

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

--[[ saídaresultante:
1
3
5
]]

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

--[[ saídaresultante:
2
1.5
1
0.5
0
]]

Genérico para loops

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

Para loops precisam de uma função ou iterador para iterar 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 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 de iteração, 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 __iter metamétodo para criar uma função de iteração personalizada.Este exemplo contornado itera sobre um array em ordem inversa, 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

--[[ saídaresultante:
5 5
4 4
3 3
2 2
1 1
]]

Arranjos

A função ipairs() retorna um iterador que itera através de índices numéricos em uma tabela e retorna um index e value para cada elemento.Isso torna apropriado para arrays, onde todos os índices são numericamente.

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

--[[ saídaresultante:
1 a
2 b
3 c
4 d
5 e
]]

Dicionários

A função pairs() retorna um iterador que itera todos os índices (incluindo índices numéricos) em uma tabela e retorna um key e value para cada entrada no dicionário.A ordem de percorrer elementos em uma tabela dicionária é arbitrária.Isso torna apropriado para iterar sobre dicionários, onde os itens são armazenados fora de ordem com índices não 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

--[[ saídaresultante:
Hello b
true d
false e
World f
5 c
1 a
]]

Quebrar loops

Para forçar um ciclo a terminar/parar/sair, use a palavra-chave break. O seguinte exemplo de código mostra como quebrar um ciclo 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!")

--[[ saídaresultante:
1
2
3
4
5
Five seconds elapsed. Time to move on!
]]

Continuar loops

Para forçar um ciclo a iterar e começar de novo, use a palavra-chave continue.Um ciclo for 循环 iterará o contra-oferta; while e repeat — until verificará a condição do ciclo antes de continuar.O seguinte exemplo de código obtém todas as crianças de um Instance de um 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 o ciclo
		table.insert(children, child)
	end

	return children
end