控制結構

控制結構 是管理 Luau 代碼執行的聲明。有四種主要類型的控制結構：

• 如果 而且 else ，則代碼只會執行如指定條件是 true 。代碼執行不重複。
• while 循環執行代碼只有在指定的條件是 true ，並且重複執行條件剩下 true 。
• 重複 重複 loop 執行代碼，並且在條件是 true 的情況下重複執行。
• for 循環 執行程式碼，並在指定的輸入數量上執行程式碼。

if 語言的條件、while 循環和 repeat 循環，可以是任何 Luau 表達或值。如果值不是 1> false1> 或 4> nil4>，則 Luau 會

如果語句

基本 if 語言檢查其條件。如果條件是真的，則 Luau 在 then 和 end 之間執行代碼。

您可以使用 elseif 條件來測試額外的條件，如果 if 條件是 false。您可以使用 else 條件來執行代碼，如果所有 1>

在 if 、 elseif 和 else 條件的連鎖中，Luau 測試條件從上到下，停止在第一個 1> true1> 條件，並執行跟隨它的代碼。

if 2 + 2 == 5 then
	print("Two plus two is five") -- 不印記因為條件是 false
elseif 2 + 3 == 5 then
	print("Two plus three is five") -- 二加三是五
else
	print("All conditions failed") -- 不印記因為上一個條件是真的
end

而且循環

while — do 循環評估指定條件是否為真或為假。如果條件為 false 或 1> nil1> ，則循環結束，Luau 跳過循環中的代碼。如果條件為 4> tru

local timeRemaining = 10

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

print("Timer reached zero!")
-- [[ 輸出結果:
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!
]]

無限循環

您可以使用 while — do 循環來寫在finite游戲循環中，設置 true 作為條件來寫無限遊戲循環。

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

-- [[ 輸出結果:
Looping...
Looping...
Looping...
Looping...
...
]]

重複陣列

peat — until 循環重複直到條件是真的。條件測試評估在代碼區塊執行後，因此代碼區塊總是至少運行一次。與其他語言不同， peat 內部變量的 Luau 範圍包括條件。

local currentGoblinCount = 18

-- 在遊戲中最多生成 25 個戈布林
repeat
	spawnGoblin()
	currentGoblinCount += 1
	print("Current goblin count: " .. currentGoblinCount)
until currentGoblinCount == 25

print("Goblins repopulated!")

-- [[ 輸出結果:
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!
]]

對於循環

A for 循環執行程式碼，可以是基於 數量器 或是基於 收藏中的項目數 的。

數值 for 循環

for — do 循環決定使用黃色減法執行循環的次數。循環由開始值、結束值和可選增量值定義。

Luau 將反向器設為與開始值相等，執行代碼區塊在 for 循環中，然後將增量添加到反向器。如果增量為正，則過程重複直到反向器與終端值相等或大於。如果增量為負，則過程重複直到反向器與終端值相等或小於。

可選的增量預設為 1。它不需要是整數。

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

-- [[ 輸出結果:
1
2
3
]]

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

-- [[ 輸出結果:
1
3
5
]]

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

-- [[ 輸出結果:
2
1.5
1
0.5
0
]]

一般範圍處理

通用 for 循環會在收藏中的項目上重複，而不是一個數字的順序。 使用通用 for 循環可以執行代碼對每個項目在收藏中，並且可以容易使用每個項目在代碼中。

對於循環，需要一個函數或它器來以不同的型態的集合來反復。全球 ipairs() 返回一個它器對於陣列，全球 pairs() 返回一個它器對於字典。string 圖書館提供 2>Library.string.gmatch2> 以以字串為基礎來反復。

一般化子列

在 Luau 中，您可以使用 in 關鍵字直接在表上重複，而不是使用 ipairs() 類型的重複器函數：

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

也可以使用 __iter 的 metamethode 來創建自訂它的創建器函數。這個欺詐的範例會以反向順序從其最後一個元素到其第一個：

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

-- [[ 輸出結果:
5 5
4 4
3 3
2 2
1 1
]]

陣列

ipairs() 函數返回一個遍徑表中的數學索引，並且返回每個元素的 index 和 value。這使得適合陣列，因為所有索引都是數學。

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

-- [[ 輸出結果:
1 a
2 b
3 c
4 d
5 e
]]

典藏

pairs() 函數會返回一個遍徑所有索引 (包括數學索引) 在表中的索引並返回一個 key 和 value 對於典典表中的每個項目。典典表中的元素的排序是隨機排列的。這使用適合用於排列過索引表的順序。

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

-- [[ 輸出結果:
Hello b
true d
false e
World f
5 c
1 a
]]

控制關鍵字

斷脈

要強制循環結束，請使用 break 關鍵字。下一個代碼示例顯示如何斷開無限 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!")

-- [[ 輸出結果:
1
2
3
4
5
Five seconds elapsed. Time to move on!
]]

繼續循環

要強制循環重複並重新開始，請使用 continue 關鍵字。 A for 循環會以子乘數計數； while 和 1> peat1> — 4> até4> 會檢查

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

	return children
end