Lua 学习之基础篇四<Lua table(表)>

table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型，如：数组、字典等。

Lua table 使用关联型数组，你可以用任意类型的值来作数组的索引，但这个值不能是 nil。

Lua table 是不固定大小的，你可以根据自己需要进行扩容。

Lua也是通过table来解决模块（module）、包（package）和对象（Object）的。 例如string.format表示使用”format”来索引table string。

table(表)的构造

构造器是创建和初始化表的表达式。表是Lua特有的功能强大的东西。最简单的构造函数是{}，用来创建一个空表。可以直接初始化数组:

-- 初始化表
mytable = {}

-- 指定值
mytable[1]= "Lua"

-- 移除引用
mytable = nil
-- lua 垃圾回收会释放内存

当我们为 table a 并设置元素，然后将 a 赋值给 b，则 a 与 b 都指向同一个内存。如果 a 设置为 nil ，则 b 同样能访问 table 的元素。如果没有指定的变量指向a，Lua的垃圾回收机制会清理相对应的内存。

-- 简单的 table
mytable = {}
print("mytable 的类型是 ",type(mytable))

mytable[1]= "Lua"
mytable["wow"] = "修改前"
print("mytable 索引为 1 的元素是 ", mytable[1])
print("mytable 索引为 wow 的元素是 ", mytable["wow"])

-- alternatetable和mytable的是指同一个 table
alternatetable = mytable
print(alternatetable)
print(mytable)

print("alternatetable 索引为 1 的元素是 ", alternatetable[1])
print("alternatetable 索引为 wow 的元素是 ", alternatetable["wow"])

alternatetable["wow"] = "修改后"

print("mytable 索引为 wow 的元素是 ", mytable["wow"])

-- 释放变量
alternatetable = nil
print("alternatetable 是 ", alternatetable)

-- mytable 仍然可以访问
print("mytable 索引为 wow 的元素是 ", mytable["wow"])

mytable = nil
print("mytable 是 ", mytable)

mytable 的类型是 	table
mytable 索引为 1 的元素是 	Lua
mytable 索引为 wow 的元素是 	修改前
table: 0x7fd2994074f0
table: 0x7fd2994074f0
alternatetable 索引为 1 的元素是 	Lua
alternatetable 索引为 wow 的元素是 	修改前
mytable 索引为 wow 的元素是 	修改后
alternatetable 是 	nil
mytable 索引为 wow 的元素是 	修改后
mytable 是 	nil

Table的访问

myTable[3]          --当键是数字的时候,只有一种访问方式
myTable.name        --当键是字符串的时候有两种访问方式
myTable["name"]

Table操作

• table.concat (list [, sep [, i [, j]]])

concat是concatenate（连锁，连接）的缩写，table.concat()函数列出参数中指定table的数组部分从start位置到end 的所有元素，元素见以指定的分隔符(sep)隔开

fruits = {"banana","orange","apple"}
-- 返回 table 连接后的字符串
print("连接后的字符串 ",table.concat(fruits))

-- 指定连接字符
print("连接后的字符串 ",table.concat(fruits,", "))

-- 指定索引来连接 table
print("连接后的字符串 ",table.concat(fruits,", ", 2,3))

连接后的字符串 	bananaorangeapple
连接后的字符串 	banana, orange, apple
连接后的字符串 	orange, apple

• table.insert (list, [pos,] value)

在table的数组部分指定位置(pos)插入值为value的一个元素，pos参数可选，默认为数组部分末尾

fruits = {"banana","orange","apple"}

-- 在末尾插入
table.insert(fruits,"mango")
print("索引为 4 的元素为 ",fruits[4])

-- 在索引为 2 的键处插入
table.insert(fruits,2,"grapes")
print("索引为 2 的元素为 ",fruits[2])

for k,v in ipairs(fruits) do
    print (k,v)
end

输出如下：
索引为 4 的元素为 	mango
索引为 2 的元素为 	grapes
1	banana
2	grapes
3	orange
4	apple
5	mango

• table.move (a1, f, e, t [,a2])

将a1中[f,e]范围内的元素拷贝到a2[t,t+e-f]范围内,拷贝内容为a1对应下标所含内容，有则copy。

t = {"12", 34, [8] = "56", m="78", n=90}
t1 = {}
table.move(t, 1, 3, 3, t1)
--把t中下标key为1-3的元素copy到t1 key为3-5的，t1的元素取决于t中范围内的元素
print("t: ")
    print(i, v)
end
print("t1: ")
for i,v in pairs(t1) do
    print(i, v)
end

t:
1	12
2	34
8	56
n	90
m	78
t1:
4	34
3	12

• table.remove (list [, pos])

返回table数组部分位于pos位置的元素，其后的元素会被前移，pos参数可选，默认为table长度，即从最后一个元素删起。

local tabLanguage = {
    "Assemblylanguage",
    "Lua",
    "c",
    "c++",
    "swift",
    "java",
    "python",
    "ruby"
};

for k,v in pairs(tabLanguage) do
    print(k,v)
end
print("LUA>>>>>>the length of table tabLanguage :", #tabLanguage, "\n")

-- 删除元素
table.remove(tabLanguage)

table.remove(tabLanguage)
for k,v in pairs(tabLanguage) do
    print(k,v)
end
print("LUA>>>>>>the length of table tabLanguage :", #tabLanguage, "\n")

-- 删除元素
local removeitem = table.remove(tabLanguage, 3)
for k,v in pairs(tabLanguage) do
    print(k,v)
end
print("LUA>>>>>>the length of table tabLanguage :", #tabLanguage, "\n")
print("remove data of tabLanguage is : "..removeitem)

-- 元素设置nil
tabLanguage[4] = nil;
for k,v in pairs(tabLanguage) do
    print(k,v)
end
print("LUA>>>>>>the length of table tabLanguage :", #tabLanguage, "\n")

输出如下:
1	Assemblylanguage
2	Lua
3	c
4	c++
5	swift
6	java
7	python
8	ruby
LUA>>>>>>the length of table tabLanguage :	8	

1	Assemblylanguage
2	Lua
3	c
4	c++
5	swift
6	java
LUA>>>>>>the length of table tabLanguage :	6	

1	Assemblylanguage
2	Lua
3	c++
4	swift
5	java
LUA>>>>>>the length of table tabLanguage :	5	

remove data of tabLanguage is : c
1	Assemblylanguage
2	Lua
3	c++
5	java
LUA>>>>>>the length of table tabLanguage :	3

• table.sort (list [, comp])

对给定的table 进行升序(字母或数字大小)排序

fruits = {"banana","orange","apple","grapes"}
print("排序前")
for k,v in ipairs(fruits) do
    print(k,v)
end

table.sort(fruits)
print("排序后")
for k,v in ipairs(fruits) do
    print(k,v)
end

排序前
1	banana
2	orange
3	apple
4	grapes
排序后
1	apple
2	banana
3	grapes
4	orange

如果有指定comp比较函数，那么sort将按照函数的规则进行排序

local tbl = {
    {id = 1, num = 88, level = 30},
    {id = 2, num = 66, level = 10},
    {id = 3, num = 66, level = 90},
    {id = 4, num = 99, level = 20},
    {id = 5, num = 66, level = 90}
}

table.sort(tbl, function(a, b)
    if a.num > b.num then
        -- 按num降序
        return true
    elseif a.num == b.num then
        -- 如果num相等，按level升序
        if a.level < b.level then
            return true
        elseif a.level == b.level then
            -- 如果level相等，按id降序
            return a.id > b.id
        end
    end
    return false
end)

for _, v in pairs(tbl) do
    print(string.format("id = %d, num = %d, level = %d", v.id, v.num, v.level))
end

-- id = 4, num = 99, level = 20
-- id = 1, num = 88, level = 30
-- id = 2, num = 66, level = 10
-- id = 5, num = 66, level = 90
-- id = 3, num = 66, level = 90

Table的遍历

Lua 中有默认三种方式遍历,其中pairs用于迭代元素，ipairs用于迭代数组

关于table-hash内部原理的介绍请参考：table-hash详解

• for k,v in pairs(tbtest) do

  但是这种遍历不是有序输出

tbtest = {
    [1] = 1,
    [2] = 2,
    [3] = 3,
    [4] = 4,
} 

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

4
1
2
3

• for k,v in ipairs(tbtest) do

有序输出，以tbtest中的key为顺序，必须是从1开始，ipairs只会从1开始按连续的key顺序遍历到key不连续为止。

tbtest = {
    [1] = 1,
    [2] = 2,
    [3] = 3,
    [5] = 5,
    } 

for k,v in ipairs(tbtest) do
    print(v)
end

1
2
3

• for i=1, #(tbtest) do

'#'是用来获取table的长度，但这种遍历方式只能遍历当tbtest中存在key为1的value时才会出现结果，而且是按照key从1开始依次递增1的顺序来遍历，否则返回0

tbtest = {
    ["a"] = 1,
    ["b"] = 2,
    ["c"] = 3,
    }
    print(#(tbtest)) 

 tbtest = {
        [1] = 1,
        [2] = 2,
        [6] = 6,
        }
print(#(tbtest))
--0
--2