Strutture di controllo

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

Un'if poi else dichiarazione esegue il codice solo se una condizione specificata è true . L'esecuzione del codice non si ripete.
Un ciclo while mentre esegue il codice solo se una condizione specificata è e ripete l'esecuzione mentre la condizione rimane .
Un ciclo di ripetizione ripete il codice e ripete l'esecuzione se la condizione è true.
Un per ciclo esegue il codice un certo numero di volte a seconda degli input specificati.

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

Se dichiarazioni

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 usare una dichiarazione else per eseguire il 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 iniziale if.

In una catena di if , elseif e else condizioni, Luau testa le condizioni da top a bottom, si ferma alla prima condizione true e esegue il codice che la segue.


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

Mentre i loop

Un ciclo A while — do valuta se una condizione specificata è vera o falsa.Se la condizione è false o nil , allora 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("Seconds remaining: " .. timeRemaining)
	task.wait(1)
	timeRemaining -= 1
end

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

Loop infiniti

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


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

--[[ Output risultante:
Looping...
Looping...
Looping...
Looping...
...
]]

Includi sempre un ritardo come task.wait() in un ciclo infinito. Ometterlo congela l'esperienza e blocca Studio.

Ripeti i loop

Il ciclo repeat — until si ripete fino a quando una condizione è 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, la scala Luau di una variabile locale dichiarata all'interno di un repeat - until ciclo include la condizione.


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

--[[ Output risultante:
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 cicli

Un ciclo A esegue il codice un certo numero di volte, basato su un contapassi numerico o sul numero di oggetti in una collezione .

Numero per i loop

Un ciclo for — do determina il numero di volte in cui eseguire il ciclo utilizzando un contatore.Il ciclo viene dichiarato con un valore di inizio, un valore di fine e un incremento opzionale.

Luau imposta il contatore uguale al valore di inizio, 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 al valore finale.Se l'incremento è negativo, il processo si ripete fino a quando il contatore è uguale o inferiore al valore finale.

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


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
]]

Generico per i loop

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

Per i cicli è necessaria una funzione o iteratore per iterare su diversi tipi di raccolte.Il globale ipairs() restituisce un iteratore per gli array e il 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 utilizzando la parola chiave in direttamente sulla tabella, invece di utilizzare una funzione iteratrice come ipairs() :


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

L'iterazione generalizzata ti consente inoltre di utilizzare il metodo __iter metametodo per creare una funzione iteratore personalizzata.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

--[[ 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 value per ogni elemento.Questo 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

--[[ 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 un key e value per ciascuna entry nel dizionario.L'ordine di percorrenza degli elementi in una tabella dizionario è arbitrario.Questo rende appropriato per itterare su dizionari, dove gli elementi vengono 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
]]

Spezza i loop

Per forzare la Terminaredi un ciclo, usa la parola chiave break. Il seguente esempio di codice mostra come rompere un 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!")

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

Continua i loop

Per forzare un ciclo a iterare e ripartire da capo, usa la parola chiave continue.Un ciclo A for itererà il contatore; while e repeat — until verificherà la condizione del ciclo prima di continuare.Il seguente esempio di codice ottiene tutti i figli di un Instance di un particolare 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

Su questa pagina