• 同一个table可以有不同类型索引
    • table索引和变量一样，没初始化则是nil，赋nil代表释放
  • 索引可以当作成员使用
    • a[“name”]等价于a.name
    • 注：a.x与a[x]并不等价，a.x等价于a[“x”]；而a[x]则是table a中索引为x的变量

  • 如果索引是浮点型，那么能被转换为整形的会被转换为整型，不能被转换的则会保持浮点型

    • 如：a={}中a[2.0]和a[2]相同。

      table构造器

  • 用于初始化table，最简单的构造器 → {}

    • a={hello=”abc”,number=2,{x=1,y=2}}
  • 可以在table中嵌套table
  • table的索引必须从1开始，不能是负数和错误格式的标识符
    • 注：可以使用[“”]的方式，初始化不符合格式的索引
      • a={[“+”]=1,[“-“]=2}但是调用时，也要使用”” → a[“+”]来调用
      • 在table中，sum=1和[sum]=1不同；
        • sun=1代表：sum作为键，1作为值
        • [sum]=1代表：sum对应的变量作为键，1作为值（值可以直接使用变量代替） ```lua tableA = { color = “black”, number = 2, {x = 0, y = 0}, {x = 1, y = 1}, [“-1”] = “negative”, [“+”] = “add” }

print(tableA.color) —输出：black print(tableA[1].x, tableA[1][“x”]) —输出：0 0 print(tableA[“-1”]) —输出：negative

  1. <a name="URPlX"></a>
  2. # table作为数组、列表和序列
  4. - 只需要使用**整形作**为**索引**即可
  5.    - 不需要声明大小，且lua中的**索引**由**1开始**（区别于其他语言）
  6. - 通常会把**数组长度保存**在一个**非数值字段**中
  7.    - **通常使用n**
  8. - 使用#table可以**返回数组**使用**连续**的**整数索引**的**长度**，但是如果存在hole则会出现误差
  9.    - **hole**：即t**ableA={1,2,3,nil,4}**则称为**存在hole**
  10.    - **#table**返回的值**不会包括非数字索引**
  11. ```lua
  12. array = {1, 2, 3, 4, 5, n = 5, number = 1, number2 = 2}
  13. array1 = {}
  14. array1[1] = 1
  15. array1[100] = 2
  17. print(#array)        --输出：5
  18. print(#array1)    --输出：1

  • 注：程序中大多数列表都是连续的，在大多数情况下#返回的长度都是正确的

    遍历表-pairs()迭代器

  • 遍历table中的所有键值对

    • 遍历结果是随机的，但一定只会遍历一遍 ```lua tableA = {1, 2, print, “four”}

for k, v in pairs(tableA) do print(k, v) end —[[ 1 1 2 2 3 function 4 four —]]

<a name="eiyA4"></a>
# table标准库
<a name="kPMcp"></a>
### table.insert()：插入元素

- **table.insert(table[,locate],value)**：在**指定位置插入**元素；**没有指定**位置则**在**table的**最后插入，**插入后之后所有元素都往后移动一位
   - table：要插入元素的表
   - locate：可选参数，要插入的位置
      - **超过**table的**最大范围**和**负数**，则会**报错**
   - value：要插入的元素
```lua
function showTable(tableA)
    for k,v in pairs(tableA) do
        print(k,v)
    end
end

tableA={10,20,30}
table.insert(tableA,2,40)    --在tableA第二个位置插入40
showTable(tableA)
print("----")
table.insert(tableA,50)        --在tableA最后插入50
showTable(tableA)
--[[输出：
1       10
2       40
3       20
4       30
----
1       10
2       40
3       20
4       30
5       50
--]]

table.remove()：删除元素

  • table.remove(table[,locate])：删除最后一个元素或指定位置元素，并返回元素值
    • table：所要操作的table
    • locate：可选参数，table中要删除的元素的位置
      • 不能超过table的最大范围 ```lua function showTable(tableA) for k,v in pairs(tableA) do print(k,v) end end

tableA={10,20,30,40,50} print(table.remove(tableA,1)) —删除tableA的第一个元素，输出：10 print(table.remove(tableA)) —删除tableA的最后一个元素，输出：50 showTable(tableA) —[[输出： 1 20 2 30 3 40 —]]

<a name="e4Eaj"></a>
#### remove和insert实现栈

- push     →     table.insert(table,value）
- pop     →    table.remove(table)
<a name="eUmVP"></a>
### table.move()：移动一段元素

- **table.move(table1,start,end,locate[,table2])**：将table1中**start——end**的**元素**，**复制到locate开始**的**位置**；
   - table1：要操作的table
   - start：开始位置
   - end：结束位置
   - locate：这一段说要移动到的目标位置
   - table2：可选参数，**选择后，将table1中start——end的元素，复制到table2中locate开始的位置**
- **注：table.move()是实际上是复制操作，将start——end的元素复制到locate位置，覆盖原来的内容**
```lua
function showTable(tableA)
    for k, v in pairs(tableA) do
        print(k, v)
    end
end

tableA = {1, 2, 3, 4, 5, 6}
table.move(tableA, 1, 3, 2)        --将1~3位置的元素复制到2开始
showTable(tableA)                            --输出：1,1,2,3,4,5,6    将原本位置的

print("=====================")
tableA = {1, 2, 3, 4, 5, 6}
table.move(tableA, 2, #tableA, 1)    --删除tableA的第一个元素
table.remove(tableA)
showTable(tableA)                                    --输出：2,3,4,5,6

print("=====================")
tableA = {1, 2, 3, 4, 5, 6}
tableB = {}
table.move(tableA, 2, 4, 1, tableB)    --将tableA中2~4位置的元素复制到tableB中，不会改变tableA
print("tableA=")                                        
showTable(tableA)                                        --输出：1,2,3,4,5,6
print("tableB=")                                        
showTable(tableB)                                        --输出：2,3,4

table.pack()：将参数打包为table

  • table.pack(…)：将…中的可变长参数，储存到一个以1开始的table中，并且将个数保存到table中的n中
    • 可用于在函数中，对可变参数是否含有nil的检测 ```lua function checkTable(…) tableA = table.pack(…) for i = 1, tableA.n do if tableA[i] == nil then
         return false
      end end return true end

print(checkTable(1,2,3)) print(checkTable(1,2,nil)) print(checkTable(1,nil,3))

<a name="EWncx"></a>
### table.unpack()：将table解包为参数

- **table.unpack(table[,start,end])**：将table中的**内容**，**转换成对应个数的返回值**返回
   - table：要操作的table
   - start：开始的位置
   - end：结束的位置
   - 该函数**只能用于序列**中
```lua
tableA={1,2,3,4,5}
print(table.unpack(tableA))            --输出：1    2    3    4    5
print(table.unpack(tableA,2,4))    --输出：2    3    4

table.concat()：将内容合成字符串

  • table.concat(table[,sep][,start][,end])：将table中的内容连接成一个字符串，连接时不会保留换行符
    • table：要操作的table
    • sep：连接table的每段之间使用说明符号进行分割
    • start：table字符串连接开始的行数
    • end：table字符串连接结束的行数 ```lua local file = io.open(“Chapter 14\test.txt”) local t = {}

for line in file:lines() do t[#t + 1] = line end print(table.concat(t, “\n”)) ```

rawget()：不调用元方法访问表

  • rawget(table,index)：不调用__index元方法，访问table

    • table：要访问的table
    • index：table中的键

      rawset()：不调用元方法赋值

  • rawset(table,key,value)：在table中的索引key赋值时，绕过元方法__newindex

    • table：要操作的table
    • key：table中的索引
    • value：table中索引对应的值