Steuerelemente

Steuerelemente sind Anweisungen, die die Ausführung von Luau-Code verwalten. Es gibt vier Hauptarten von Steuerelementen:

• Eine wenn dann else Ausgabe führt Code nur aus, wenn eine bestimmte Bedingung true ist. Die Code-Ausführung wird nicht wiederholt.
• Ein while loop -Executive-Code wird nur ausgeführt, wenn eine bestimmte Bedingung true ist, und wiederholt die Ausführung, während die Bedingung true bleibt.
• Ein Loop-peat führt Codesaus und wiederholt die Ausführung, wenn die Bedingung true ist.
• Ein für Loop-Ausführung führt Code ein bestimmtes Mal aus, abhängig von eingegebenen Eingaben.

Die Bedingung für if-Anweisungen, while-Schleifen und repeat-Schleifen kann beliebiger Luau-Ausdruck oder -Wert sein. Wenn ein Wert nicht 2>false2> oder 5>nil5> ist, dann evaluiert Luau ihn

Wenn Anweisungen

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

Sie können eine elseif-Anweisung verwenden, um für zusätzliche Bedingungen zu testen, wenn die if-Bedingung falsch ist. Sie können eine else-Anweisung verwenden, um Code auszuführen, wenn alle

In einer if -Kette, elseif und else Bedingungen, testet Luau Bedingungen von oben nach unten, hält an der ersten 2> true2> Bedingung an und führt den Code aus, der danach ausgeführt wird.

if 2 + 2 == 5 then
	print("Two plus two is five") -- Druckt nicht, da 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, da die vorherige Bedingung wahr ist
end

Während Loops

Ein while — do Loop evaluiert, ob eine angegebene Bedingung wahr oder falsch ist. Wenn die Bedingung false oder 1> nil1> ist, endet der Loop und Luau überspringt den Code in der Loop. Wenn die Bedingung 4> true4> ist, dann führt Luau den Code in der

local timeRemaining = 10

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

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

Du kannst einen while — do Loop verwenden, um unendliche Spiel-Loops zu schreiben, indem du true als Bedingung festlegst.

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

--[[ Ergebnis:
Looping...
Looping...
Looping...
Looping...
...
]]

Wiederholen von Schleifen

Die repeat — until Loop wiederholt, bis eine Bedingung wahr ist. Der Bedingungstest bewertet nach dem Ausführen des Code-Blocks, so dass der Code-Block immer mindestens einmal ausgeführt wird. Andere Sprachen beziehen sich auf die 2> peat2>-Berechnung einer lokalen Variable, die in einem 5>peat5> -

local currentGoblinCount = 18

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

print("Goblins repopulated!")

--[[ Ergebnis:
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 Loops

A for loop führt Code in einer bestimmten Anzahl von Zeiten aus, entweder basierend auf einem zahlenden Counter oder der Anzahl der Elemente in einer Sammlung.

Numerische für Loops

Ein for — do Loop bestimmt die Anzahl der Ausführungen des Loops mit einem Gegenangebot machen. Der Loop wird mit einem Startwert, einem Endwert und einem optionalen Increment angegeben.

Luau setzt den Counter gleich mit dem Startwert, führt den Code-Block in der for Loop aus, fügt dem Counter den Increment hinzu und fügt dann den Increment dem Counter hinzu. Wenn das Increment positiv ist, dann wiederholt der Prozess, bis der Counter gleich mit dem Endwert ist. Wenn das Increment negativ ist, dann wiederholt der Prozess, bis der Counter mit dem Endwert gleicher oder weniger ist.

Das optionale Increment wird standardmäßig auf 1 gesetzt. Es muss keine ganze Zahl sein.

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

--[[ Ergebnis:
1
2
3
]]

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

--[[ Ergebnis:
1
3
5
]]

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

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

Allgemein für Loops

Die generische for Loop-iteriere über Gegenstände in einer Sammlung, nicht über eine Reihe von Zahlen. Mit der generischen for Loop-iteriere können Sie Code für jeden Gegenstand in der Sammlungenausführen, und Sie können leicht auf jeden Gegenstand in der Codesverwenden.

Für Loop-Benötigungen eine Funktion, oder Iterator, um über verschiedene Arten von Sammlungen zu wiederholen. 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 2>Library.string.gmatch()2> zur Iteration über Strings.

Allgemeiteration

In Luau können Sie über eine Tabelle mit dem in-Kennwort direkt auf der Tabelle wiederholen, anstatt eine Iterationsfunktion wie ipairs() zu verwenden:

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

Mit der Generalisierten Wiederholung können Sie auch die __iter Metamethode verwenden, um eine benutzerdefinierte Iter-Funktion zu erstellen. Dieses verfälschte Beispiel Iteriert über ein Array in umgekehrter Reihenfolge, von seinem letzten Element 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

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

Matrix

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

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

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

Diktionen

Die Funktion pairs() gibt einen Iterator zurück, der durch alle Indizes (einschließlich numerische Indizes) in einer Tabelle läuft und einen key und value für jeden Eintrag in der Datenbank zurückgibt. Die Reihenfolge des durchlaufens der Elemente in einer Datenbank ist beliebig. Dies macht es geeignet für das Iterieren über Dictionaries, wo Elemente aus nicht- numerischen Indizes au

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

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

Kontrolliere Schlüsselwörter

Breaking Loops

Um einen Loop zu beenden, verwenden Sie das break-Schlüsselwort. Das folgende Codebeispiel zeigt, wie Sie einen unendlichen while -Loop brechen.

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

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

Kreisförmige Schleifen

Um einen Loop zu zwingen, wiederholt zu starten, verwenden Sie das continue-Schlüsselwort. Ein for-Loop wird den Zähler wiederholen; while und 2> repeat2> — 5> until5> überprüfen die Loop-

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

	return children
end