table是lua中一种很常见，很多用处的数据类型。目前你可以把它理解为C#中的ArrayList什么都可以装。申明方式也很简单

        表名 = {} 这样就是一个表了

首先我们来讲讲表作为数组的使用

------------------------------------------------------表作为数组的时候---------------------------------------------------

一、表作为一维数组

-- 数组 数组的遍历 里面的类型都可以不一样
-- lua的数组是从1开始的
a = {10,20,30,40,50,"LLL"}
print("数组的长度为"..#a)
print(a[1])

        正如代码所示，这样你就正确的写了一本表出来了，同时你还获取到了他的长度，也就是表有多少个元素，表内部肯定还是可以存表的，也就是表的嵌套

下面展示作为一维数组 该怎么进行遍历 采用for循环进行的遍历

-- 数组的遍历
for i = 1,#a do
    print("a["..i.."]="..tostring(a[i]))
end

但是！这里有一个坑！这个坑就是 通过#获取长度的方式并不可靠，如果中间某个元素为nil的话，那么你获取到的表长就会中断，只会获取到nil以前的长度。这个我们后面有别的解决方式，不过这里千万要记住这里的局限性！

二、表作为二维数组

        上面提到了一维数组，它内部可以装任何的数据，自然也是可以装表的。如下面所示：

-- 申明了一个二维数组
a = {{1,2,3},
    {4,5,6},
    {7,8,9}}
print("二维数组的长度为"..#a)
print(a[1][2])

-- 二维数组的遍历
for i = 1,#a do
    for j = 1,#a[i] do
        print("a["..i.."]["..j.."]="..tostring(a[i][j]))
    end
end

三、自定义索引        

        这是什么意思呢，这个的意思就是说，表内部是默认按照1 2 3的顺序给每个元素排座位的，我们可以自己手动修改，例如 0 -1 ，这样子都是可以的，请看下面的代码，但是这样的话想要遍历就显得很困难了，需要我们采用其他的方法！我们后面介绍

-- 自定义索引 允许乱改索引 然后访问 长度计算很奇怪
-- 如果中间断了一个数 那么会按照最大长度计算
-- 断了很多的话 那么就会中断
aa = {[0] = 595,5,22,[-2]   = "hello"}
print("aa[0]="..tostring(aa[0]))
print("aa[1]="..tostring(aa[1]))    
print("aa[-2]="..tostring(aa[-2]))
print("aa[2]="..tostring(aa[2]))
print("aa的长度为"..#aa) -- 只计算正索引的部分

PS：除了这种自定义索引，我们还可以采用某一个元素是什么的方式，类似字典的配对，只不过这个更加的灵活了，不会限制死变量类型了。如下

t = {
    namee = "xiaohong",
    sex = true,
    [0] = 989
}
-- 这种访问方式 后面会再见的
print(t.namee)

--------------------------------------------------表的遍历---------------------------------------------------------------

上文提到了 通过#获取表长 然后进行遍历表的操作是不完善的。接下来介绍两种通过迭代器遍历表的方法

四、遍历表的方法1——ipairs

这个其实和上面差不多 也是只能遍历连续表 不能遍历中断的 所以真要遍历表 还得看法二

-- ipairs 遍历 还是从1开始往后遍历的 小于等于0的索引不会被遍历到
-- 只能找到连续索引键值 如果中间断续了 他也无法遍历后面的内容
print("ipairs遍历")
a = {[0] = 1,2,[-1] = 3,4,5,[5] = 6}
for i,k in ipairs(a) do
    print("i="..i.." k="..tostring(k))
end

五、遍历表的方法2——pairs

这个就可以很好的适应我们得需求了，可以遍历不规则的表了

-- pairs 遍历 可以遍历所有的键值对 包括负数索引和非连续索引
-- 通过键获得值 可以得到所有信息 可以遍历任何不规则的表
print("pairs遍历")
for i,k in pairs(a) do
    print("i="..i.." k="..tostring(k))
end

PS:上面都是键值对一起遍历的，我们也可以只单独遍历键，例如：

-- 也可以只遍历键
print("只遍历键")
for i in pairs(a) do
    print("i="..i)
end 
for i in ipairs(a) do
    print("i="..i)
end 

---------------------------------------------------表的其他用法----------------------------------------------------------

六、表作为字典

上文提到，表就是以键值对的形式存在的，所以我们用表作为字典简直就是完美无缺。如下所示：

-- 字典是由键值对的时候构成的
a = {
    ["name"] = "小红",
    ["age"] = 18,
    ["height"] = 1.75,
    ["weight"] = 70.5
}

        关于表中的元素的访问，除了前面提到的采用中括号 [数字索引]的形式访问 还可以通过 表名.变量来使用，不过这种方式只适合于变量为字符串的时候使用。为数字时不适合 。新增元素就是直接在表中添加一个新纪录就行，删除的话，一般来说置为nil就行。如下所示：

-- 访问单个变量就是使用中括号 键访问
print(a["name"])
print(a["age"])
-- 还可以使用点号访问 虽然可以这样访问 但是不能访问数字 只能字符串
print(a.name)
a["name"] = "小明"
print(a.name)
-- 新增
a["sex"] = false
print(a["sex"])
-- 删除 就是让某个元素为nil 置空就是删除
for i, k in pairs(a) do
    -- print(i,k)可以传多个参数
    print(i, k, 1, 2, 3)
end
-- 其实_也是一个变量名罢了
for _, k in pairs(a) do
    -- print(i,k)可以传多个参数
    print(_, k, 1, 2, 3)
end

七、表作为类或者结构体使用

        如下所示，我们直接在表内部按照成员变量，成员方法的书写，就相当于是我们在C#中对于类的声明和创建了。

        不过有一些需要注意的点是：

        1、你在表中声明的成员变量，你如果在函数中你是不能直接调用的（看下面的age代码），你需要通过  表名.变量的形式才能使用  或者你在声明函数的时候就直接把自己给传进去

        2、在lua中，我们如果想在表外部调用表中的函数，一般有两种方式

1）通过 . 的方式 例如这样Stduent.Down(Stduent)

2）通过 : 的方式 例如这样Stduent:Down()

那这样会有什么不同呢，不同之处就是 采用：会将前面的调用者默认作为参数 传入到函数中

-- lua中是默认没有面向对象的 需要我们自己来实现
-- 成员变量 成员函数
Stduent = {
    -- 名字
    name = "lqc",
    -- 年龄
    age = 18,
    -- 在表中的函数的第一种声明方式
    Up = function()
        -- 这样写 是错误的 是空的 这个age和表中的age没有关系 他是一个全局变量
        -- print(age)
        -- 想要在表内访问表的成员变量 需要通过表名来访问
        -- 正确的方式1 使用表名.成员变量名 或 表名.成员函数名
        print("年龄是" .. Stduent.age)
        print("我上升了")
    end,
    Down = function(t)
        -- 正确的方式2 能够在函数内部调用自己属性或者方法的方
        -- 把自己作为一个参数传进来 在内部访问
        print("年龄是" .. t.age)
        print("我下降了")
    end,
    Learn = function(subject)
        print("我在学习" .. subject)
    end
}
-- 函数的使用情况
Stduent.Learn("Lua")
Stduent.Up()
-- 在lua中 .和:的区别
-- 使用.调用函数的时候 需要手动传入表名作为参数
Stduent.Down(Stduent)
-- 使用:调用函数的时候 会自动把调用者作为第一个参数传入
-- 使用的时候 不需要传入参数 因为会自动传入 声明的时候也可以这样
-- 然后用关键字self来接收这个参数 self就是调用者自己 看下面的sayhello_2函数
Stduent:Down()

        当然 除了在内部写好的变量或者函数外 我们还可以在外部新增 变量或者新增函数 。

        这里也有两种声明方式，一种是通过 表名.函数名 然后创建一个新函数 一种是通过: 创建一个新函数如下：

通过 . 这样就和前面学的申明function差不多了 这里有两种方式声明function

-- 声明表之后 在表外可以新增成员 新增变量或者函数
Stduent.sex = "男"
print("性别是" .. Stduent.sex)
-- 在表中的函数的第二种声明方式
Stduent.SayHello_1 = function()
    print("Hello Lua Class!")
end
Stduent.SayHello_1()
-- 在表中的函数的第三种声明方式
function Stduent.SayHello_2()
    print("Hello Lua Class 2!")
end

通过：声明function 那就不能用一个函数来接收了 只能采取第二种声明function的方法了 如下。同时呢 在这里我们又遇到了一个新的关键字 那就是self 这个关键字就是代表的第一个传入的参数 也就是student

-- 使用：声明
-- 注意 这种声明方式 只能后面要写名字 不能前面用一个变量进行函数接收
-- self 代表的不是自己 而是第一个默认传入的参数
function Stduent:SayHello_3()
    print(self.name .. "Hello Lua Class 3!")
end

--------------------------------------------------------------表内部的一些方法--------------------------------------

八、表内部的方法介绍

-- 表中 table提供的一些公共方法的学习
t1 = {{age = 1,name = "小明"},{age = 2,name = "小红"},{age = 3,name = "小刚"}}
t2 = {age = 4,name = "小李"}

1、insert 插入方法 我们可以在一个表后面插入另外一个表

-- 插入元素 在表的末尾插入一个元素
table.insert(t1,t2)
print("表t1的长度为"..#t1)
for i,k in pairs(t1) do
    print(i,k.name,k.age)
end
-- 还可以在指定位置插入指定元素
-- 例如
t5 = {10,20,30,40,50}
table.insert(t5,2,6) -- 在第3个位置插入25
for i = 1,#t5 do
    print("t5["..i.."]="..t5[i])
end

2、remove 删除末尾元素方法 这个还可以删除指定位置的元素

-- 删除元素 删除表中指定位置的元素
-- 传表进去 会移除最后一个索引的内容
table.remove(t1)
print("表t1的长度为"..#t1)
for i,k in pairs(t1) do
    print(i,k.name,k.age)
end

-- 删除指定位置的元素
-- 第一个参数就是需要移除元素的表 第二个参数是位置索引
table.remove(t1,2)
for i,k in pairs(t1) do
    print(i,k.name,k.age)
end

3、sort 排序方法 支持自定义排序

t3 = {5,3,8,1,2,7,4,6}
-- 这里有一个排序方法
-- 可以传入两个参数 第一个参数是需要排序的表 第二个参数是一个函数 用于定义排序规则
-- 如果不传入第二个参数 默认是升序排列
table.sort(t3)
for i = 1,#t3 do
    print("t3["..i.."]="..t3[i])
end
-- 还可以自定义排序
table.sort(t3,function(a,b)
    -- 降序排列
    return a > b
end)
for i = 1,#t3 do
    print("t3["..i.."]="..t3[i])
end

4、concat 将表中元素按照 特殊连接符号进行拼接 会返回一个拼接好的字符串

-- 拼接
-- 把表中的元素按照指定的分隔符 拼接成一个字符串
-- 第一个参数 是需要拼接的表 第二个参数是分隔符
-- 第三个参数是开始索引 可选 第四个参数是结束索引 可选
-- 一般是用于字符串的表进行拼接 或者最多有数字的表进行拼接
tb = {"Lua","C#","Python","Java"}
str = table.concat(tb,"-",2,3) -- 从第2个到第3个进行拼接
print("拼接结果为"..str)

好的！今天关于表的介绍就到这里了，欢迎你的收看，我们下一篇文章再见！