控制结构

控制结构 是声明，它们管理 Luau 代码执行的流量。有四种主要类型的控制结构：

• 如果另然，if then else语句只会执行代码，如果指定的条件是true。代码执行不会重复。
• while 循环执行代码只会执行 if 指定的条件是 true，并且在条件保持为 true 时重复执行。
• 重复循环执行代验证码，并且如果条件是 true 执行重复。
• for loop 执行代码 a set number of times 根据指定的输入。

if 声明、while 循环和repeat 循环的条件可以是任何 Luau 表达或值。如果值不是 1> false1> 或 4> nil4> ，那么 Luau 将它评

如果声明

基本 if 声明测试其条件。如果条件是真的，那么 Luau 将代码执行在 then 和 end 之间。

您可以使用 elseif 条件是否为满足条件，或测试额外的条件使用 if 语句。您可以使用 else 条件是否为满足条件，或测试额外的条件使用 2>if

在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> true4> ，那么 Luau 就会执行循环中的代码

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 循环来写代码无限游戏循环，设置 true 作为条件。

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

--[[ 输出结果：
Looping...
Looping...
Looping...
Looping...
...
]]

重复循环

peat — until 循环重复，直到条件是真的。 条件测试评估在代码块运行后，因此代码块总是至少运行一次。 与其他语言不同， peat 的 local 变量声明内的 1> peat1> 范围包括条件。

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 循环执行代码 a 设置 数量 次，或基于 数量控制器 或 收藏中的项目数量。

循环数学

for — do 循环确定执行循环使用计数还价的次数。循环声明了一个开始值、终止值和可选增量。

Luau将反向设置为开始值，执行代码块在 for 循环中，然后将增量添加到 counte还价。如果增量是正的，那么过程会重复直到 counter 等同于或大于最后值。如果增量是负的，那么过程会重复直到 counter 等同于或小于最后值。

可选的增量默认为 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>Lib字符串ary.string.gmatch()2> 来遍历串。

通用迭代

在 Luau 中，您可以使用 in 关键字直接在表上循环，而不是使用 ipairs() 函数：

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

通用循环还允许您使用 __iter мета方法创建自定义循环函数。此恶作剧示例在阵列的倒序从其最后元素到最先：

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 对表中每个条目。在字典表中 traversing 要素的顺序是任意的。这使得它适合用于遍索索引，在这里项目存储出不是按非数量索引存储。

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 关键字。一个 for 循环会反复执行计数还价； while 和 1> peat1> — 4> until4> 将检查循环状态，

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