Lua 是什么？
Lua 是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放， 其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。
Lua 是巴西里约热内卢天主教大学（Pontifical Catholic University of Rio de Janeiro）里的一个研究小组，由Roberto Ierusalimschy、Waldemar Celes 和 Luiz Henrique de Figueiredo所组成并于1993年开发。
设计目的
其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。
Lua 特性
- 轻量级: 它用标准C语言编写并以源代码形式开放，编译后仅仅一百余K，可以很方便的嵌入别的程序里。
- 可扩展: Lua提供了非常易于使用的扩展接口和机制：由宿主语言(通常是C或C++)提供这些功能，Lua可以使用它们，就像是本来就内置的功能一样。
- 其它特性:
- 支持面向过程(procedure-oriented)编程和函数式编程(functional programming)；
- 自动内存管理；只提供了一种通用类型的表（table），用它可以实现数组，哈希表，集合，对象；
- 语言内置模式匹配；闭包(closure)；函数也可以看做一个值；提供多线程（协同进程，并非操作系统所支持的线程）支持；
- 通过闭包和table可以很方便地支持面向对象编程所需要的一些关键机制，比如数据抽象，虚函数，继承和重载等。
Lua 基本语法
Lua 学习起来非常简单，我们可以创建第一个 Lua 程序！
交互式编程：
Lua 提供了交互式编程模式。我们可以在命令行中输入程序并立即查看效果。
Lua 交互式编程模式可以通过命令 lua -i 或 lua 来启用：
$ lua -i
$ Lua 5.1.4 Copyright (C) 1994-2008 Lua.org, PUC-Rio
>
在命令行中，输入以下命令:
> print("my name is jack lee")
接着我们按下回车键，输出结果如下：
> print("my name is jack lee")
my name is jack lee
脚本式编程：
我们可以将 Lua 程序代码编写到一个以 lua 结尾的文件，并执行，该模式称为脚本式编程，如我们将如下代码存储在名为 name.lua 的脚本文件中,并且将脚本放在D:盘
print("my name is jack!")
print("welcome learn lua follow teacher li!")
使用 lua 名执行以上脚本，输出打印结果
lua d:\Lua\name.lua
注释
单行注释
两个减号是单行注释:
--
多行注释
--[[
多行注释
多行注释
--]]
变量，函数命名规范
标示符表示一个变量，函数或其他定义项,命名规范以一个字母 A 到 Z 或 a 到 z 或下划线 _后加上字母,下划线 _数字（0到9）。建议不要使用下划线加大写字母的标示符，因为Lua的保留字也是这样的。
一般约定，以下划线开头连接一串大写字母的名字（比如 _VERSION）被保留用于 Lua 内部全局变量。
Lua 不允许使用特殊字符如 @, $, 和 % 来定义成员名。 Lua 是一个区分大小写的编程语言。因此在 Lua 中 Run 与 run 是两个不同的标示符。以下列出了一些正确的标示符：
mohd zara abc move_name a_123
myname50 _temp j a23b9 retVal
关键词
以下列出了 Lua 的保留关键字。保留关键字不能作为常量或变量或其他用户自定义标示符：注：（以下关键字后续会详细讲解）
|
and |
break |
do |
else |
|
elseif |
end |
false |
for |
|
function |
if |
in |
local |
|
nil |
not |
or |
repeat |
|
return |
then |
true |
until |
|
while |
|
|
|
全局变量
在默认情况下，变量总是认为是全局的。
全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil。
> print(b)
nil
> b=10
> print(b)
10
>
你可以设置全局变量为空，只需要将变量赋值为nil。
b = nil
print(b) --> nil
这样变量b就好像从没被使用过一样。换句话说, 当且仅当一个变量不等于nil时，这个变量即存在。
Lua 数据类型
Lua是动态类型语言，变量不要类型定义,只需要为变量赋值。 值可以存储在变量中，作为参数传递或结果返回。
Lua中有8个基本类型分别为：nil、boolean、number、string、userdata、function、thread和table。 (注：以下数据类型后续做详细讲解)
|
数据类型 |
描述 |
|
nil |
表示一个无效值（在条件表达式中相当于false）。 |
|
boolean |
包含两个值：false和true。 |
|
number |
表示双精度类型的实浮点数 |
|
string |
字符串由一对双引号或单引号来表示 "" \'\' |
|
function |
函数 |
|
userdata |
表示任意存储在变量中的C数据结构 |
|
thread |
表示执行的独立线程，用于执行协同程序 |
|
table |
Lua 中的表（table）其实是一个"关联数组"，数组的索引可以是数字或者是字符串。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。 |
我们可以使用type函数测试给定变量或者值的类型：
在sublime编辑器中写下以下代码， 按Ctrl+B 编译。
_str="I am str"
_number=10.116
_bo=false
print(type(str))
print(type(_number))
print(type(_bo))
数据类型具体分析：
nil（空）
nil 类型表示一种没有任何有效值，它只有一个值 -- nil，例如打印一个没有赋值的变量，便会输出一个 nil 值：
> print(type(a))
nil
boolean（布尔）
boolean 类型只有两个可选值：true（真） 和 false（假），Lua 把 false 和 nil 看作是"假"，其他的都为"真"
number（数字）
Lua 默认只有一种 number 类型 -- double（双精度）类型，以下几种写法都被看作是 number
print(type(2))
print(type(2.2))
print(type(0.2))
string（字符串）字符串由一对双引号或单引号来表示。
string1 = "this is string1"
string2 = \'this is string2\'
也可以用 2 个方括号 "[ [ ] ]" 来表示"一块"字符串。
_str2=[[my name is jack!]]
print(_str2)
在对一个数字字符串上进行算术操作时，Lua 会尝试将这个数字字符串转成一个数字:
print("1"+5) --6
print("1"+"6") --7
print("3+7") -- "3+7"
关于字符串拼接,使用.. 对字符串进行拼接
value=11
print("value="..value) --value=11
使用 # (井号)来计算字符串的长度，放在字符串前面，如下实例：
mail = "[email protected]"
print(#mail)
--19
Table（表）
在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是大括号{}，用来创建一个空表。也可以在表里添加一些数据，直接初始化表:
-- 创建一个空的 table
local tbl1 = {}
-- 直接初始表
local tbl2 = {"apple", "pear", "orange", "grape"} --苹果，梨，橙子，葡萄
local tbl2={X=3,y=4} --指定键值初始化 X,Y是键，值是3,4
Lua 中的表（table）其实是一个"关联数组"，数组的索引可以是数字或者是字符串。(类似字典)
_table_1={}
_table_1["str_key1"]="str_value"
_table_1["str_key2"]=2
nub_key1=1
_table_1[nub_key1]="value1"
nub_key2=2
_table_1[nub_key2]=13
_table_1[nub_key2]=_table_1[nub_key2]+1
for k,v in pairs(_table_1) do
print(k.."===="..v)
end
不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始。
local tbl = {"apple", "pear", "orange", "grape"}
for key, val in pairs(tbl) do
print("Key", key)
end
-- 1 2 3 4
table 不会固定长度大小，有新数据添加时 table 长度会自动增长，没初始的 table 都是 nil。
_table = {}
for i = 1, 10 do
_table[i] = i
end
-- for k,v in pairs(_table) do
-- print(k,v)
-- end
_table["key"] = "val"
print(_table["key"])
print(_table["none"])
for k,v in pairs(_table) do
print(k,v)
end
表函数的定义和使用：
tab={x=2,y=3}
function tab:setValue(m_x,m_y) --注意定义的时候使用了：冒号
tab.x=m_x
tab.y=m_y
end
tab:setValue(5,6) --注意，在调用的时候也必须和定义时一致使用冒号。
print(tab.x,tab.y)
function（函数）
函数的基本语法:
function function_name(n_value)
return n_value+1
end
print(function_name(7))
函数还可以像下面这样存在一个变量里：
function function_name(n_value)
return n_value+1
end
print(function_name(7))
func_self=function_name
print(func_self(5))
function 可以以匿名函数（anonymous function）的方式通过参数传递:
--首先写一个函数 有个2个参数 1是表 2是函数 --遍历表 取出键值
--打印调用func将 键值作为参数传递进func
function anonymous(tab,func)
for k,v in pairs(tab) do
print(func(k,v))
end
end
--调用anonymous 1参传入表，2参是匿名函数并且有执行内容，--内容是返回_k _v 注--意函数结尾需要有end
_table={key1="value1",key2="value2"}
anonymous(_table,function(_k,_v)
return _k,_v
end)
thread（线程）
在 Lua 里，最主要的线程是协同程序（coroutine）。拥有自己独立的栈、局部变量和指令指针，可以跟其他协同程序共享全局变量和其他大部分东西。
线程跟协程的区别：线程可以同时多个运行，而协程任意时刻只能运行一个，并且处于运行状态的协程只有被挂起（suspend）时才会暂停。
userdata（自定义类型）
userdata 是一种用户自定义数据，用于表示一种由应用程序或 C/C++ 语言库所创建的类型，可以将任意 C/C++ 的任意数据类型的数据（通常是 struct 和 指针）存储到 Lua 变量中调用。（简单来说就是在LUA中用userdata表示其他语言的数据类型）
Lua 变量
变量在使用前，必须在代码中进行声明，即创建该变量，Lua 中的变量全是全局变量，那怕是语句块或是函数里，除非用 local 显式声明为局部变量，
局部变量的作用域为从声明位置开始到所在语句块结束，变量的默认值均为 nil。
variable_1=1 --全局
local variable_2 = 2 --局部
function function_name()
variable_3=3 --全局
local variable_4 = 4 --局部
return variable_3+variable_2--(注意 variable_2是在外面声明的局部变量，本质也是全局的)
end
print(function_name())
print("variable_3="..variable_3)
print("variable_4=",variable_4)-- 注意不能使用".."连接一个空值
赋值语句
赋值是改变一个变量的值和改变表域的最基本的方法。
value=1
strValue="str"
value_2=value+2
print(strValue)
---------------------------------------------------------
_table={n="n_vale",m="m_value"}
print(_table.n)
_table.n=11
print(_table.n)
Lua 循环
很多情况下我们需要做一些有规律性的重复操作，因此在程序中就需要重复执行某些语句。
一组被重复执行的语句称之为循环体，能否继续重复，决定循环的终止条件。
循环结构是在一定条件下反复执行某段程序的流程结构，被反复执行的程序被称为循环体。
循环语句是由循环体及循环的终止条件两部分组成的。
while 循环
Lua 编程语言中 while 循环语句在判断条件为 true 时会重复执行循环体语句。
语法
Lua 编程语言中 while 循环语法：（注意不同于C# 语句没有大括号）
while(condition)
do
statements
end
statements(循环体语句) 可以是一条或多条语句，condition(条件) 可以是任意表达式，在 condition(条件) 为 true 时执
实例：
a=1
while( a < 5 )
do
print("a 的值为:", a)
a = a+1
end
Lua for 循环
Lua 编程语言中 for 循环语句可以重复执行指定语句，重复次数可在 for 语句中控制。
Lua 编程语言中 for语句有两大类：(注意与C#的for 循环有较明显区别)
第一种：数值for循环
for var=exp1,exp2,exp3 do
<执行体>
end
var从exp1变化到exp2，每次变化以exp3为步长递增var，并执行一次"执行体"。exp3是可选的，如果不指定，默认为1。
实例：
for i=1,5 do
print(i)
end
---------------------------------------------------
function function_name(x)
return x*2
end
for i=1,function_name(3) do
print(i)
end
第二种：泛型for循环
泛型for循环通过一个迭代器函数来遍历所有值
在lua中pairs与ipairs两个迭代器的用法相近，但有一点是不一样的：
pairs可以遍历表中所有的key，包含索引，和自定义类型key
ipairs 仅可以遍历出具备索引的值
_table2={"Suanday","Monday"}
_table2["ukey"]="uvalue" --键值都是字符串
intkey=8
_table2[intkey]="uvalue" --键是number 值是字符串
for k,v in ipairs(_table2) do
print(k,v)
end
输出结果是 （table2 中仅具备索引的2个值被输出了）
-- 1 Suanday
-- 2 Monday
for k,v in pairs(_table2) do
print(k,v)
end
输出结果是（所有的键值均被输出）
--1 Suanday
--2 Monday
--ukey uvalue
--8 uvalue
Lua break 语句
Lua 编程语言 break 语句插入在循环体中，用于退出当前循环或语句，并开始脚本执行紧接着的语句。
如果你使用循环嵌套，break语句将停止最内层循环的执行，并开始执行的外层的循环语句。
a=1
while(a<6)
do
print(a)
a=a+1
if(a>3)
then
break
end --注意if语句需要关键字 then和end
end --这个 end 是while 语句的结束
无限循环
在循环体中如果条件永远为 true 循环语句就会永远执行下去，以下以 while 循环为例：
while( true )
do
print("循环将永远执行下去")
end
Lua if 语句
Lua if 语句 由一个布尔表达式作为条件判断，其后紧跟其他语句组成。
Lua if 语句语法格式如下：
if(布尔表达式)
then
--[ 在布尔表达式为 true 时执行的语句 --]
end
a=1
if(a>0)
then
a=a+1
print(a)
end
if...else 语句
Lua if 语句可以与 else 语句搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码块。
Lua if...else 语句语法格式如下：
if(布尔表达式)
then
--[ 布尔表达式为 true 时执行该语句块 --]
else
--[ 布尔表达式为 false 时执行该语句块 --]
end
if...elseif...else 语句
Lua if 语句可以与 elseif...else 语句搭配使用, 在 if 条件表达式为 false 时执行 elseif...else 语句代码块，用于检测多个条件语句。
Lua if...elseif...else 语句语法格式如下：
if( 布尔表达式 1)
then
--[ 在布尔表达式 1 为 true 时执行该语句块 --]
elseif( 布尔表达式 2)
then
--[ 在布尔表达式 2 为 true 时执行该语句块 --]
elseif( 布尔表达式 3)
then
--[ 在布尔表达式 3 为 true 时执行该语句块 --]
else
--[ 如果以上布尔表达式都不为 true 则执行该语句块 --]
end
if...else 语句
Lua if 语句允许嵌套, 这就意味着你可以在一个 if 或 else if 语句中插入其他的 if 或 else if 语句。Lua if 嵌套语句语法格式如下：
if( 布尔表达式 1)
then
--[ 布尔表达式 1 为 true 时执行该语句块 --]
if(布尔表达式 2)
then
--[ 布尔表达式 2 为 true 时执行该语句块 --]
end
end
范例：
a=1
if(a>0) then a=a+1
if(a==2) then a=a+11
end
print(a)
end
Lua 函数
在Lua中，函数是对语句和表达式进行抽象的主要方法。既可以用来处理一些特殊的工作，也可以用来计算一些值。
Lua 提供了许多的内建函数，你可以很方便的在程序中调用它们，如print()函数可以将传入的参数打印在控制台上。
Lua 函数主要有两种用途：
1.完成指定的任务，这种情况下函数作为调用语句使用；
2.计算并返回值，这种情况下函数作为赋值语句的表达式使用
function returenMaxValue(v1,v2)
if(v1>v2)
then result=v1
else
result=v2
return result
end
end
print(returenMaxValue(11,19))
Lua 运算符
运算符是一个特殊的符号，用于告诉解释器执行特定的数学或逻辑运算。Lua提供了以下几种运算符类型：
- 算术运算符
- 关系运算符
- 逻辑运算符
- 其他运算符
算术运算符
下表列出了 Lua 语言中的常用算术运算符，设定 A 的值为10，B 的值为 20：
|
操作符 |
描述 |
实例 |
|
+ |
加法 |
A + B 输出结果 30 |
|
- |
减法 |
A - B 输出结果 -10 |
|
* |
乘法 |
A * B 输出结果 200 |
|
/ |
除法 |
B / A w输出结果 2 |
|
% |
取余 |
B % A 输出结果 0 |
|
^ |
乘幂 |
A^2 输出结果 100 |
|
- |
负号 |
-A 输出结果v -10 |
关系运算符
下表列出了 Lua 语言中的常用关系运算符，设定 A 的值为10，B 的值为 20：
|
操作符 |
描述 |
实例 |
|
== |
等于，检测两个值是否相等，相等返回 true，否则返回 false |
(A == B) 为 false。 |
|
~= |
不等于，检测两个值是否相等，相等返回 false，否则返回 true |
(A ~= B) 为 true。 |
|
> |
大于，如果左边的值大于右边的值，返回 true，否则返回 false |
(A > B) 为 false。 |
|
< |
小于，如果左边的值大于右边的值，返回 false，否则返回 true |
(A < B) 为 true。 |
|
>= |
大于等于，如果左边的值大于等于右边的值，返回 true，否则返回 false |
(A >= B) 返回 false。 |
|
<= |
小于等于， 如果左边的值小于等于右边的值，返回 true，否则返回 false |
(A <= B) 返回 true。 |
逻辑运算符
下表列出了 Lua 语言中的常用逻辑运算符，设定 A 的值为 true，B 的值为 false：
|
操作符 |
描述 |
实例 |
|
and |
逻辑与操作符。 若 A 为 false，则返回 A，否则返回 B。 |
(A and B) 为 false。 |
|
or |
逻辑或操作符。 若 A 为 true，则返回 A，否则返回 B。 |
(A or B) 为 true。 |
|
not |
逻辑非操作符。与逻辑运算结果相反，如果条件为 true，逻辑非为 false。 |
not(A and B) 为 true。 |
其他运算符
下表列出了 Lua 语言中的连接运算符与计算表或字符串长度的运算符：
|
操作符 |
描述 |
实例 |
|
.. |
连接两个字符串 |
a..b ，其中 a 为 "Hello " ， b 为 "World", 输出结果为 "Hello World"。 |
|
# |
一元运算符，返回字符串或表的长度。 |
#"Hello" 返回 5 |
Lua 字符串
字符串或串(String)是由数字、字母、下划线组成的一串字符。
Lua 语言中字符串可以使用以下三种方式来表示：
单引号间的一串字符。
双引号间的一串字符。
和[[ ]]间的一串字符。
范例：
str_1="stringtype_1"
str_2=\'stringtype_2\'
str_3=[["stringtype_3"]]
print(str_1)
print(str_2)
print(str_3)
字符串操作
result=string.upper("upper") //字符串转大写
print(result)
result=string.lower("LOWER")//字符串转小写
print(result)
result=string.reverse("reverse ")//字符串翻转
print(result)
result=string.len("len")//字符串长度
print(result)
字符串格式化
Lua 提供了 string.format() 函数来生成具有特定格式的字符串, 函数的第一个参数是格式 , 之后是对应格式中每个代号的各种数据。
字符串格式化
str_1="aaa"
str_2="bbb"
result =string.format("%s,%s",str_1,str_2)
print(result)
日期格式化:
day=1
month=5
year=2017
date=string.format("日期：%02d/%02d/%03d",day,month,year)
print(date)
Lua 数组
数组，就是相同数据类型的元素按一定顺序排列的集合，可以是一维数组和多维数组。
Lua 数组的索引键值可以使用整数表示，数组的大小不是固定的。
array={"hu","hj"}
for i=0,2 do
print(array[i])
end
--nil
-- hu
-- hj
-- 我们发现上述代码，索引为0时，从输出了nil lua数组索引默认为1.
正如你所看到的，我们可以使用整数索引来访问数组元素，如果知道的索引没有值则返回nil。
在 Lua 索引值是以 1 为起始，但你也可以指定 0 开始。
除此外我们还可以以负数为数组索引值：
array={}
for i=-10,0 do
array[i]=i*2
print(array[i])
end
多维数组
array={}
for i=1,3 do
array[i]={}
for j=1,3 do
array[i][j]=i*j
end
end
for i=1,3 do
for j=1,3 do
print(array[i][j])
end
end
-- 123
-- 246
-- 369
Lua 迭代器
泛型 for 迭代器
泛型 for 在自己内部保存迭代函数，实际上它保存三个值：迭代函数、状态常量、控制变量。
泛型 for 迭代器提供了集合的 key/value 对，语法格式如下：
for k, v in pairs(t) do
print(k, v)
end
范例代码：
table={"huhu","jack","ukraine"}
for k,v in pairs(table) do
print(k,v)
end
Lua table(表)
table 是 Lua 的一种数据结构,用来帮助我们创建不同的数据类型，如：数字、字典等。
Lua table 使用关联型数组，你可以用任意类型的值来作数组的索引，但这个值不能是 nil。
Lua table 是不固定大小的，你可以根据自己需要进行扩容。
table(表)的构造
构造器是创建和初始化表的表达式。表是Lua特有的功能强大的东西。最简单的构造函数是{}，用来创建一个空表。
-- 初始化表
mytable = {}
-- 指定值
mytable[1]= "Lua" --使用数字作为键
table["strKey"]="value" --使用字符串作为键的写法1
table.strKey="value" --使用字符串作为键的写法2
-- 移除引用
mytable = nil
-- lua 垃圾回收会释放内存
范例代码-1：
table={"value1","value2"}
table["other1"]="other_value1"
table["other2"]=" other_value2"
for k,v in pairs(table) do
print(k,v)
end
--1 value1
--2 value2
--other1 other_value1
--other2 other_value2
范例代码-2：
m_table={"a","b","c"}
print("m_table类型是=",type(m_table))
temp_table=m_table
print("temp_table指向m_table,temp_table[1]=",temp_table[1])
temp_table[1]="aa" --修改m_table[1]的值
temp_table=nil
print("释放temp_table后 m_table[1]=",m_table[1])
Table连接：
m_table={"a","b","c"}
temp=table.concat(m_table) --注意table是关键字
print(temp)
插入和移除：
插入：
m_table={"a","b","c"}
table.insert(m_table,"d")
print(m_table[4])
移除：
table.remove(m_table) --移除方法，会移除最后一个元素
for k,v in pairs(m_table) do
print(k,v)
end
排序：
字母排序：
str={"a","d","b","c"}
for k,v in pairs(str) do
print("排序前："..k..":"..v)
end
table.sort(str)
for k,v in pairs(str) do
print("排序后："..k..":"..v)
end
数字排序：
a=1
b=2
c=3
d=4
str={a,d,b,c}
for k,v in pairs(str) do
print("排序前："..k..":"..v)
end
table.sort(str)
for k,v in pairs(str) do
print("排序后："..k..":"..v)
end
