Lua的学习-4-Table 表

一、Table 表的初始化

Lua的Table表涵盖了 集合，数组，可变数组，哈希（键值对）
1、初始化-数组下标方式
Lua的下标从 1 开始

--声明（按照数组方式）
--结果：len = 3,3，5，7
a = {3,5,7}
len = #a
p'rint("len = "..len)
for i = 1,len do
    print(a[i])
end

通过 #a 的方式获取长度是不准确的，特别是在table的元素中有两个nil，并且以nil为结尾时，这时可以通过table.maxn()方式

--结果len =7 ,末尾的nil 代表table的结束；如果采用的是#a,则此处结果为3
a = {3,5,7,nil,"a","b","c",nil}
len = table.maxn(a)
print("len="..len)

--结果：len=9
b = {3,5,7,nil,"a","b","c",nil}
b[9] = 78
len table.maxn(b)

从上可知，table的特性：
table是可变数组，可以增加其元素；table内部元素可以多类型；下标从1开始
如果一定要下标从0开始，可以用下面方法，但不推荐，很多标准库不能使用。

c = {[0]=3,5,7,nil,"a","b","c",nil}

2、初始化-键值对方式

声明 按照键值对方式

a = {x = 3,y=5,z="hello"}
a["n"] = "nnn"
a.m = "mmm"

len = table.maxn(a)
print("len="..len)
print("a.x ="..a.x)
print("a[\"y\"] = "..a["y"])
print(a.n)
--结果：len = 0  a.x =3  a[“y”] =5  nnn

通过键值对方式创建的table，不能使用maxn()方法获取长度；使用方括号[ ]方式获取值时，需要转义符

3、键值方式、数组方式混合型

a = {3，5，7；x = 3,y=5,z="hello"}
a["n"] = "nnn"
a.m = "mmm"

len = table.maxn(a)
print("len="..len)
print("a.x ="..a.x)
print("a[\"y\"] = "..a["y"])
print(a.n)
--结果：len = 3  a.x =3  a[“y”] =5  nnn

通过混合方式创建的table，maxn()方法只能获取到数组方式的长度；此处的“；”和“，”作用是一样的；但能让开发者更好的分辨；

4、键为特殊字符的方式

c={["+"]="a",["-"]="b" }
print(c["+"])
--结果：a  但是这种创建方式，不能通过c["+"]来获取某一元素的值。

二、二维数组

二维数组的写法也很灵活

--结果：能把数组里面所有的数据都输出
a = { {1,2,3},{"aa","bb","cc","dd","ee"} }
a[3] = {"张三","李四","王五"}
len = table.maxn(a)
innerLen = table.maxn(a[1])
for i = 1,len do
    innerLen = table.maxn(a[i])
    for j=1,innerLen do
        print(a[i][j])
    end
end

三、表 遍历

上面通过for循环也是一样遍历方式。

第二种方式：
for k,v in next,数组名称 do

end
nil被自动忽略,后面的数组类型元素会被放到键值对元素前面输出

--结果：1==3
2==5
3==7
5==a
x="hello"
m==mmm 

a = {3,5,7,nil,x="hello","a",nil}
a.m = "mmm"
for k,v in next, a do
    print(k.."=="..v)
end

第三种方式：
ipairs是关键字，只输出1，2，3等数组元素
for k,v in ipairs(a) do
print(k…==…v)
end

结果：
1==3
2==5
3==7

for k,v in ipairs(a) do
    print(k..==..v)
end

第四种方式：
pairs是关键字，可以输出所有元素,但是无序输出。pairs和ipairs关键字是迭代器

--结果同第二种方式
for k,v in pairs(a) do
    print(k..==..v)
end

四、数组元素的插入和删除

table插入：
table.insert(数组名,1,“aaa”)–向table头插入
table.insert(数组名,“ccc”) --向table尾插入；会自动插入到数组的末尾

--结果：
1==3
2==5
3==7
5==a
6==ccc
x="hello"
m==mmm 

a = {3,5,7,nil,x="hello","a",nil}
table.insert(a,"ccc")

for k,v in pairs(a) do 
    print(k.."="..v)
end

table删除
table.remove(数组名,1) --删除table头元素
table.remove(数组名) --删除table尾元素

--结果：
1==3
2==7
4==a
5==ccc
x="hello"
m==mmm 
table.remove(a,2)

–删除数组元素中的最后一位

--结果：
1==3
2==7
4==a
x="hello"
m==mmm 

table.remove(a)

–键值方式的删除
a.x = nil

五、加载和编译运行

多个lua文件的调用加载
1、dofile(“绝对路径\luaFile.lua”) --加载并执行
绝对路径中用“\”转义，这种方式非常不灵活。如果不加绝对路径，会报错。

2、loadfile(“luaFile.lua”) --加载并编译为中间码，不执行
assert() --可以返回更清楚的错误信息

--此种方法并不会执行，所以不会报错
file = loadfile("aa.file")

--用assert关键字之后才会执行，便会输出错误
local fun = assert(file)
fun()

加绝对路径之后，便不会报错。

3、loadstring(“字符串”) – 字符串当匿名函数用
通常用于运行程序外部的代码，比如运行用户自定义的代码。
可以用于：从服务端直接获取字符串代码；然后通过loadstring方法运行.

f = loadstring("print(\"aabbcc\")")
f()

d = loading("function aa(a,b) return a+b end")
d()
num = aa(3,9)t
print(num)  ---结果：12

4、require函数，常用
require函数会搜索目录加载文件，上面我们都是用绝对路径，现在通过require函数就可以使用相对路径。底层文件已经指向src路径下。
会判断文件是否已经加载，避免重复加载同一文件。

require("app.scenes.aa")
--在此文件中也可以调用aa文件中的方法

六、Table排序算法

1、冒泡排序
从小到大排序

arr = {19,3,25,11,17,2,98,27}
len = table.maxn(arr)
 
function sortArr()
    for i = 1,len do
        for j = i + 1,len do
            if arr[i] > arr[j] then
                arr[i],arr[j] = arr[j]arr[i]
            end
        end
    end
    for i = 1,len do
        print(arr[i])
    end
end

2、lua自带的table排序

--底层封装了冒泡排序,从大到小
table.sort(arr,function(a,b) return a>b end)
for i = 1,len do
        print(arr[i])
    end