Lua学习总结

• 目录

Lua简介

lua简介：

1. Lua是一个小巧的脚本语言。是巴西里约热内卢天主教大学（Pontifical Catholic University of Rio de Janeiro）里的一个研究小组，由Roberto Ierusalimschy、Waldemar Celes 和 Luiz Henrique de Figueiredo所组成并于1993年开发。 其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。Lua由标准C编写而成，几乎在所有操作系统和平台上都可以编译，运行。Lua并没有提供强大的库，这是由它的定位决定的。所以Lua不适合作为开发独立应用程序的语言。Lua 有一个同时进行的JIT项目，提供在特定平台上的即时编译功能。
2. Lua脚本可以很容易的被C/C++ 代码调用，也可以反过来调用C/C++的函数，这使得Lua在应用程序中可以被广泛应用。不仅仅作为扩展脚本，也可以作为普通的配置文件，代替XML,ini等文件格式，并且更容易理解和维护。 Lua由标准C编写而成，代码简洁优美，几乎在所有操作系统和平台上都可以编译，运行。 一个完整的Lua解释器不过200k，在目前所有脚本引擎中，Lua的速度是最快的。这一切都决定了Lua是作为嵌入式脚本的最佳选择。

**lua的目标：**其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。

Lua 应用场景：

1. 游戏开发
2. 独立应用脚本
3. Web 应用脚本
4. 扩展和数据库插件如：MySQL Proxy 和 MySQL WorkBench
5. 安全系统，如入侵检测系统

---

First Lua Program

print("Hello World!")
print "HelloWorld"

---

Lua基本语法

lua语法格式没有高级语言这么严格，好比说每句代码末尾的分号可加可不加
lua中不需要用类型来声明对象
脚本式编程：

 我们可以将 Lua 程序代码保持到一个以 lua 结尾的文件，并执行，该模式称为脚本式编程

注释：

--当行注释
--[[
多行注释
]]--

**标识符：**规则和c#的差不多
全局变量：
在默认情况下，变量总是认为是全局的。全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil

a = 10
print(a)
print(b)

--如果你想删除一个全局变量，只需要将变量赋值为nil
a = nil
print(a)

关键字：

---

Lua数据类型

Lua中有8中数据类型，分别是：nil、boolean、number、string、function、userdata（用户自定义类型）、thread、table。

测试：

print(type(nil))   --nil
print(type(true))  --boolean
print(type("cch")) --string
print(type(3.3))   --number
print(type({}))    --table
print(type(print)) --function

遍历一个table：

tab1 = {name = "cch",age = 22}
print(tab1.name)
for key,value in pairs(tab1) do
	print(key..":"..value)
end

nil在条件判断中代表false：

b = nil
if(b) then
	print(true)
else 
	print(false)
end

---

Lua变量

变量：

1. Lua 变量有三种类型：全局变量、局部变量、表中的域。
2. Lua 中的变量全是全局变量，那怕是语句块或是函数里，除非用 local 显式声明为局部变量。
3. 局部变量的作用域为从声明位置开始到所在语句块结束。
4. 变量的默认值均为 nil。

赋值语句：

1. 赋值是改变一个变量的值和改变表域的最基本的方法。
2. Lua可以对多个变量同时赋值，变量列表和值列表的各个元素用逗号分开，赋值语句右边的值会依次赋给左边的变量。

a,b,c = 10,4,5
print(a)
print(b)
print(c

索引：
对 table 的索引使用方括号 []。Lua 也提供了 . 操作。

tab1 = {name = "cch",age = 22}
print(tab1["name"]) --cch
print(tab1.name)   --cch

---

循环

Lua中提供了三种循环方式：while、for、repeat…until

while:

while(condition)
do
   statements
end

while循环测试：

a = 20
while(a > 0) do
	print(a)
	a = a - 1
end

---

for:

for var=exp1,exp2,exp3 do  
    <执行体>  
end  

var从exp1变化到exp2，每次变化以exp3为步长递增var，并执行一次"执行体"。exp3是可选的，如果不指定，默认为1。
for循环测试：

for i = 10,1,-1 do
	print(i)
end

---

repeat…until：

repeat
   statements
until( condition )

当until后面的条件语句为true时停止执行循环体，次循环的循环体至少执行一次
repeat…until循环测试：

a = 10
repeat
	print(a)
	a = a - 1
until(a <= 0)
	

循环嵌套（打印九九乘法表）：

for i = 1,9,1 do
	local str = "";
	for j = 1,i,1 do
		str = str .."\t".. j.."*"..i.."="..(i*j)
	end
	print(str)
end	

---

流程控制语句

Lua中只提供了if…else的流程控制语句，没有c#中的switch语句

if(条件)
then
    代码块
end

---

函数（function）

函数的定义：

optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
    function_body
    return result_params_comma_separated
end

解析：

1. optional_function_scope: 该参数是可选的制定函数是全局函数还是局部函数，未设置该参数默认为全局函数，如果你需要设置函数为局部函数需要使用关键字 local。
2. function_name: 指定函数名称。
3. argument1, argument2, argument3…, argumentn: 函数参数，多个参数以逗号隔开，函数也可以不带参数。
4. function_body: 函数体，函数中需要执行的代码语句块。
5. result_params_comma_separated: 函数返回值，Lua语言函数可以返回多个值，每个值以逗号隔开。

实例：

function Max(num1,num2)
	local maxNum
	if(num1 > num2) then 
		maxNum = num1
	else
		maxNum = num2
	end
	return maxNum
end
print(Max(2,3))

---

函数多返回值：
Lua函数可以返回多个结果值，比如string.find，其返回匹配串"开始和结束的下标"（如果不存在匹配串返回nil）。

function MaxAndMin(...)
	local tab = {...}
	local max = tab[1]
	local min = tab[1]
	for key,value in pairs(tab) do
		if(value > max) then
			max = value;
		end
		if(value < min) then
			min = value;
		end
	end
	return min,max
end
print(MaxAndMin(0,8,2,3,45))   --0 45
print(string.find("cchcch",'cch')) -- 1 3

---

可变参数
Lua 函数可以接受可变数目的参数，类似于c#中的params，在函数参数列表中使用三点 … 表示函数有可变的参数。

function Add(...)
	local tab = {...}
	local sum = 0
	for key,value in pairs(tab) do
		sum = sum + value;
	end
	return sum,#tab
end

print(Add(12,13,56))  --81 3

---

实例：Lua实现快速排序

function QuickSortUnit(tab,left,right)
	local temp = tab[left]
	while(left < right) do
		while(left < right and temp < tab[right]) do
			right = right - 1;
		end
		tab[left] = tab[right]
		while(left < right and temp >= tab[left]) do
			left = left + 1
		end
		tab[right] = tab[left]
	end
	tab[left] = temp
	return left
end

function QuickSort(tab,left,right)
	local index = QuickSortUnit(tab,left,right)
	if(left < right) then 
		QuickSort(tab,left,index-1)
		QuickSort(tab,index+1,right)
	end
end

tab1 = {45,32,23,16,9}
QuickSort(tab1,1,#tab1)
for key,value in pairs(tab1) do
	print(value)
end

---

运算符

运算符是一个特殊的符号，用于告诉解释器执行特定的数学或逻辑运算。Lua提供了以下几种运算符类型：

1. 算术运算符
2. 关系运算符
3. 逻辑运算符
4. 其他运算符

算术运算符：

关系运算符：

逻辑运算符：

其他运算符：

---

字符串

常用的一些函数：

1. string.upper(argument)
2. string.lower(argument)
3. string.gsub(mainString,findString,replaceString,num)
   在字符串中替换,mainString为要替换的字符串， findString 为被替换的字符，replaceString 要替换的字符，num 替换次数（可以忽略，则全部替换）
4. string.find (str, substr, [init, [end]])
   在一个指定的目标字符串中搜索指定的内容(第三个参数为索引),返回其具体位置。不存在则返回 nil。
5. string.reverse(arg)
6. string.format(…)
7. string.char(arg) 和 string.byte(arg[,int])
   char 将整型数字转成字符并连接， byte 转换字符为整数值(可以指定某个字符，默认第一个字符)。
8. string.len(arg)
9. string.rep(string, n)
10. …
11. string.gmatch(str, pattern)
    回一个迭代器函数，每一次调用这个函数，返回一个在字符串 str 找到的下一个符合 pattern 描述的子串。如果参数 pattern 描述的字符串没有找到，迭代函数返回nil。
12. string.match(str, pattern, init)
    string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。
    在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil。

测试：

print(string.upper("cch"))   --CCH
print(string.lower("CcH"))    --cch
print(string.gsub("cchcch",'cc','bb',2)) --bbhbbh
print(string.find("cchcch","cch"))  --1 3
print(string.reverse("cchcch"))    --hcchcc
print(string.format("this string is %s","cch"))  --this string is cch
print(string.char(67,68))    --CD
print(string.byte("CDAD",3)) --65(A)
print(string.len("cch"))     --3
print(string.rep("cch",3))   --cchcchcch
for word in string.gmatch("Hello Lua user", "%a+") do 
	print(word) 
end   --Hello Lua user
print(string.format("%d, %q", string.match("I have 2 questions for you.", "(%d+) (%a+)")))  --2, "questions"

---

数组与迭代器

Lua中的数组与c#不同，Lua中的数组下标从1开始，其他方面差不多

tab = {23,3,4,5,56,67}
for i=1,#tab do
	print(tab[i])
	i = i+1
end

迭代器：

tab = {23,3,4,5,56,67}
for k,v in pairs(tab) do
    print(v)
end

---

Lua table(表)

table表的介绍：

1. table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型，如：数组、字典等。
2. Lua table 使用关联型数组，你可以用任意类型的值来作数组的索引，但这个值不能是 nil。
3. Lua table 是不固定大小的，你可以根据自己需要进行扩容。
4. Lua也是通过table来解决模块（module）、包（package）和对象（Object）的。 例如string.format表示使用"format"来索引table string。

table表的常用方法：

测试：

-- table.concat(tab)     表连接  返回连接后的字符串
tab = {3,4,5,6,7,8}
print(table.concat(tab))        --345678
print(table.concat(tab,","))     --3,4,5,6,7,8
print(table.concat(tab," ",1,3)) --3 4 5

tab1 = {3,4,5,6,7}
table.insert(tab1,5,100);
for key,value in pairs(tab1) do
	print(key..":"..value)
end
--1:3
--2:4
--3:5
--4:6
--5:100
--6:7

--tab = {3,4,5,6,7,8}
table.remove(tab); --默认删除最后一个
table.remove(tab,4);
for key,value in pairs(tab) do
	print(key..":"..value)
end

-- table.sort(tab)  排序
tab = {3,4,5,6,7,8}
--table.sort(tab) --升序
table.sort(tab,function(a,b) return (a>b) end)  --降序

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

自定义迭代器：

tab2 = {1,2,3,4}
function fun(tab,index)
	index = index+1
	local value = tab[index]
	if(value) then 
		return index,value
	end
end

function selfpairs(tab)
	return fun,tab,0
end

for key,value in selfpairs(tab2) do
	print(key,value)
end

---

协程

Lua协程基本语法：

coroutine.create(方法) coroutine.resume(方法，参数)
创建协程，和唤醒协程，两个方法搭配起来使用

co = coroutine.create(
	function(i)
		print(i)
	end
)
coroutine.resume(co,1)  --1

coroutine.wrap(方法)
返回一个函数，一旦调用这个函数，就进入协程

co = coroutine.wrap(
	function()
		print("协程")
	end
)
co() --协程

coroutine.status(co)
获取协程的状态（三种状态：suspended挂起 dead死亡 running运行中）

co = coroutine.create(
	function(i)
		print(i)
	end
)
print(coroutine.status(co)) --suspended
coroutine.resume(co,1)       --1 
print(coroutine.status(co))  --dead

coroutine.yield(参数)
挂起协程，和resume()搭配只用，两个函数（或者说协程内部和外部）之间进行调用
resume和yield的配合强大之处在于，resume处于主程中，它将外部状态（数据）传入到协同程序内部；而yield则将内部的状态（数据）返回到主程中。

co = coroutine.create(
	function(i)
		num1,num2 = coroutine.yield(89)
		print(i,num1,num2) -- 1 2
	end
)
print(coroutine.status(co)) --suspended
print(coroutine.resume(co,1))   --true 89    
coroutine.resume(co,2,3)
print(coroutine.status(co))  --dead