Strutture di controllo

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

• Una dichiarazione if then else esegue il codice solo se una condizione specificata è true. L'esecuzione del codice non si ripete.
• Un ciclo while esegue il codice solo se una condizione specificata è true, e ripete l'esecuzione finché la condizione rimane true.
• Un ciclo repeat esegue il codice e ripete l'esecuzione se la condizione è true.
• Un ciclo for esegue il codice un numero prestabilito di volte a seconda degli input specificati.

La condizione per le dichiarazioni if, i cicli while e repeat può essere qualsiasi espressione o valore Luau. Se un valore non è false o nil, allora Luau lo valuta come true nelle dichiarazioni condizionali. A differenza di altri linguaggi di scripting, Luau considera sia lo zero che la stringa vuota come true.

Dichiarazioni if

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

Puoi usare una dichiarazione elseif per testare condizioni aggiuntive se la condizione if è falsa. Puoi utilizzare una dichiarazione else per eseguire codice se tutte le condizioni if e elseif falliscono. Le parti elseif e else sono entrambe opzionali, ma non puoi usare nessuna delle due senza una dichiarazione if iniziale.

In una catena di condizioni if, elseif e else, Luau testa le condizioni dall'alto verso il basso, si ferma alla prima condizione true, ed esegue il codice che la segue.

if 2 + 2 == 5 then
	print("Due più due è cinque") -- Non viene stampato perché la condizione è falsa
elseif 2 + 3 == 5 then
	print("Due più tre è cinque") -- Due più tre è cinque
else
	print("Tutte le condizioni sono fallite") -- Non viene stampato perché la condizione precedente è vera
end

Cicli while

Un ciclo while—do valuta se una condizione specificata è vera o falsa. Se la condizione è false o nil, il ciclo termina e Luau salta il codice nel ciclo. Se la condizione è true, Luau esegue il codice nel ciclo e ripete il processo.

local timeRemaining = 10

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

print("Il timer ha raggiunto zero!")
--[[ Output risultante:
Secondi rimanenti: 10
Secondi rimanenti: 9
Secondi rimanenti: 8
Secondi rimanenti: 7
Secondi rimanenti: 6
Secondi rimanenti: 5
Secondi rimanenti: 4
Secondi rimanenti: 3
Secondi rimanenti: 2
Secondi rimanenti: 1
Il timer ha raggiunto zero!
]]

Cicli infiniti

Puoi usare un ciclo while—do per scrivere cicli di gioco infiniti impostando true come condizione.

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

--[[ Output risultante:
In esecuzione...
In esecuzione...
In esecuzione...
In esecuzione...
...
]]

Cicli repeat

Il ciclo repeat—until si ripete fino a quando una condizione è vera. Il test condizionale viene valutato dopo che il blocco di codice è stato eseguito, quindi il blocco di codice viene sempre eseguito almeno una volta. A differenza di altri linguaggi, l'ambito di una variabile locale dichiarata all'interno di un ciclo repeat—until include la condizione.

local currentGoblinCount = 18

-- Genera goblin fino a un massimo di 25 nel gioco
repeat
	spawnGoblin()
	currentGoblinCount += 1
	print("Conteggio attuale dei goblin: " .. currentGoblinCount)
until currentGoblinCount == 25

print("I goblin sono stati ripopolati!")

--[[ Output risultante:
Conteggio attuale dei goblin: 19
Conteggio attuale dei goblin: 20
Conteggio attuale dei goblin: 21
Conteggio attuale dei goblin: 22
Conteggio attuale dei goblin: 23
Conteggio attuale dei goblin: 24
Conteggio attuale dei goblin: 25
I goblin sono stati ripopolati!
]]

Cicli for

Un ciclo for esegue il codice un numero prestabilito di volte, sia basato su un contatore numerico che sul numero di elementi in una collezione.

Cicli for numerici

Un ciclo for—do determina il numero di volte in cui eseguire il ciclo usando un contatore. Il ciclo è dichiarato con un valore di partenza, un valore finale e un incremento opzionale.

Luau imposta il contatore uguale al valore di partenza, esegue il blocco di codice nel ciclo for, quindi aggiunge l'incremento al contatore. Se l'incremento è positivo, il processo si ripete fino a quando il contatore è uguale o maggiore del valore finale. Se l'incremento è negativo, il processo si ripete fino a quando il contatore è uguale o minore del valore finale.

L'incremento opzionale predefinito è 1. Non deve essere necessariamente un numero intero.

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

--[[ Output risultante:
1
2
3
]]

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

--[[ Output risultante:
1
3
5
]]

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

--[[ Output risultante:
2
1.5
1
0.5
0
]]

Cicli for generici

Il ciclo for generico itera sugli elementi di una collezione piuttosto che su una sequenza di numeri. Con i cicli for generici, puoi eseguire codice per ogni elemento nella collezione e puoi facilmente usare ogni elemento nel codice.

I cicli for necessitano di una funzione, o iteratore, per iterare su diversi tipi di collezioni. La funzione globale ipairs() restituisce un iteratore per gli array, e la funzione globale pairs() restituisce un iteratore per i dizionari. La libreria string fornisce string.gmatch() per iterare sulle stringhe.

Iterazione generalizzata

In Luau, puoi iterare su una tabella usando la parola chiave in direttamente sulla tabella, invece di utilizzare una funzione iteratore come ipairs():

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

L'iterazione generalizzata ti consente anche di utilizzare il metametodo __iter per creare una funzione iteratore personalizzata. Questo esempio artificiale itera su un array in ordine inverso, dal suo ultimo elemento al 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

--[[ Output risultante:
5 5
4 4
3 3
2 2
1 1
]]

Array

La funzione ipairs() restituisce un iteratore che itera attraverso gli indici numerici in una tabella e restituisce un index e un value per ciascun elemento. Questo la rende appropriata per gli array, dove tutti gli indici sono numerici.

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

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

Dizionari

La funzione pairs() restituisce un iteratore che itera attraverso tutti gli indici (inclusi gli indici numerici) in una tabella e restituisce una key e un value per ciascun elemento nel dizionario. L'ordine di attraversamento degli elementi in una tabella dizionario è arbitrario. Questo la rende appropriata per l'iterazione sui dizionari, dove gli oggetti sono memorizzati fuori ordine con indici non numerici.

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

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

Interrompere cicli

Per forzare la fine di un ciclo, usa la parola chiave break. Il seguente esempio di codice mostra come interrompere un ciclo while—do infinito.

local secondsElapsed = 0
local timeout = 5

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

	if secondsElapsed == timeout then
		break
	end
end

print("Cinque secondi trascorsi. È tempo di andare avanti!")

--[[ Output risultante:
1
2
3
4
5
Cinque secondi trascorsi. È tempo di andare avanti!
]]

Continuare cicli

Per forzare un ciclo a iterare e ricominciare, usa la parola chiave continue. Un ciclo for itererà il contatore; while e repeat—until controlleranno la condizione del ciclo prima di continuare. Il seguente esempio di codice ottiene tutti i figli di un Instance di un specifico 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 il ciclo
		table.insert(children, child)
	end

	return children
end