桌子 | 文档 - Roblox 创作者中心

表数据类型可以存储多个类型的任何非nil 的值，包括booleans、1> 数量1>、4> 字符串4>、7> 函数7>和其他表。使用括号 0> 0> 建造表：


-- 构建一个空的表，命名为“t”
local t = {}
print(t) -- {}

您可以使用表作为一个阵列或字典。阵列使用排序列表的数字作为索引，但字典可以有数字、字符串和对象作为索引。

有关使用表工作的内置函数的更多信息，请参阅table图书。

阵列

阵列是一个有序列的值列。阵列有助于存储数据集，例如一个拥有特殊权限的玩家群。

创建阵列

使用 Luau 表创建阵列时，请将值在顺序上声明，并使用分号分开。


-- 构建一个阵列，其中包含三个项目
local testArray = {"A string", 3.14159, workspace.Camera}
print(testArray)

从阵列中阅读

要从数组列中读取，请在其参考后添加一个方形括号，并指定元素内的索引号([pos]):


-- 构建一个阵列，其中包含三个项目
local testArray = {"A string", 3.14159, workspace.Camera}

print(testArray[1]) -- 一个字符串
print(testArray[2]) -- 3.14159
print(testArray[3]) -- Camera

与某些语言不同，Luau使用 1 基索引对阵列，因此 1 行目在阵列中的第一个项目是 [1]，而不是 [0]。

写入阵列

要在索引中定义或重写阵列值，请使用方括[index]=和值：


local testArray = {"A string", 3.14159, workspace.Camera}

testArray[2] = 12345
testArray[4] = "New string"

print(testArray[2]) --123456
print(testArray[4]) -- New string

在阵列上迭代

要在数组列上循环，您可以使用一个 for 循环。因为阵列有数量索引，因此您也可以使用一个数量 for 循环从 1 到阵列长度（1> # array1>）。


local testArray = {"A string", 3.14159, workspace.Camera, "New string"}

-- 使用 general 循环
for index, value in testArray do
	print(index, value)
end

-- 使用阵列长度操作器（#）iterate
for index = 1, #testArray do
	print(index, testArray[index])
end

--[[ 输出结果：
1 A string
2 3.14159
3 Camera
4 New string
1 A string
2 3.14159
3 Camera
4 New string
]]

插入物品

有两种内置方法可以将项目插入数组列的 end ：

通过参考阵列和项目值给 Luau 的 table.insert() 函数传递参数。
使用 array[#array+1] 语法将新项目添加到阵列。


local testArray = {"A string", 3.14159}

table.insert(testArray, "New string")
testArray[#testArray+1] = "Another new string"

print(testArray[3]) -- 新字符串
print(testArray[4]) -- Another new string

要在阵数组的开始和结束之间插入一个物品，请包含位置值作为 table.insert() 的第二个参数。这将新物品插入，并将以下项目推出一个索引位置。


local testArray = {"First item", "Next item"}

table.insert(testArray, 2, "NEW ITEM #2")

print(testArray[1]) -- 第一个项物品
print(testArray[2]) -- 新项目 #2
print(testArray[3]) -- Next item

移除项目

要从阵数组中移除一个项目，请使用 table.remove() 。这将项目从指定位置移除，并将任何跟随的项目移动回一个索引位置。


local testArray = {"First item", "Next item", "Last item"}

table.remove(testArray, 2)

print(testArray[1]) -- 第一个项物品
print(testArray[2]) -- Last item

词典

字典是阵列的扩展。字典存储一个键值对，其中键可以是任何数字、字符串或对象。

创建字典

要创建一个字典表，定义每个键跟着 = 和值 value 。用分号将每对钥匙-值与值 2> 分开：


local testDictionary = {
	FruitName = "Lemon",
	FruitColor = "Yellow",
	Sour = true
}

字典的钥匙可以是数字、字符串和对象。例如，钥匙可以也是一个 Instance 。要使用对象作为钥匙，请在方块括号中声明钥匙 ([key]):


local part = Instance.new("Part")

local testDictionary = {
	PartType = "Block",
	[part] = true
}

从字典中阅读

要从字典中读取，请在其参考后添加一对括号，并指定钥匙名。使用括号直接参考字符串键（["key"]）或使用变量值（[key]）。


local part = Instance.new("Part")

local testDictionary = {
	PartType = "Block",
	[part] = true
}
-- 包括对字符串钥匙的引用
print(testDictionary["PartType"]) -- 防御
-- 对非字符键进行跳过
print(testDictionary[part]) -- true

写作辞典

要定义或重写新或现有字典键的值，请在 [key] 后跟着 = 和值：


local testDictionary = {
	FruitName = "Lemon",
	Sour = true
}

-- 更改现有钥匙的值
testDictionary["FruitName"] = "Cherry"
testDictionary["Sour"] = false

-- 插入新的键值对
testDictionary["FruitCount"] = 10

print(testDictionary["FruitName"]) -- 樱桃
print(testDictionary["Sour"]) -- 否
print(testDictionary["FruitCount"]) -- 10

过典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典典

要在字典上反复使用，请使用 for 循环中的全球函数 pairs：


local testDictionary = {
	FruitName = "Lemon",
	FruitColor = "Yellow",
	Sour = true
}

for key, value in pairs(testDictionary) do
	print(key, value)
end

--[[ 输出结果：
FruitName Lemon
Sour true
FruitColor Yellow
]]

与使用使用 ipairs() 在阵数组上不同，使用对在字典上返回的项目不一定是在字典中的顺序。

移除键值对

要从字典中移除或清除键值对，将其值设置为 nil 。


local testDictionary = {
	FruitName = "Lemon",
	FruitColor = "Yellow",
	Sour = true
}

testDictionary["Sour"] = nil

for key, value in pairs(testDictionary) do
	print(key, value)
end
--[[ 输出结果：
FruitName Lemon
FruitColor Yellow
]]

桌子作为参考

如果您在新变量中存储表，Luau不会创建该表的副本。相反，变量成为一个引用，或指针，到原始表。任何对表的引用都会反射原始表的任何更改：


local originalArray = {10, 20}

local arrayReference = originalArray

print("Original:", originalArray[1], originalArray[2])
print("Reference:", arrayReference[1], arrayReference[2])

-- 在原始阵数组中更改值
originalArray[1] = 1000
originalArray[2] = 2000

print("Reference:", arrayReference[1], arrayReference[2])

--[[ 输出结果：
Original: 10 20
Reference: 10 20
Reference: 1000 2000
]]

克隆桌子

浅层克隆

要复制一个表 without any nested tables, Luau 提供了 table.clone() 方法。


local original = {
	key = "value",
	engine = "Roblox",
	playerID = 505306092
}

local clone = table.clone(original)

深度克隆

要复制一个更复杂的表，其中有递归表，你需要使用类似以关注中/正在关注的递归函数：


-- 用于深度复制表的函数
local function deepCopy(original)
	-- 为复制定义新表
	local copy = {}

	-- 通过原始表进行复制
	for key, value in original do
		-- 如果值的类型是表，深度复制到钥匙(索引)
		-- 否则（或）类型不是表，将默认值分配到索引
		copy[key] = type(value) == "table" and deepCopy(value) or value
	end

	-- 返回深度克隆表的最终复制品
	return copy
end

有了函数在场景，你可以使用以下命令来创建深度副本：


local original = {
	key = "value",
	playerInfo = {
		playerID = 505306092,
		playerName = "PlayerName"
	},
	otherInfo = {
		{
			{1, 3, 5, 7, 9}
		}
	}
}

local clone = deepCopy(original)

冰冻桌子

冰冻一个表使其只能读取，这对于不想要更改的常量值很有用。冰冻是永久的，没有“冻结”或“解冻”方法。要检查表是否冰冻，请使用 table.isfrozen() 。

浅层冰冻

要冻结表，无需任何子表，Luau提供方法 table.freeze()。


local target = {
	key = "value",
	engine = "Roblox",
	playerID = 505306092
}

table.freeze(target)
target.playerID = 1 --> attempt to modify a readonly table

深度冻结

要将更复杂的表中的子表冻结在一个更复杂的表中，请使用类似以关注中/正在关注的递归函数：


local function deepFreeze(target)
	-- 将表单浅冻结
	table.freeze(target)

	-- 检查表中的每个键，并将其冰冻，如果它是表
	for _, v in target do
		if type(v) == "table" then
			deepFreeze(v)
		end
	end
end

有了函数在那场景，你可以深冻表如下所示：


local target = {
	key = "value",
	playerInfo = {
		playerID = 505306092,
		playerName = "PlayerName"
	},
	otherInfo = {
		{
			{1, 3, 5, 7, 9}
		}
	}
}

deepFreeze(target)
target.playerInfo.playerID = 1 --> attempt to modify a readonly table