概述：
Lua 是一种轻量小巧的脚本语言，用标准 C 语言编写并以源代码形式开放，其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。
一、变量
Lua 是动态类型语言，变量不要类型定义。Lua 变量就两种类型：全局变量、局部变量。
使用 local 关键字声明的、在函数体内的，就是局部变量。其它都是全局变量。
-- test.lua 文件脚本
a = 5 -- 全局变量
local b = 5 -- 局部变量
function funcationName()
c = 5 -- 局部变量
local d = 6 -- 局部变量
end
print(a, b, c, d) -- 打印值为：5 5 nil nil
二、循环和流程控制语句
2.1、while 循环
while( true )
do
print("循环将永远执行下去")
end
--实例
i = 1
while(i < 5)
do
i = i + 1
print(i)
end
2.2、for 循环
数值 for 循环：
var 从 exp1 变化到 exp2，每次变化以 exp3 为步长递增 var，并执行一次"执行体"。exp3 是可选的，如果不指定，默认为 1。
for var=exp1,exp2,exp3 do
<执行体>
end
--实例
for i=1, 10, 1 do
print(i)
end
泛型 for 循环：
i 是数组索引值，v 是对应索引的数组元素值。ipairs 是 Lua 提供的一个迭代器函数，用来迭代数组。
--打印数组 a 的所有值
for i,v in ipairs(a)
do print(v)
end �
--实例
array = {
"value1",
"value2",
"value3"
}
for i,v in ipairs(array) do
print(i,v)
end
2.3、repeat...until 循环
repeat...until 循环和 C 语言里面的 do...while() 作用是一样的。
repeat
statements
until( condition )
--实例
i = 1
repeat
i = i + 1
print(i)
until(i > 5)
2.4、if 语句
if 语句：
if(布尔表达式)
then
--[ 在布尔表达式为 true 时执行的语句 --]
end
if...else 语句：
if(布尔表达式)
then
--[ 布尔表达式为 true 时执行该语句块 --]
else
--[ 布尔表达式为 false 时执行该语句块 --]
end
三、运算符
Lua 提供了以下几种运算符类型：
- 算术运算符
- 关系运算符
- 逻辑运算符
- 其他运算符
3.1、算术运算符
算术运算符就是加法、减法、乘法、乘法、取余等这些。和 C 语言是一样的。
3.2、关系运算符
关系运算 就是等于、不等于、大于、大于等于、小于等于、小于。
3.3、逻辑运算符
- and 逻辑与操作符。
- or 逻辑或操作符。
- not 逻辑非操作符。
a = true
b = true
-- and
if ( a and b )
then
print("a and b - 条件为 true" )
end
-- or
if ( a or b )
then
print("a or b - 条件为 true" )
end
-- not
if ( not( a and b) )
then
print("not( a and b) - 条件为 true" )
else
print("not( a and b) - 条件为 false" )
end
3.4、其他运算符
“..”，连接两个字符串。
“#”，一元运算符，返回字符串或表的长度。
“~”，相当于 C 中的“!”。
a = "Hello"
b = "World"
if a ~= b then
end
print("连接字符串 a 和 b ", a..b )
print("b 字符串长度 ", #b )
print("字符串 Test 长度 ", #"Test" )
print("Mob 网址长度 ", #"www.mob.com" )
四、基本类型
Lua 中有 8 个基本类型分别为：nil、boolean、 number、string、userdata、function、thread 和 table。
nil 类型。表示一个无效值。
boolean 类型。false 和 true。
number 类型。表示双精度类型的实浮点数。
string 类型。字符串由一对双引号或单引号来表示。
function 类型。由 C 或 Lua 编写的函数。
userdata 类型。表示任意存储在变量中的 C 数据结构。
thread 类型。表示执行的独立线路，用于执行协同程序。
table 类型。Lua 中的表（table）其实是一个“关联数组”（associative arrays），数组的索引可以是数字或者字符串。在 Lua 里，table 的创建是通过“构造表达式”来完成，最简单构造表达式是{}，用来创建一个空表。
其中 nil、boolean、 number、string 这四种类型和其它语言中的类型的使用都是类似的。 function 和 table 这两种类型，会在本篇后面部分详细讲解，userdata 和 thread 暂时先不讲。
五、table 类型
table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型，如：数组、字典等。
Lua table 使用关联型数组，你可以用任意类型的值来作数组的索引，但这个值不能是 nil。
Lua table 是不固定大小的，你可以根据自己需要进行扩容。
Lua 也是通过 table 来解决模块（module）、包（package）和对象（Object）的。
5.1、table 的构造
-- 创建一个表
mytable = {}
-- table 里面值的设置和获取
mytable[1] = "元素1"
mytable["er"] = "元素2"
print("mytable 索引为 1 的元素", mytable[1])
print("mytable 索引为 er 的元素", mytable["er"])
5.2、table 模拟数组
-- 数组，lua里面的元素是从 1 开始的
array = {
"value1",
"value2",
"value3"
}
-- 数组里面值得获取
print(array[1], array[2], array[3])
5.3、table 模拟字典
-- 字典
dictionary = {
key1 = "value1",
key2 = "value2",
key3 = "value3"
}
-- 字典里面值得获取
print(dictionary.key1, dictionary.key2, dictionary.key3)
六、函数类型
函数是对语句和表达式进行抽象的主要方法。
functionName1 = function(i)
print(i)
end
function functionName2(i)
print(i)
end
functionName1(2)
functionName2(2)
和 C 语言相比，Lua 中函数的几个不同点：
-- 1、多返回值，多余的返回值会省略，少的补齐 nil
function multreturn()
return 1, 2
end
print(multreturn())
-- 2、可变参数
function average(...)
result = 0
local arg = {...}
for i,v in ipairs(arg) do
result = result + v
end
print("总共传入".. #arg.."个数")
return result/#arg
end
print("平均值为", average(1, 2, 3, 4, 5, 6, 7, 8, 9))
七、模块
模块就是使用 table 来实现的，看起来会让我们和面向对象语言里面的类有点相似。
Class = {}
-- 定义一个共有的变量
Class.var1 = "初始化 var1 的值"
-- var1 = "初始化 var1 的值"
-- 定义一个私有变量
local var2 = "初始化 var2 的值"
-- 定义一个共有函数 func1
function Class.func1()
print("这是共有函数 func1")
end
-- 定义私有函数，该函数只能在本模块里面使用
local function func2()
print("这是私有函数 func2")
end
-- 定义一个全局函数，可以直接其它模块里面调用，但是不能通过该模块去调用。
function func3()
print("这是全局函数 func3")
end
return Class
它里面整一个就是一个表，在里面可以定义私有、共有变量，私有、共有函数。这些特性都是通过表来限制的，如果不是通过表来限制，那这些函数和变量的作用域都是全局的。
-- 通过require() 函数导入模块
local m = require('Module')
print("模块类型为：", type(m))
-- 修改模块共有变量
m.var1 = "修改一下 var1"
print("模块变量值为：", m.var1)
-- 调用模块共有函数
print("模块func1函数的调用：", m.func1())
-- 模块的加载过程
print("func3 函数是不是在这里打印？", func3())
八、闭包
闭包是函数中的函数，可以包含父函数的局部变量的代码块，可以始终让局部变量的值始终保持在内存中。
它的最大用处有两个，一个是可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。
-- 示例1
function func1()
local x = 0
function ee()
x = x + 1
print(x)
end
return ee
end
local f1 = func1()
for i=1, 5 do
f1()
end
-- 示例2
function func2()
local x = 0
return function()
x = x + 1
print(x)
end
end
local f2 = func2()
for i=1, 5 do
f2()
end
-- 示例3
function func3(a)
local x = a
return function()
x = x + 1
print(x)
end
end
local f31 = func3(3)
for i=1, 5 do
f31()
end
local f32 = func3(10)
for i=1, 5 do
f32()
end
九、元表及元方法
在 Lua table 中我们可以访问对应的 key 来得到 value 值，但是却无法对两个 table 进行操作。
因此 Lua 提供了元表(Metatable)，允许我们改变 table 的行为，每个行为关联了对应的元方法。
有两个很重要的函数来处理元表：
setmetatable(table,metatable): 对指定 table 设置元表(metatable)，如果元表(metatable)中存在 metatable 键值，setmetatable 会失败 。
getmetatable(table): 返回对象的元表(metatable)。
-- 给指定表设置元表
mytable = {} -- 普通表
mymetatable = {} -- 元表
setmetatable(mytable, mymetatable) -- 把 mymetatable 设为 mytable 的元表
-- 返回对象元表
getmetatable(mytable) -- 这回返回mymetatable
__index 元方法
__index 元方法是 metatable 里面最常见的键。
当你通过键来访问 table 的时候，如果这个键没有值，那么 Lua 就会寻找该 table 的 metatable（假定有 metatable）中的 __index 键。如果 __index 包含一个表格，Lua 会在表格中查找相应的键。
-- 实例1
mytable = {
key1 = "value1"
}
mymetatable = {
__index = {
key2 = "metatablevalue"
}
}
setmetatable(mytable, mymetatable)
print(mytable.key1, mytable.key2, mytable.key3)
-- 实例2
mytable = {
key1 = "value1"
}
mymetatable = {
__index = function(mytable, key)
if key == "key2" then
return "metatablevalue"
else
return nil
end
end
}
setmetatable(mytable, mymetatable)
print(mytable.key1, mytable.key2, mytable.key3)
总结：
Lua 查找一个表元素时的规则，其实就是如下 3 个步骤:
- 在表中查找，如果找到，返回该元素，找不到则继续
判断该表是否有元表，如果没有元表，返回 nil，有元表则继续。
判断元表有没有
__index方法，如果__index方法为 nil，则返回 nil；如果__index方法是一个表，则重复 1、2、3；如果__index方法是一个函数，则返回该函数的返回值。
十、面向对象之封装
面向对象的特征有封装、继承、多态。Lua 是一门弱类型的语言，多态那肯定是不存在的。
通过元表和元方法以及模块来模拟类的封装，请看如下示例：
local User = {}
User.id = 0
User.name = ""
User.age = 0
-- function User:new()
-- print("User 被构造了")
-- mytable = {}
-- setmetatable(mytable, self)
-- self.__index = self
-- return mytable
-- end
function User:new(id, name, age)
print("new self:", self)
-- print("User 被构造了，", id, name, age)
mytable = {"haha"}
setmetatable(mytable, self)
self.__index = self
self.id = id
self.name = name
self.age = age
return mytable
end
function User:fun()
-- print("fun 成员方法调用了")
end
function User:setName(name)
print("setName self:", self)
self.name = name
end
function User:getName()
print("getName self:", self)
return self.name
end
return User
