Kontrollstrukturen

Kontrollstrukturen sind Anweisungen, die den Fluss der Ausführung von Luau-Code steuern. Es gibt vier Haupttypen von Kontrollstrukturen:

• Eine if then else Anweisung führt Code nur aus, wenn eine bestimmte Bedingung true ist. Die Codeausführung wird nicht wiederholt.
• Eine while-Schleife führt Code nur aus, wenn eine bestimmte Bedingung true ist, und wiederholt die Ausführung, solange die Bedingung true bleibt.
• Eine repeat-Schleife führt Code aus und wiederholt die Ausführung, wenn die Bedingung true ist.
• Eine for-Schleife führt Code eine festgelegte Anzahl von Malen aus, abhängig von den angegebenen Eingaben.

Die Bedingung für if-Anweisungen, while-Schleifen und repeat-Schleifen kann jeder Luau-Ausdruck oder Wert sein. Wenn ein Wert nicht false oder nil ist, bewertet Luau ihn in bedingten Anweisungen als true. Im Gegensatz zu anderen Skriptsprachen betrachtet Luau sowohl Null als auch den leeren String als true.

If-Anweisungen

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

Du kannst eine elseif-Anweisung verwenden, um zusätzliche Bedingungen zu testen, falls die if-Bedingung falsch ist. Du kannst eine else-Anweisung verwenden, um Code auszuführen, wenn alle if- und elseif-Bedingungen fehlschlagen. Die elseif- und else-Teile sind beide optional, aber du kannst keinen von beiden ohne eine ursprüngliche if-Anweisung verwenden.

In einer Kette von if, elseif und else-Bedingungen testet Luau die Bedingungen von oben nach unten, stoppt bei der ersten true-Bedingung und führt den folgenden Code aus.

if 2 + 2 == 5 then
	print("Zwei plus zwei ist fünf") -- Wird nicht ausgegeben, weil die Bedingung falsch ist
elseif 2 + 3 == 5 then
	print("Zwei plus drei ist fünf") -- Zwei plus drei ist fünf
else
	print("Alle Bedingungen sind fehlgeschlagen") -- Wird nicht ausgegeben, weil die vorherige Bedingung wahr ist
end

While-Schleifen

Eine while—do Schleife bewertet, ob eine bestimmte Bedingung wahr oder falsch ist. Wenn 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("Verbleibende Sekunden: " .. timeRemaining)
	task.wait(1)
	timeRemaining -= 1
end

print("Timer hat Null erreicht!")
--[[ Ausgaben:
Verbleibende Sekunden: 10
Verbleibende Sekunden: 9
Verbleibende Sekunden: 8
Verbleibende Sekunden: 7
Verbleibende Sekunden: 6
Verbleibende Sekunden: 5
Verbleibende Sekunden: 4
Verbleibende Sekunden: 3
Verbleibende Sekunden: 2
Verbleibende Sekunden: 1
Timer hat Null erreicht!
]]

Unendliche Schleifen

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

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

--[[ Ausgaben:
Schleife...
Schleife...
Schleife...
Schleife...
...
]]

Repeat-Schleifen

Die repeat—until Schleife wird wiederholt, bis eine Bedingung true ist. Der bedingte Test wird nach dem Ausführen des Codeblocks bewertet, sodass der Codeblock immer mindestens einmal ausgeführt wird. Im Gegensatz zu anderen Sprachen umfasst der Luau-Bereich einer lokal deklarierten Variablen innerhalb einer repeat—until Schleife die Bedingung.

local currentGoblinCount = 18

-- Spawn Goblins bis maximal 25 im Spiel
repeat
	spawnGoblin()
	currentGoblinCount += 1
	print("Aktuelle Goblinzahl: " .. currentGoblinCount)
until currentGoblinCount == 25

print("Goblins wurden wieder bevölkert!")

--[[ Ausgaben:
Aktuelle Goblinzahl: 19
Aktuelle Goblinzahl: 20
Aktuelle Goblinzahl: 21
Aktuelle Goblinzahl: 22
Aktuelle Goblinzahl: 23
Aktuelle Goblinzahl: 24
Aktuelle Goblinzahl: 25
Goblins wurden wieder bevölkert!
]]

For-Schleifen

Eine for-Schleife führt Code eine festgelegte Anzahl von Malen aus, entweder basierend auf einem numerischen Zähler oder der Anzahl der Elemente in einer Sammlung.

Numerische For-Schleifen

Eine for—do Schleife bestimmt die Anzahl der Ausführungen der Schleife mithilfe eines Zählers. Die Schleife wird mit einem Startwert, Endwert und optionaler Inkrementierung deklariert.

Luau setzt den Zähler auf den Startwert, führt den Codeblock in der for-Schleife aus und addiert dann die Inkrementierung zum Zähler. Wenn die Inkrementierung positiv ist, wird der Prozess wiederholt, bis der Zähler gleich oder größer als der Endwert ist. Wenn die Inkrementierung negativ ist, wird der Prozess wiederholt, bis der Zähler gleich oder kleiner als der Endwert ist.

Die optionale Inkrementierung hat standardmäßig den Wert 1. Sie muss keine ganze Zahl sein.

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

--[[ Ausgaben:
1
2
3
]]

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

--[[ Ausgaben:
1
3
5
]]

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

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

Generische For-Schleifen

Die generische for-Schleife iteriert über Elemente in einer Sammlung anstatt über eine Zahlenfolge. Mit generischen for-Schleifen kannst du Code für jedes Element in der Sammlung ausführen und jedes Element im Code problemlos verwenden.

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

Generalisierte Iteration

In Luau kannst du über eine Tabelle iterieren, indem du das Schlüsselwort in direkt auf der Tabelle verwendest, anstatt eine Iteratorfunktion wie ipairs() zu verwenden:

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

Die generalisierte Iteration ermöglicht es dir auch, die __iter-Metamethode zu verwenden, um eine benutzerdefinierte Iteratorfunktion zu erstellen. Dieses konstruierte Beispiel iteriert in umgekehrter Reihenfolge über ein Array, von seinem letzten Element bis zum 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

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

Arrays

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

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

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

Dictionaries

Die pairs() Funktion gibt einen Iterator zurück, der durch alle Indizes (einschließlich numerischer Indizes) in einer Tabelle iteriert und für jeden Eintrag im Dictionary einen key und value zurückgibt. Die Reihenfolge des Durchlaufens der Elemente in einer Dictionary-Tabelle ist willkürlich. Dies macht es geeignet für die Iteration über Dictionaries, bei denen die Elemente ungeordnet mit nicht-numerischen Indizes gespeichert sind.

local dictionary = {
	[1] = "a",
	["Hallo"] = "b",
	[5] = "c",
	[true] = "d",
	["Welt"] = "f",
	[false] = "e"
}
for key, value in pairs(dictionary) do
	print(key, value)
end

--[[ Ausgaben:
Hallo b
true d
false e
Welt f
5 c
1 a
]]

Schleifen abbrechen

Um eine Schleife zu erzwingen, dass sie endet, verwende das Schlüsselwort break. Das folgende Codebeispiel zeigt, wie man eine unendliche while—do Schleife bricht.

local secondsElapsed = 0
local timeout = 5

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

	if secondsElapsed == timeout then
		break
	end
end

print("Fünf Sekunden sind vergangen. Zeit weiterzumachen!")

--[[ Ausgaben:
1
2
3
4
5
Fünf Sekunden sind vergangen. Zeit weiterzumachen!
]]

Schleifen fortsetzen

Um eine Schleife zu zwingen, zu iterieren und erneut zu starten, verwende das Schlüsselwort continue. Eine for-Schleife wird den Zähler iterieren; while- und repeat—until-Schleifen prüfen die Schleifenbedingung, bevor sie fortfahren. Das folgende Codebeispiel erhält alle Kinder eines Instance einer 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