Kontrollstrukturen

Kontrollstrukturen sind Aussagen, die den Fluss der Ausführung von Luau-Code verwalten. Es gibt vier Hauptarten von Kontrollstrukturen:

• Eine if dann else Aussage führt Code nur aus, wenn eine bestimmte Bedingung true ist. Die Codeausführung wiederholt sich nicht.
• Eine While-Schleife führt Code aus, nur wenn eine angegebene Bedingung true ist, und wiederholt die Ausführung, während die Bedingung true bleibt.
• Eine Wiederholungsschleife führt Codesaus und wiederholt die Ausführung, wenn die Bedingung true.
• Ein für Schleife führt Code eine bestimmte Anzahl von Malen aus, abhängig von angegebenen Eingaben.

Die Bedingung für if Aussagen, while Schleifen und repeat Schleifen kann jede Luau-Ausdruck oder -Wert sein.Wenn ein Wert nicht false oder nil ist, bewertet Luau ihn als true in Bedingungsstatements.Im Gegensatz zu anderen Skriptsprachen betrachtet Luau sowohl die Null als auch die leere Zeichenkette als true.

Wenn Aussagen

Die grundlegende if -Anweisung prüft ihre Bedingung. Wenn die Bedingung wahr ist, führt Luau den Code zwischen then und end aus.

Du kannst eine elseif Aussage verwenden, um zusätzliche Bedingungen zu testen, wenn die if Bedingung falsch ist.Du kannst eine else Aussage verwenden, um Code auszuführen, wenn alle if und elseif Bedingungen fehlschlagen.Die elseif - und else -Teile sind beide optional, aber du kannst keines ohne eine anfängliche if -Erklärung verwenden.

In einer Kette von if, elseif und else Bedingungen prüft Luau Bedingungen von oben nach unten, hält bei der ersten true Bedingung an und führt den Code aus, der danach folgt.

if 2 + 2 == 5 then
	print("Two plus two is five") -- Druckt nicht, weil die Bedingung falsch ist
elseif 2 + 3 == 5 then
	print("Two plus three is five") -- Zwei plus drei ist fünf
else
	print("All conditions failed") -- Druckt nicht, weil die vorherige Bedingung wahr ist
end

Während Schleifen

Eine while — do Schleife prüft, ob eine bestimmte Bedingung wahr oder falsch istWenn die Bedingung false oder nil ist, endet die Schleife und Luau überspringt den Code in der Schleife.Wenn die Bedingung true ist, führt Luau den Code in der Schleife aus und wiederholt den Prozess.

local timeRemaining = 10

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

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

Unendliche Loops

Du kannst eine while — do Schleife verwenden, um unendliche Spielschleifen zu schreiben, indem du true als Bedingung festlegst.

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

--[[ Ausgabe:
Looping...
Looping...
Looping...
Looping...
...
]]

Wiederholungszyklen

Die repeat — until Schleife wiederholt sich, bis eine Bedingung wahr ist.Der Bedingungstest bewertet nach , dass der Codeblock ausgeführt wird, so dass der Codeblock immer mindestens einmal ausgeführt wird.Im Gegensatz zu anderen Sprachen enthält der Luau-Bereich einer lokalen Variable, die innerhalb einer repeat - until -Schleife deklariert wird, die Bedingung.

local currentGoblinCount = 18

-- Spawne Goblins bis zu einem Maximum von 25 im Spiel
repeat
	spawnGoblin()
	currentGoblinCount += 1
	print("Current goblin count: " .. currentGoblinCount)
until currentGoblinCount == 25

print("Goblins repopulated!")

--[[ Ausgabe:
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!
]]

Für Schleifen

A for Schleife führt Code eine bestimmte Anzahl von Mal aus, entweder basierend auf einem numerischen Zähler oder der Anzahl von Artikeln in einer Sammlung.

Zahl für Schleifen

Eine for — do Schleife bestimmt die Anzahl der Ausführungen der Schleife mit einem Gegenangebot machen.Die Schleife wird mit einem Startwert, einem Endwert und einem optionalen Zunahmewert deklariert.

Luau setzt den Zähler auf den Startwert gleich, führt den Code-Block im for -Loop aus und fügt dann das Inkrement zum Gegenangebot machenhinzu.Wenn das Zunahme positiv ist, wiederholt sich der Prozess, bis der Zähler dem Endwert gleich oder größer ist.Wenn das Inkrement negativ ist, wiederholt der Prozess, bis der Zähler dem Endwert gleich oder weniger als gleich ist.

Die optionale Erhöhung wird auf 1 festgelegt. Es muss keine ganze Zahl sein.

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

--[[ Ausgabe:
1
2
3
]]

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

--[[ Ausgabe:
1
3
5
]]

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

--[[ Ausgabe:
2
1.5
1
0.5
0
]]

Generisch für Schleifen

Die generische for -Schleife durchläuft Elemente in einer Sammlung anstatt eine Reihe von Zahlen.Mit generischen for -Schleifen können Sie Code für jedes Element in der Sammlungenausführen und jedes Element im Codesleicht verwenden.

Für Schleifen benötigen eine Funktion oder Iterator, um über verschiedene Arten von Sammlungen zu iterieren.Die globale ipairs() gibt einen Iterator für Arrays zurück, und die globale pairs() gibt einen Iterator für Dictionaries zurück.Die string Bibliothek bietet string.gmatch() eine Iteration über Zeichen.

Generalisierte Iteration

In Luau kannst du eine Tabelle mit dem Schlüsselwort in direkt auf der Tabelle durchlaufen, anstatt eine Iterationsfunktion wie ipairs() zu verwenden:

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

Die generische Iteration ermöglicht es Ihnen auch, die __iter Metamethode zu verwenden, um eine benutzerdefinierte Iterationsfunktion zu erstellen.Dieses herbeigeführte Beispiel iteriert über ein Array in umgekehrter Reihenfolge, von seinem letzten Element bis zu seinem ersten:

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

--[[ Ausgabe:
5 5
4 4
3 3
2 2
1 1
]]

Arrays

Die ipairs()-Funktion gibt eine Iterator zurück, der durch numerische Indizes in einer Tabelle iteriert und für jedes Element index und value zurückgibt.Das macht es für Arrays angemessen, bei denen alle Indizes numerisch sind.

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

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

Wörterräume

Die pairs()-Funktion gibt eine Iterator zurück, der durch alle Indizes (einschließlich numerischer Indizes) in einer Tabelle iteriert und einen key und value für jeden Eintrag im Wörterbuch zurückgibt.Die Reihenfolge der Durchquerungselemente in einer Diktionstabelle ist willkürlich.Dies macht es angemessen, über Wörterbücher zu iterieren, bei denen Elemente mit nicht-numerischen Indizes außerhalb der Reihenfolge gespeichert werden.

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

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

Schleifen brechen

Um eine Schleife zu erzwingen, die beenden, verwende das Schlüsselwort break. Das folgende Codebeispiel zeigt, wie eine unendliche while — do Schleife gebrochen wird.

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

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

Schleifen fortsetzen

Um eine Schleife zu zwingen, sich wieder zu wiederholen und erneut zu starten, verwende das Schlüsselwort continue.Eine for -Schleife wird die Gegenangebot machenwiederholen; while und repeat — until überprüfen die Schleifenbedingung, bevor sie fortfahren.Das folgende Codebeispiel erhält alle Kinder eines Instance eines bestimmten ClassName .

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

	return children
end