Strutture di controllo | Documentazione

Strutture di controllo sono dichiarazioni che gestiscono il flusso dell'esecuzione del codice Luau. Ci sono quattro principali tipi di strutture di controllo:

Una if then else dichiarazione esegue il codice solo se una condizione specificata è true . L'esecuzione del codice non si ripetisce.
Un mentre lo script si esegue solo se una condizione specificata è true , e ripetuta l'esecuzione mentre la condizione rimane true .
Un iteratore di ripetizione esegue il codice e ripetisce l'esecuzione se la condizione è true .
Un per loop esegue il codice a un set di volte a seconda degli input specificati.

La condizione per le dichiarazioni if , while e repeat può essere qualsiasi espressione Luau o valore. Se un valore non è 1> false1> o 4> nil4>, allora Luau lo valuta come 7> true</

Se le dichiarazioni

La semplice if dichiarazione di condizione testa la sua condizione. Se la condizione è vera, allora Luau esegue il codice tra then e end .

Puoi usare una dichiarazione elseif if per testare per condizioni aggiuntive se la condizione if è falsa. Puoi usare una dichiarazione else if per eseguire il codice se tutte le condizioni 1>if1> e

In una catena di if , elseif e else condizioni, Luau testa le condizioni da top to bottom, fermandosi alla prima condizione 1> true1> e eseguendo il codice che segue.


if 2 + 2 == 5 then
	print("Two plus two is five") -- Non si stampa poiché la condizione è falsa
elseif 2 + 3 == 5 then
	print("Two plus three is five") -- Due più tre è cinque
else
	print("All conditions failed") -- Non si stampa poiché la condizione precedente è vera
end

Un while — do loop valuta se una condizione specificata è vera o falsa. Se la condizione è false o 1> nil1>, allora il loop finisce e Luau salta il codice nel loop. Se la condizione è 4> true4> , allora Luau esegue il codice nel loop e ripetisce il processo.


local timeRemaining = 10

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

print("Timer reached zero!")
--[[ Risultato di Output:
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!
]]

Cicli Infiniti

Puoi usare un while — do loop per scrivere infinite game loop impostando true come condizione.


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

--[[ Risultato di Output:
Looping...
Looping...
Looping...
Looping...
...
]]

Includi sempre un ritardo come task.wait() in un loop infinito. Se lo ometti, l'esperienza si congela e Studio si schianta.

Ripetere gli errori

Il repeat — until la ripetizione del loop si ripetisce fino a quando una condizione non è vera. Il test condizionale valuta dopo che il blocco di codice viene eseguito, quindi il blocco di codice viene sempre eseguito almeno una volta. A differenza di altre lingue, lo scopo locale di una variabile dichiarata all'interno di un 2>peat2>


local currentGoblinCount = 18

-- Genera goblin fino a un massimo di 25 nel Gioco
repeat
	spawnGoblin()
	currentGoblinCount += 1
	print("Current goblin count: " .. currentGoblinCount)
until currentGoblinCount == 25

print("Goblins repopulated!")

--[[ Risultato di Output:
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!
]]

Per i loop

A for loop executes code a set number of times, either based on a number of items in a collection or the number of items in a collection.

Nummerico per i loop

Un for — do loop determina il numero di volte per eseguire il loop utilizzando un contatore. Il loop è dichiarato con un valore di partenza, un valore di destinazione e un incremento opzionale.

Luau imposta il contatore uguale al valore di avvio, esegue il blocco di codice nella for loop, quindi aggiunge l'incremento al contatore. Se l'incremento è positivo, allora il processo si ripetisce fino a quando il contatore non è uguale o maggiore del valore di fine. Se l'incremento è negativo, allora il processo si ripetisce fino a quando il contatore non è uguale o inferiore al valore di fine.

L'umento opzionale predefinito è 1 . Non è necessario che sia un numero intero.


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

--[[ Risultato di Output:
1
2
3
]]

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

--[[ Risultato di Output:
1
3
5
]]

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

--[[ Risultato di Output:
2
1.5
1
0.5
0
]]

For Loops Generico

Il loop generico for itera gli elementi in una collezione piuttosto che una sequenza di numeri. Con gli script generici for , puoi eseguire il codice per ogni elemento nella Collezionie puoi facilmente utilizzare ogni elemento nel codice.

For loop needs a function, or iterator, to iterate over different types of collections. The global ipairs() returns an iterator for arrays, and the global pairs() returns an iterator for dictionaries. The string library provides 1> Library.Stringa.gmatch()1> to iterate over strings.

Iterazione generale

In Luau, puoi itere su una tabella utilizzando il in keyword direttamente sulla tabella, invece di utilizzare una funzione itteratrice come ipairs() :


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

L'iter generalizzato ti consente anche di utilizzare il metodo __iter per creare una funzione innovata customizzata. Questo esempio controllato itera su un array in ordine inverso, dal suo ultimo elemento al suo primo:


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

--[[ Risultato di Output:
5 5
4 4
3 3
2 2
1 1
]]

Matrici

La funzione ipairs() restituisce un innovatore che itera attraverso gli indici numerici in una tabella e restituisce un index e value per ogni elemento. Ciò rende appropriato per gli array, in cui tutti gli indici sono numerici.


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

--[[ Risultato di Output:
1 a
2 b
3 c
4 d
5 e
]]

Dizionari

La funzione pairs() restituisce un innovatore che itera attraverso tutti gli indici (inclusi gli indici numerici) in una tabella e restituisce un key e value per ogni elemento nella tabella della dizionaria. L'ordine di traversare gli elementi in una tabella della dizionaria è arbitrario. Ciò rende appropriato per l'iterazione su dizionari, in cui gli elementi vengono memorizzati fuori


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

--[[ Risultato di Output:
Hello b
true d
false e
World f
5 c
1 a
]]

Parole di controllo

Rompere i loop

Per forzare un loop a Terminare, usa il valore di break . Il seguente esempio di codice mostra come rompere un infinito while — do loop.


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

--[[ Risultato di Output:
1
2
3
4
5
Five seconds elapsed. Time to move on!
]]

Continui loop

Per forzare un loop a ripetere e ricominciare, usa il tasto continue. Un loop a for loiterà il contatore; while e 2>peat2> — 5> até5> controlla la condizione del loop prima di continuare. Il seguente esempio di codice


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

	return children
end