lua学习笔记2--table

table是lua中的一种"数据/代码结构",可以用俩创建不同的"数据类型"
lua语言中的数组其实就是table类型

array = {1, 2, 3, 4, 5}
print(type(array))    --table

table基本使用:
1.初始化table
　　table 表名 = {}

myTable = {}

2.给table赋值
　　数组方式:以角标的方式进行赋值,索引从1开始
　　键值对方式

myTable[1] = "baidu"
myTable[2] = "taobao"
myTable[3] = "jd"
myTable["a"] = "asd"
myTable["xxx"] = "xxx"

迭代器方式遍历table:如果是数组用ipairs,如果是键值对,用pairs
for key, value in ipairs(表名) do
　　代码体
end

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

table相关方法
1.增加元素 table.insert(表名,[位置],值)
　　往指定位置增加元素,如果不写元素,默认往最后位置增加
　　这个方式适合"数组",不太适合"键值对"
　　键值对就用:表名['键']=值 的方式添加
2.移除元素 table.remove(表名,[位置])
　　如果超出范围,不会报错也不会移除任何元素
　　这个方式适合"数组",不能用于"键值对"
　　键值对就用:表名['键']=nil 的方式移除
3.获取长度 table.getn(表名)
　　这个方式适合"数组",不能用于"键值对"

table.insert(myTable, 1, "toutiao")
table.insert(myTable, "360")
myTable["abc"] = "abc"

table.remove(myTable)
myTable["xxx"] = nil

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

模块:
将一些常用的函数封装到一个独立lua脚本中,然后提供给其他的lua脚本访问使用,这种方式在lua中叫做模块
模块当中基本的成员就是变量和函数
类似于c#中的静态工具类
lua当中的模块,在语法格式上类似于命名空间,需要引入才能使用

模块的基本使用:
　　创建一个新的lua脚本,并命名
　　初始化模块:模块其实也是table的代码格式,说白了就是初始化一个table
　　在模块中定义变量和函数
　　模块的最后要写return模块名
　　**在定义变量和函数的时候,名称前面必须加"模块名."
　　**最终格式:模块名.变量名 模块名.函数名

--初始化模块
testModule = {}

--定义一个变量
testModule.name = "ABCD"

--定义函数
function testModule.add(a, b)
    return a + b
end

function testModule.sub(a, b)
    return a - b
end

--结束模块
return testModule

使用模块:
　　引入模块 require("模块名") 或者 require "模块名"
　　访问变量: 模块名.变量名
　　访问方法: 模块名.函数名

--引入指定模块
require("testModule")

--访问模块中的变量
print(testModule.name)
testModule.name = "abcd" --可以修改模块中变量的值
print(testModule.name)

--访问模块中的函数
a = 10
b = 20
print(testModule.add(a,b))
print(testModule.sub(a,b))

Metatable元表
如果想同时操作两个table,就需要让两个table之间发生"关联"
元表就是让两个表之间产生"附属"关系,只需要操作主表,就可以间接的操作元表

元表基本操作
1.基本语法
实例化两个普通表A,B
关联两个表,将表B设置成表A的元表:setmetatable(表A, 表B)

getmetatable(表名)
如果表名有元表,就返回元表的类型和地址;如果没有元表,返回nil

可以直接通过"表名.键名"访问表A中的成员,但是元表内的成员是无法访问到的,会返回nil

我们需要设置元表的"__index索引",让这个索引指向元表自身:
元表名.__index = 元表名 (两个下划线)

设置完__index索引后,我们再使用"表名.键名"访问成员,如果表A中没有,就会自动访问表B中的成员

__index 元方法

当你通过键来访问 table 的时候，如果这个键没有值，那么Lua就会寻找该table的metatable（假定有metatable）中的__index 键

如果__index包含一个表格，Lua会在表格中查找相应的键。

tableA = { name = "tableA", age = 100 }    　　 --主表
tableB = { gender = "男", address = "成都" }    --元表/子表
--设置元表
setmetatable(tableA, tableB)    --tableB就是tableA的元表

print(getmetatable(tableA))     --判断tableA是否有元表

print(tableA.name)    　 --tableA
print(tableA.gender)     --nil    无法直接访问元表的成员

tableB.__index = tableB    --设置元表的__index索引
print(tableA.gender)    　　--男    A中没有该成员,自动访问元表中的成员数据 

table本身是引用型数据
类:就是初始化一个table
类中的字段:在table的{}内进行定义,可以指定初始值
类中的方法: 类名:方法名
self关键字:类似于c#中的this

访问对象中的字段: 对象名.字段名 (.号)
访问对象中的方法: 对象名:方法名 (:号)--初始化一个类

Person = { name, age, gender, address = "中国" } --在Person类中模拟字段

--模拟构造方法
function Person:New(name, age, gender, address)
　　local obj = {} --初始化一个新表
　　setmetatable(obj, self)      --把当前的类[表]设置为新表的元表
　　self.__index = self      　   --指定元表的__index索引

　　self.name = name
　　self.age = age
　　self.gender = gender
　　self.address = address

　　return obj
end

--模拟一个方法
function Person:Show()
　　print(string.format("name:%s,age:%s,gender:%s,address:%s",self.name, self.age, self. gender, self.address))
end

--实例化一个对象
cxk = Person:New("cxk",100,"男","北京")
cxk:Show()    --name:cxk,age:100,gender:男,address:北京

 继承关系模拟

--创建一个动物类
Animal = { name }
--构造方法
function Animal:New(name)
    local obj = {}
    setmetatable(obj, self)
    self.__index = self
    self.name = name
    return obj
end
--普通方法
function Animal:ToString()
    print(self.name .. " ToString")
end

--子类继承父类
Cat = Animal:New(nil)
--子类的构造方法
function Cat:New(name)
    local obj = Animal:New(name)
    setmetatable(obj, self)
    self.__index = self
    --self.name = name
    return obj
end
--子类的普通方法
function Cat:Eat(food)
    print(self.name .. " eat " .. food)
end

--通过子类实例化对象
jfm = Cat:New("jfm")
jfm:ToString()
jfm:Eat("food")

加载其他文件:

dofile("[路径]脚本名.lua")
如果当前脚本和加载的脚本在同一文件夹下,只需写脚本名
如果当前脚本和加载的脚本不在同一文件夹下,需要写路径
路径..\\表示上一级目录 \\两个斜杠其中一个表示转义符
dofile("aaa\\bbb\\x.lua")
dofile("..\\aaa\\bbb\\x.lua")

 Animal.lua:

Animal = { name }

function Animal:New(name)
    local obj = {}
    setmetatable(obj, self)
    self.__index = self
    self.name = name
    return obj
end

function Animal:ToString()
    print(self.name .. " ToString")
end

Person.lua

Person = { name, age, gender, address }

function Person:New(name, age, gender, address)
    local obj = {}
    setmetatable(obj, self)
    self.__index = self
    self.name = name
    self.age = age
    self.gender = gender
    self.address = address
    return obj
end

function Person:ToString()
    print(self.name, self.age, self.gender, self.address)
end

Program.lua

dofile("Animal.lua")
dofile("Person.lua")

tom = Animal:New("汤姆")
tom:ToString()

mk = Person:New("mk", 88, "男", "北京")
mk:ToString()