《Lua快速入门》4.表（Table）

表（Table）

1. 表的基本概念

1.1 表的定义

表（Table）是 Lua 中唯一的数据结构，用于表示数组、字典、集合、对象等。表是一种动态的、可扩展的关联数组，键和值可以是任意类型（除了 nil）。

1.2 表的创建

表通过花括号 {} 创建，键值对用逗号分隔。

local t = {}  -- 空表
local arr = {1, 2, 3}  -- 数组
local dict = {name = "Lua", version = "5.4"}  -- 字典

1.3 表的特性

• 动态性：表的大小和内容可以动态调整。
• 灵活性：键和值可以是任意类型（除了 nil）。
• 唯一性：表是 Lua 中唯一的数据结构，可以表示多种数据结构。

2. 表的操作与方法

2.1 表的访问

• 通过键访问值：

  local dict = {name = "Lua", version = "5.4"}
  print(dict["name"])  -- 输出: Lua
  print(dict.name)     -- 输出: Lua
  

• 通过索引访问数组元素：

  local arr = {1, 2, 3}
  print(arr[1])  -- 输出: 1
  

2.2 表的修改

• 添加或修改键值对：

  local t = {}
  t["key"] = "value"
  t.key2 = "value2"
  

• 删除键值对：

  t["key"] = nil
  

2.3 表的遍历

• 使用 pairs 遍历所有键值对：

  local t = {a = 1, b = 2, c = 3}
  for k, v in pairs(t) do
      print(k, v)
  end
  

• 使用 ipairs 遍历数组部分：

  local arr = {1, 2, 3}
  for i, v in ipairs(arr) do
      print(i, v)
  end
  

2.4 表的长度

• 使用 # 获取数组部分的长度：

  local arr = {1, 2, 3}
  print(#arr)  -- 输出: 3
  

2.5 表的常用方法

• table.insert：向表中插入元素。

  local t = {1, 2, 3}
  table.insert(t, 4)  -- 在末尾插入
  table.insert(t, 2, 1.5)  -- 在指定位置插入
  

• table.remove：从表中移除元素。

  local t = {1, 2, 3}
  table.remove(t, 2)  -- 移除第二个元素
  

• table.concat：将数组部分的元素连接成字符串。

  local t = {1, 2, 3}
  print(table.concat(t, ", "))  -- 输出: 1, 2, 3
  

• table.sort：对数组部分进行排序。

  local t = {3, 1, 2}
  table.sort(t)
  print(table.concat(t, ", "))  -- 输出: 1, 2, 3
  

3. 元表与元方法

3.1 元表的概念

元表（Metatable）是一种特殊的表，用于定义表的自定义行为。通过元表，可以为表添加运算符重载、访问控制等功能。

3.2 设置元表

使用 setmetatable 函数为表设置元表。

local t = {}
local mt = {}
setmetatable(t, mt)

3.3 元方法

元方法是元表中的特殊键，用于定义表的自定义行为。常见的元方法包括：

3.3.1 __index 元方法

__index 用于定义表的索引访问行为。当访问表中不存在的键时，会调用 __index 元方法。

local t = {}
local mt = {
    __index = function(table, key)
        return "Key not found: " .. key
    end
}
setmetatable(t, mt)
print(t["name"])  -- 输出: Key not found: name

3.3.2 __newindex 元方法

__newindex 用于定义表的新键赋值行为。当向表中赋值一个不存在的键时，会调用 __newindex 元方法。

local t = {}
local mt = {
    __newindex = function(table, key, value)
        print("Assigning " .. key .. " = " .. value)
    end
}
setmetatable(t, mt)
t["name"] = "Lua"  -- 输出: Assigning name = Lua

3.3.3 __add 元方法

__add 用于定义表的加法操作。

local t1 = {value = 10}
local t2 = {value = 20}
local mt = {
    __add = function(a, b)
        return {value = a.value + b.value}
    end
}
setmetatable(t1, mt)
setmetatable(t2, mt)
local t3 = t1 + t2
print(t3.value)  -- 输出: 30

3.3.4 __tostring 元方法

__tostring 用于定义表的字符串表示。

local t = {name = "Lua", version = "5.4"}
local mt = {
    __tostring = function(table)
        return table.name .. " " .. table.version
    end
}
setmetatable(t, mt)
print(t)  -- 输出: Lua 5.4

4. 总结

表是 Lua 中最重要的数据结构，具有高度的灵活性和动态性。通过元表和元方法，可以为表添加自定义行为，实现运算符重载、访问控制等功能。掌握表的使用和元表机制，是编写高效 Lua 程序的关键。