Lua学习记录#

基础语法#

Lua中的变量#

Lua 是动态类型语言，变量不要类型定义,只需要为变量赋值。值可以存储在变量中，作为参数传递或结果返回。

数据类型	描述
nil	这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。
boolean	包含两个值：false和true。
number	表示双精度类型的实浮点数
string	字符串由一对双引号或单引号来表示
function	由 C 或 Lua 编写的函数
userdata	表示任意存储在变量中的C数据结构
thread	表示执行的独立线路，用于执行协同程序
table	Lua 中的表（table）其实是一个”关联数组”（associative arrays），数组的索引可以是数字、字符串或表类型。在 Lua 里，table 的创建是通过”构造表达式”来完成，最简单构造表达式是{}，用来创建一个空表。

变量在使用前，需要在代码中进行声明，即创建该变量。

编译程序执行代码之前编译器需要知道如何给语句变量开辟存储区，用于存储变量的值。

Lua 变量有三种类型：全局变量、局部变量、表中的域。

Lua 中的变量全是全局变量，哪怕是语句块或是函数里，除非用 local 显式声明为局部变量。

局部变量的作用域为从声明位置开始到所在语句块结束。

变量的默认值均为 nil。

字符串#

1
--字符串允许单双引号定义，使用\n或者[[]]方式定义多行字符串
2
a ="abc"
3
b= '哈哈哈'
4
c=[[
5
a
6
b
7
c
8
]]
9

10
print(a)
11
print(b)
12
print(c)
13

14
--字符串使用..进行拼接，使用#获取长度,字母占1位，汉字占三位
15
print(a..b)
16
print(#(a..b))
17
--使用%d,%f，%a，%s分别关联整形数字,浮点型数字，字符，字符串
18
a ="abc"
19
b= '哈哈哈'
20
c=233.333
21
print(string.format("a=%s,b=%s,c=%d,c2=%f",a,b,c,c))
22

23
--字符串类型转换
24
a=true;
25
print(tostring(a))
26
--小写转大写
27
a="Abc"
28
print(string.upper(a))
29
--大写转小写
30
print(string.lower(a))
31
--字符串截取
32
a="abcdefg"
33
print(string.sub(a,1,4))
34
--字符串查找
35
a="agbcdefg"
36
print(string.find(a,"cde"))--返回起始和结束位置
37
--字符串替换
38
a="acbcdefg"
39
print(string.gsub(a,"c","d"))--返回替换后的字符串和替换次数
40
--字符串长度
41
a="abcdefg"
42
print(string.len(a))
43
--字符串修改
44
a="abcabc"
45
print(string.gsub(a,"ab","**"))

运算符#

Lua中没有自增减和复合运算，例如++，—，+=,*=等等；

Lua的条件运算符除了不等于（!=）是~=，其他都一致;

Lua逻辑运算符是 and、 or、 not；

Lua不支持逻辑运算符、三目运算符；

流程控制与循环#

if条件分支语句#

注意写法就好，用法都一样

1
a= 1
2
if a==1 then
3
    print("a=1")
4
    a=2
5
elseif a==2 then
6
    print("a=2")
7
    a=3
8
else
9
    print("a=3")
10
end
11
--打印 a=1

循环语句#

1
--while
2
a=0
3
while(a<5) do
4
    print(a)
5
    a=a+1
6
end
7
--do while
8
b=0
9
repeat
10
    print(b)
11
    b=b+1
12
until b>5
13
--for
14
--for循环里前两个参数定义左右边界，第三个参数定义步长，第三个参数可以省略
15
for i=5,1,-1 do
16
    print(i)
17
end

函数#

1
--函数定义之后才能调用
2
--test(1)在这里调用会报错
3
function  test1()
4
    print("test1")
5
end
6
test1()
7
--第二种声明方式
8
test2 = function()
9
    print("test2")
10
end
11
test2()
12
--有参数的函数
13
function test3(a,b)
14
    print("两数之和"..a+b)
15
end

关于参数的特殊点需要注意：

1
function test3(a,b,c)
2
    print(a,b,c)
3
end
4

5
test3(1,true,"abc")
6
--如果参数没有填完整，也不会报错，只会赋值为nil
7
test3(1)
8

9
--Lua的函数允许设置任意长度参数
10
function test5(...)
11
    args={...}
12
    for i=1,#args do
13
        print(args[i])
14
    end
15
end
16

17
test5("one", "two", "three")

带返回值的函数

1
function test3(a)
2
    return a,true,"CS2";
3
end
4

5
print(test3(1))
6
--打印：1,true,CS2
7
temp1 = test3(1)
8
print(temp1)
9
--打印：1
10
temp1,temp2 = test3(1)
11
print(temp1,temp2)
12
--打印：1,true
13
temp1,temp2,temp3 = test3(1)
14
print(temp1,temp2,temp3)
15
--打印：1,true,CS2
16
temp1,temp2,temp3,temp4 = test3(1)
17
print(temp1,temp2,temp3,temp4)
18
--打印：1,true,CS2,nil

Lua不支持函数的重载，只会调用最近声明的函数

1
function test4()
2
    print("test4")
3
end
4

5
function test4(a)
6
    print(tostring(a).."最近的一个函数")
7
end
8

9
print(test4())
10
--打印nil最近的一个函数

闭包

1
--闭包 = 函数 + 创建时的词法环境。当 createCounter() 返回内部函数时：
2
--内部函数 永久持有 外部函数的 count 变量
3
--即使外部函数 createCounter() 已执行完毕，count 依然存活
4
function createCounter()
5
    local count = 0  -- 这个变量会被闭包"记住"
6

7
    return function()
8
        count = count + 1  -- 操作闭包捕获的count
9
        return count
10
    end
11
end
12

13
-- 创建两个独立的计数器
14
counterA = createCounter()
15
counterB = createCounter()
16

17
print(counterA())  --> 1
18
print(counterA())  --> 2
19
print(counterB())  --> 1
20
print(counterA())  --> 3

表#

表（table）是Lua的一种复杂数据类型，是一切复杂数据类型的基础，相当于数组。

基础用法#

Lua允许一个表中存入各种类型的变量，当nil在最后的位置时，将不计入长度，表从1开始遍历

1
a = {1,2,3,"a","bc",nil,true}
2
b = {1,2,3,"a","bc",true,nil}
3
c = {1,2,3,"a","bc",true,nil,nil,nil}
4
print(#a)--打印7
5
print(#b)--打印6
6
print(#c)--打印6
7

8
--多维表
9
a={{1,"a",false},{2,"b",true},{3,"c",false,"ssss"}}

遍历#

1
--遍历
2
for i=1,#a do
3
    print(a[i])
4
end
5

6
--多维表遍历
7
a={{1,"a",false},{2,"b",true},{3,"c",false,"ssss"}}
8

9
for i=1,#a do
10
    b=a[i]
11
    for j=1,#b do
12
        print(b[j])
13
    end
14
end

自定义索引#

1
--自定义索引
2
a = {[-1]=1,2,[0]=3,"a","bc",nil,true}
3
--打印1，3，2，a，bc，nil，true
4

5
print(#a)--打印5
6

7
--跳跃性地设置自定义索引会出问题
8
a = {[-1]=1, [1]=2, [8]=3, [3]=4, [4]=5}
9
for i = -1,#a do
10
    print(i,a[i])--只会打印-1和1的索引，以及0 nil
11
end
12
print(#a)--打印1

迭代器#

1
a = { [-1]=1,2,3,[8]=4,5,6}
2
--inpairs从1开始遍历，而且只遍历连续的索引
3
for i,v in ipairs(a) do
4
  print(i,v)
5
end
6
--inpairs遍历所有键值
7
for i,v in pairs(a) do
8
    print(i,v)
9
end
10
--遍历所有的键
11
for i in pairs(a) do
12
    print(i)
13
end

字典#

Lua实现字典的方式还是使用自定义索引，定义每一个键值对，如果在引用时使用没有出现过的键，则为nil，如果想要删除直接定义那个键的值为nil即可。

1
--字典
2
dict = {['a']='1'}
3
--新增
4
dict["b"]='2'
5
--删除
6
dict["a"]=nil
7
--修改
8
dict["b"]='3'
9
--遍历
10
for k,v in pairs(dict) do
11
    print(k,v)
12
end

表的公共操作#

1
t1 = {{age =1 , name = "tom"},{age =2 , name = "SB"}}
2
t2 = {age =3 , name = "CS"}
3

4
print(#t1)
5
--插入   把t2插入到t1中，t2消失
6
table.insert(t1,t2)
7
print(#t1)
8
print(#t2)
9
for i,v in pairs(t1) do
10
    print(v.age,v.name)
11
end
12

13
--移除  移除最后一位元素
14
table.remove(t1)
15
--移除指定位置的元素
16
table.remove(t1,1)
17
for i,v in pairs(t1) do
18
    print(v.age,v.name)
19
end
20

21
t2 = {4,87,32,2,3,66}
22
--排序  升序排序
23
table.sort(t2)
24
--降序排序 第一个参数是排序表，第二个是排序规则
25
table.sort(t2,function(a,b)
26
  return a>b
27
end)
28

29
for k,v in pairs(t2) do
30
  print(k,v)
31
end
32

33

34
--拼接  常用于拼接字符串,第一个是需要拼接的表，第二个是拼接符号
35
t3 = {"1","2","3"}
36
str=table.concat(t3,",")
37
print(str)

多脚本执行#

全局变量和本地变量#

Lua声明一个变量默认是一个全局变量，使用local修饰才能变成局部变量，for循环里的i也属于局部变量

1
for i=1,3 do
2
    print(i)
3
    j="存在"
4
end
5
print(i)--nil
6
print(j)--存在
7
function test()
8
    local a="不存在"
9
    b="存在"
10
end
11
test()
12
print(a)--nil
13
print(b)--存在

多脚本执行#

全局变量可以跨脚本执行，但局部变量不可以

在test2.lua添加如下代码

1
print("Test2")
2
testB="CS2"
3
local testLocalB="Local CS2"

test1.lua执行如下代码

1
--使用require执行test2.lua
2
require("test2")
3
print(testB)--输出CS2
4
print(testLocalB)--输出nil

脚本的加载与卸载#

require加载过一次后不会再被执行

1
--使用require加载过一次后不会再被执行
2
require("test2") --此时test2的print不再打印

脚本卸载

1
--使用require执行test2.lua
2
require("test2")
3
print(testB)--输出CS2
4
print(testLocalB)--输出nil
5

6
--使用require加载过一次后不会再被执行
7
require("test2") --此时test2的print不再打印
8
--判断脚本是否被执行
9
print(package.loaded["test2"])
10
--卸载脚本
11
package.loaded["test2"]=nil
12
print(package.loaded["test2"])

大G表#

1
--_G表是一个总表，将我们的所有全局变量都存储在其中,本地变量不会存储
2
for k,v in pairs(_G) do
3
    print(k,v)
4
end

虽然不会存储局部变量，但我们可以在一个脚本里return一个局部变量，然后去获取它

1
--tets2.lua
2
print("Test2")
3
testB="CS2"
4
local testLocalB="Local CS2"
5
return testLocalB
6

7

8
--test1.lua
9
local testB = require("test2")
10
print(testB)--打印Local CS2

协程#

协程的创建#

1
fun = function(a)
2
  print(a)
3
end
4

5
--协程的本质是创建一个线程对象
6
co = coroutine.create(fun)
7

8
print(co)
9
print(type(co))
10
--这种方式创建就是一个函数
11
co2 = coroutine.wrap(fun)
12
print(co2)
13
print(type(co2))

协程的挂起#

1
fun = function()
2
    local a=1
3
    while true do
4
        print(a)
5
        a=a+1
6
        --挂起协程，下一次执行协程继续在这个while循环里执行,返回a的值
7
        coroutine.yield(a)
8
    end
9
end
10
--创建但不执行
11
co= coroutine.create(fun)
12
--执行
13
coroutine.resume(co)
14
coroutine.resume(co)
15
coroutine.resume(co)
16
coroutine.resume(co)
17
--此时a=5
18
isOK,tempA=coroutine.resume(co)
19
--再次执行后a=6
20
print(isOK,tempA)--打印true,6
21

22
temp = coroutine.wrap(fun)
23
print(temp())

协程的状态#

1
fun = function()
2
    local a=1
3
    while a<2 do
4
        print(a)
5
        a=a+1
6
        --打印协程运行（runing）状态
7
        print(coroutine.status(co))
8
        coroutine.yield(a)
9
    end
10
end
11
--创建但不执行
12
co= coroutine.create(fun)
13

14
coroutine.resume(co)
15
--打印协程挂起（suspended）状态
16
print(coroutine.status(co))
17

18
--打印协程结束（dead）状态
19
coroutine.resume(co)
20
print(coroutine.status(co))

元表#

概念#

表的元数据：每个表可关联一个元表（通过setmetatable），用于定义该表的特殊行为元方法机制：通过预定义键（如__index, __add）挂载函数来实现功能扩展

1
--任何表变量都可以作为另一个表的元表
2
--任何表变量都可以有自己的元表
3
--当字表进行一些操作时会执行元表中的操作
4
meta = {}
5
myTable={}
6
--第一个是子表，第二个是元表
7
setmetatable(myTable,meta)

元表的特定操作#

__tostring#

1
meta ={
2
    --当字表要当做字符串时，调用__tostring方法
3
    __tostring =function(t)
4
        return t.name
5
    end
6
}
7

8
myTable={
9
    name="donk666",
10
}
11
print(myTable)--打印table: 00CE9710
12
setmetatable(myTable,meta)
13
print(myTable)--打印donk666

__call#

1
meta2 ={
2
    --当子表要当做函数时，调用__call方法
3
    --__call默认第一个参数是表本身
4
    __call =function(a,b)
5
        print(a.name)
6
        print(b)
7
    end
8
}
9

10
myTable2={
11
    name="donk666",
12
}
13

14
setmetatable(myTable2,meta2)
15

16
myTable2("niko")--打印donk666  niko

运算符重载#

1
meta ={
2
    --运算符重载，当子表使用+-*/^%等运算符时会调用方法
3
    --运算符+
4
    __add = function(t1,t2)
5
        return t1.age + t2.age
6
    end,
7
    --运算符-
8
    __sub = function(t1,t2)
9
        return t1.age - t2.age
10
    end,
11
    --运算符*
12
    __mul  = function(t1,t2)
13
        return t1.age * t2.age
14
    end,
15
    --运算符/
16
    __div = function(t1,t2)
17
        return t1.age / t2.age
18
    end,
19
    --运算符%
20
    __mod = function(t1,t2)
21
        return t1.age % t2.age
22
    end,
23
    --运算符^
24
    __pow = function(t1,t2)
25
        return t1.age ^ t2.age
26
    end,
27
    --运算符<
28
    __lt = function(t1,t2)
29
        return t1.age < t2.age
30
    end,
31
    --运算符<=
32
    __le = function(t1,t2)
33
        return t1.age <= t2.age
34
    end,
35
    --运算符==
36
    __eq = function(t1,t2)
37
        return t1.age == t2.age
38
    end,
39
    --运算符..
40
    __concat  = function(t1,t2)
41
        return t1.age .. t2.age
42
    end,
43

44

45
}
46

47
myTable1 = {
48
    age = 10
49
}
50
myTable2 ={
51
    age = 20
52
}
53
setmetatable(myTable1, meta)
54

55
print(myTable1 + myTable2)
56
print(myTable1 - myTable2)
57
print(myTable1 * myTable2)
58
print(myTable1 / myTable2)
59
print(myTable1 % myTable2)
60
print(myTable1 ^ myTable2)
61
--如果使用条件运算符重载，必须设置两个字表的元表一致
62
setmetatable(myTable2, meta)
63
print(myTable1 < myTable2)
64
print(myTable1 <= myTable2)
65
print(myTable1 == myTable2)
66
print(myTable1 .. myTable2)

__index#

1
meta ={
2
    age = 1
3
}
4
myTable ={
5

6
}
7
setmetatable(myTable,meta)
8
--子表中找不到指定属性时，会去元表的__index指定的表查找
9
print(myTable.age)--打印nil
10
--__index最好写在表外部,不然可能出问题
11
meta.__index = {age = 2}
12
print(myTable.age)--打印2

__newindex#

1
meta ={
2

3
}
4

5
myTable ={
6

7
}
8
myTable.__newindex = {}
9
setmetatable(myTable,meta)
10
--当赋值时赋值给一个不存在的索引，则会把值赋到newindex所指的表中，不会修改自己
11
myTable.age = 1
12
print(myTable.age)

面向对象#

类与结构体#

Lua并没有面向对象概念，只是通过结构体模仿面向对象来操作，但结构体本质上还是表。

1
Student  = {
2
    name = "Tom",
3
    age = 18,
4
    isCS = true,
5
    show = function(a)
6
        print(a.name, a.age,a.isCS)
7
    end
8
}
9

10
Teacher = {
11
    name = "Jerry",
12
    age = 30,
13
    show = function(a)
14
        print(a.name, a.age)
15
    end
16
}
17

18
print(Student.name)--打印Tom
19
-- .调用方法就是正常调用
20
Student.show(Student)--打印Tom 18 true
21
Student.show(Teacher)--打印Jerry 30 nil
22
--  :调用方法会把调用者作为第一个参数传入方法中
23
Student:show()--打印Tom 18 true     Student:show()等价于Student.show(Student)
24
--表在声明之后可以在表外修改变量和方法
25
Student.name="NM"
26
--还可以新增变量
27
Student.AA="asdda"
28
--也可以修改函数方法
29
Student.show = function(a)
30
    print(a.name, a.age,a.isCS,a.AA)
31
end
32
Student:show()

关于符号 : 和 . 还是补充说明一下，使用：调用方法只是把调用者作为第一个参数传入，如果函数后续还有参数则还需要额外传入；

1
Student  = {
2
    name = "Tom",
3
    age = 18,
4
    isCS = true,
5
    show = function(a,b)
6
        print(a.name, a.age,a.isCS,b)
7
    end
8
}
9
Student:show() --打印Tom  18  true  nil
10
Student:show(23333)--打印Tom  18  true  23333

使用：声明一个方法相当于把自身作为一个参数，常常配合self用于在声明之后的外部使用， self是一个关键字，表示默认传入调用者为第一个参数

1
Student  = {
2
    name = "Tom",
3
    age = 18,
4
    isCS = true,
5
    --这里的self只是作为一个参数来使用，不是关键字
6
    show = function(self, b)
7
        print(self.name, self.age, self.isCS, b)
8
    end
9
}
10
--和上面的方法完全等价，self相当于Student，
11
function Student:show(b)
12
    print(self.name, self.age, self.isCS, b)
13
end
14
Student:show() --打印Tom  18  true  nil
15
Student:show(23333)--打印Tom  18  true  23333

封装#

1
Object ={}
2
Object.id =1
3

4
function Object:Test()
5
    print(self.id)
6
end
7

8
function Object:new()
9
    local obj ={}
10
    self.__index =self
11
    setmetatable(obj,self)
12
    return obj
13
end
14

15
local myObj=Object:new()
16
print(myObj.id)
17
myObj:Test()

pixelmoe的个人博客!

Lua学习记录#

基础语法#

Lua中的变量#

字符串#

运算符#

流程控制与循环#

if条件分支语句#

循环语句#

函数#

表#

基础用法#

遍历#

自定义索引#

迭代器#

字典#

表的公共操作#

多脚本执行#

全局变量和本地变量#

多脚本执行#

脚本的加载与卸载#

大G表#

协程#

协程的创建#

协程的挂起#

协程的状态#

元表#

概念#

元表的特定操作#

__tostring#

__call#

运算符重载#

__index#

__newindex#

面向对象#

类与结构体#

封装#