Lua 是动态类型语言，变量不要类型定义,只需要为变量赋值。 值可以存储在变量中，作为参数传递或结果返回。
1、数据类型
- nil：表示无效值，和null类似，在条件中相当于false；
- boolean：true，false；
- number：双精度实浮点型；
- string：字符串；
- function：函数；
- userdata：任意存储在变量中的C数据结构；
- thread：协程；
- table： Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字、字符串或表类型。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。
2、实例
print(type(nil)) nil
print(type(true)) boolean
print(type(1)) number
print(type(1.01)) number
print(type("lua")) string
print(type(print)) function
print(type(coroutine.create(function() end))) thread
print(type({})) table
3、特殊说明
3.1 nil
它只有一个值 – nil；
对于全局变量和 table，nil 还有一个"删除"作用，给全局变量或者 table 表里的变量赋一个 nil 值，等同于把它们删掉。
在此特殊说明一下type方法，返回值是string，所以是否为空的判断要 ==“nil”，而不是 ==nil
3.2 boolean
boolean 类型只有两个可选值：true（真） 和 false（假），Lua 把 false 和 nil 看作是 false，其他的都为 true，数字 0 也是 true。
3.3 string
字符串由一对双引号或单引号来表示，也可以用 2 个方括号 “[[]]” 来表示"一块"字符串。
另外对于字符串连接，应该使用“a” … “b”，而不是“a” + “b”；
1 … 1，输出结果是11，“1” + 1，输出会是2。
3.3.1 转义字符
| 转义字符 | 意义 | ASCII码值 | 备注 |
|---|---|---|---|
| \0 | 空字符(NULL) | 000 | 字符串结束的标志。 |
| \a | 响铃（BEL） | 007 | 在标准输出设备输出字符’\a’时，系统自带的扬声器（或蜂鸣器）会发出“叮”的一声。 |
| \b | 退格（BS），将当前位置移到前一列 | 008 | 将光标从当前位置向前（左）移动一个字符（遇到\n或\r则停止移动），并从此位置开始输出后面的字符（空字符\0和换行符\n除外）。 |
| \t | 水平制表(HT) （跳到下一个TAB位置） | 009 | - |
| \n | 换行(LF) ，将当前位置移到下一行开头 | 010 | - |
| \v | 垂直制表(VT) | 011 | - |
| \f | 换页(FF)，将当前位置移到下页开 | 012 | - |
| \r | 回车(LF) ，将当前位置移到本行开头 | 013 | - |
| \ " | 代表一个双引号字符 | 034 | - |
| \ ’ | 代表一个单引号（撇号）字符 | 039 | - |
| \ddd | 1到3位八进制数所代表的任意字符 | 三位八进制 | 例如：print(‘\034’)会输出" |
| \xhh | 1到2位十六进制所代表的任意字符 | 二位十六进制 | 未实验成功 |
3.3.2 方法
- string.upper()：字符串全部转为大写字母。
- string.lower()：字符串全部转为小写字母。
- string.gsub(mainString,findString,replaceString,num)：在字符串中替换。mainString 为要操作的字符串， findString 为被替换的字符，replaceString 要替换的字符，num 替换次数（可以忽略，则全部替换）。
- string.find (str, substr, [init, [end]])：在一个指定的目标字符串 str 中搜索指定的内容 substr，如果找到了一个匹配的子串，就会返回这个子串的起始索引和结束索引，不存在则返回 nil。
- string.reverse()：字符串反转。
- string.format()：返回一个类似printf的格式化字符串。string.format(“the value is:%d”,4)->‘the value is:4’
%c - 接受一个数字, 并将其转化为ASCII码表中对应的字符
%d, %i - 接受一个数字并将其转化为有符号的整数格式
%o - 接受一个数字并将其转化为八进制数格式
%u - 接受一个数字并将其转化为无符号整数格式
%x - 接受一个数字并将其转化为十六进制数格式, 使用小写字母
%X - 接受一个数字并将其转化为十六进制数格式, 使用大写字母
%e - 接受一个数字并将其转化为科学记数法格式, 使用小写字母e
%E - 接受一个数字并将其转化为科学记数法格式, 使用大写字母E
%f - 接受一个数字并将其转化为浮点数格式
%g(%G) - 接受一个数字并将其转化为%e(%E, 对应%G)及%f中较短的一种格式
%q - 接受一个字符串并将其转化为可安全被Lua编译器读入的格式
%s - 接受一个字符串并按照给定的参数格式化该字符串
为进一步细化格式, 可以在%号后添加参数。参数将以如下的顺序读入:
(1) 符号: 一个+号表示其后的数字转义符将让正数显示正号. 默认情况下只有负数显示符号.
(2) 占位符: 一个0, 在后面指定了字串宽度时占位用. 不填时的默认占位符是空格.
(3) 对齐标识: 在指定了字串宽度时, 默认为右对齐, 增加-号可以改为左对齐.
(4) 宽度数值
(5) 小数位数/字串裁切: 在宽度数值后增加的小数部分n, 若后接f(浮点数转义符, 如%6.3f)则设定该浮点数的小数只保留n位, 若后接s(字符串转义符, 如%5.3s)则设定该字符串只显示前n位. - string.char() ： 将整型数字转成字符并连接。
- string.byte(arg[,int])转换字符为整数值(可以指定某个字符，默认第一个字符)。
- string.len()：计算字符串长度。
- string.rep(string, n)：返回字符串string的n个拷贝。
- string.gmatch(str, pattern)：返回一个迭代器函数，每一次调用这个函数，返回一个在字符串 str 找到的下一个符合 pattern 描述的子串。如果参数 pattern 描述的字符串没有找到，迭代函数返回nil。 for word in string.gmatch(“Hello Lua user”, “%a+”) do print(word) end ->Hello Lua user
- string.match(str, pattern, init)：只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil。
- string.sub(s, i [, j])：字符串截取。s：要截取的字符串，i：截取开始位置，j：截取结束位置，默认为 -1，最后一个字符。
3.4 table
在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。也可以在表里添加一些数据，直接初始化表：
-- 创建一个空的 table
local table1 = {}
-- 直接初始表
local table2 = {"1", "2", "3", "4"}
Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串。
a = {}
a["key"] = "value"
a[10] = 10
不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始。
table 不会固定长度大小，有新数据添加时 table 长度会自动增长，没初始的 table 都是 nil。
3.4.1 多维数组
-- 初始化数组
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
3.4.2 方法
- table.concat (table [, sep [, start [, end]]])：concat是concatenate(连锁, 连接)的缩写. table.concat()函数列出参数中指定table的数组部分从start位置到end位置的所有元素, 元素间以指定的分隔符(sep)隔开。
- table.insert (table, [pos,] value)：在table的数组部分指定位置(pos)插入值为value的一个元素. pos参数可选, 默认为数组部分末尾。
- table.maxn (table)：指定table中所有正数key值中最大的key值. 如果不存在key值为正数的元素, 则返回0。(Lua5.2之后该方法已经不存在了)
- table.remove (table [, pos])：返回table数组部分位于pos位置的元素. 其后的元素会被前移. pos参数可选, 默认为table长度, 即从最后一个元素删起。
- table.sort (table [, comp])：对给定的table进行升序排序。
3.4.3 模块
模块类似于一个封装库，从 Lua 5.1 开始，Lua 加入了标准的模块管理机制，可以把一些公用的代码放在一个文件里，以 API 接口的形式在其他地方调用，有利于代码的重用和降低代码耦合度。
Lua 的模块是由变量、函数等已知元素组成的 table，因此创建一个模块很简单，就是创建一个 table，然后把需要导出的常量、函数放入其中，最后返回这个 table 就行。以下为创建自定义模块 module.lua，文件代码格式如下：
-- 文件名为 module.lua
-- 定义一个名为 module 的模块
module = {}
-- 定义一个常量
module.constant = "这是一个常量"
-- 定义一个函数
function module.func1()
io.write("这是一个公有函数！\n")
end
local function func2()
print("这是一个私有函数！")
end
function module.func3()
func2()
end
return module
模块的结构就是一个 table 的结构，因此可以像操作调用 table 里的元素那样来操作调用模块里的常量或函数。
上面的 func2 声明为程序块的局部变量，即表示一个私有函数，因此是不能从外部访问模块里的这个私有函数，必须通过模块里的公有函数来调用.。
Lua提供了一个名为require的函数用来加载模块。要加载一个模块，只需要简单地调用就可以了。例如：
require("<模块名>")
或者：
require "<模块名>"
对于自定义的模块，模块文件不是放在哪个文件目录都行，函数 require 有它自己的文件路径加载策略，它会尝试从 Lua 文件或 C 程序库中加载模块。
require 用于搜索 Lua 文件的路径是存放在全局变量 package.path 中，当 Lua 启动后，会以环境变量 LUA_PATH 的值来初始这个环境变量。如果没有找到该环境变量，则使用一个编译时定义的默认路径来初始化。
3.4.4 元表(Metatable)
在 Lua table 中我们可以访问对应的 key 来得到 value 值，但是却无法对两个 table 进行操作(比如相加)。
因此 Lua 提供了元表(Metatable)，允许我们改变 table 的行为，每个行为关联了对应的元方法。
例如，使用元表我们可以定义 Lua 如何计算两个 table 的相加操作 a+b。
当 Lua 试图对两个表进行相加时，先检查两者之一是否有元表，之后检查是否有一个叫 __add 的字段，若找到，则调用对应的值。 __add 等即时字段，其对应的值（往往是一个函数或是 table）就是"元方法"。
有两个很重要的函数来处理元表：
- setmetatable(table,metatable): 对指定 table设置元表(metatable)，如果元表(metatable)中存在 __metatable 键值，setmetatable 会失败。
- getmetatable(table): 返回对象的元表(metatable)。
以下实例演示了如何对指定的表设置元表：
mytable = {} -- 普通表
mymetatable = {} -- 元表
setmetatable(mytable,mymetatable) -- 把 mymetatable 设为 mytable 的元表
以上代码也可以直接写成一行：
mytable = setmetatable({},{})
以下为返回对象元表：
getmetatable(mytable) -- 这会返回 mymetatable
3.4.4.1 __index 元方法
这是 metatable 最常用的键。
当你通过键来访问 table 的时候，如果这个键没有值，那么Lua就会寻找该table的metatable（假定有metatable）中的__index 键。如果__index包含一个表格，Lua会在表格中查找相应的键。
我们可以在使用 lua 命令进入交互模式查看：
$ lua
Lua 5.3.0 Copyright (C) 1994-2015 Lua.org, PUC-Rio
> other = { foo = 3 }
> t = setmetatable({}, { __index = other })
> t.foo
3
> t.bar
nil
如果__index包含一个函数的话，Lua就会调用那个函数，table和键会作为参数传递给函数。
__index 元方法查看表中元素是否存在，如果不存在，返回结果为 nil；如果存在则由 __index 返回结果。
mytable = setmetatable({key1 = "value1"}, {
__index = function(mytable, key)
if key == "key2" then
return "metatablevalue"
else
return nil
end
end
})
print(mytable.key1,mytable.key2)
总结：
Lua 查找一个表元素时的规则，其实就是如下 3 个步骤:
- 在表中查找，如果找到，返回该元素，找不到则继续。
- 判断该表是否有元表，如果没有元表，返回 nil，有元表则继续。 判断元表有没有
- __index 方法，如果 __index 方法为 nil，则返回 nil；如果 __index 方法是一个表，则重复 1、2、3；如果__index 方法是一个函数，则返回该函数的返回值。
3.4.4.2 __newindex 元方法
__newindex 元方法用来对表更新，__index则用来对表访问 。
当你给表的一个缺少的索引赋值，解释器就会查找__newindex 元方法：如果存在则调用这个函数而不进行赋值操作。
以下实例演示了 __newindex 元方法的应用：
mymetatable = {}
mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })
print(mytable.key1)
mytable.newkey = "新值2"
print(mytable.newkey,mymetatable.newkey)
mytable.key1 = "新值1"
print(mytable.key1,mymetatable.key1)
以上实例中表设置了元方法 __newindex，在对新索引键（newkey）赋值时（mytable.newkey = “新值2”），会调用元方法，而不进行赋值。而如果对已存在的索引键（key1），则会进行赋值，而不调用元方法 __newindex。
以下实例使用了 rawset 函数来更新表：
mytable = setmetatable({key1 = "value1"}, {
__newindex = function(mytable, key, value)
rawset(mytable, key, "\""..value.."\"")
end
})
mytable.key1 = "new value"
mytable.key2 = 4
print(mytable.key1,mytable.key2)
为表添加操作符：
-- 计算表中最大值，table.maxn在Lua5.2以上版本中已无法使用
-- 自定义计算表中最大键值函数 table_maxn，即计算表的元素个数
function table_maxn(t)
local mn = 0
for k, v in pairs(t) do
if mn < k then
mn = k
end
end
return mn
end
-- 两表相加操作
mytable = setmetatable({ 1, 2, 3 }, {
__add = function(mytable, newtable)
for i = 1, table_maxn(newtable) do
table.insert(mytable, table_maxn(mytable)+1,newtable[i])
end
return mytable
end
})
secondtable = {4,5,6}
mytable = mytable + secondtable
for k,v in ipairs(mytable) do
print(k,v)
end
__add 键包含在元表中，并进行相加操作。 表中对应的操作列表如下：(注意：__是两个下划线)
| 模式 | 描述 |
|---|---|
| __add | 对应的运算符 ‘+’ |
| __sub | 对应的运算符 ‘-’. |
| __mul | 对应的运算符 ‘*’ |
| __div | 对应的运算符 ‘/’ |
| __mod | 对应的运算符 ‘%’ |
| __unm | 对应的运算符 ‘-’ |
| __concat | 对应的运算符 ‘…’ |
| __eq | 对应的运算符 ‘==’ |
| __lt | 对应的运算符 ‘<’ |
| __le | 对应的运算符 ‘<=’ |
3.4.4.3 __call 元方法
__call 元方法在 Lua 调用一个值时调用。以下实例演示了计算表中元素的和：
-- 计算表中最大值，table.maxn在Lua5.2以上版本中已无法使用
-- 自定义计算表中最大键值函数 table_maxn，即计算表的元素个数
function table_maxn(t)
local mn = 0
for k, v in pairs(t) do
if mn < k then
mn = k
end
end
return mn
end
-- 定义元方法__call
mytable = setmetatable({10}, {
__call = function(mytable, newtable)
sum = 0
for i = 1, table_maxn(mytable) do
sum = sum + mytable[i]
end
for i = 1, table_maxn(newtable) do
sum = sum + newtable[i]
end
return sum
end
})
newtable = {10,20,30}
print(mytable(newtable))
3.4.4.4 __tostring 元方法
__tostring 元方法用于修改表的输出行为。以下实例我们自定义了表的输出内容：
mytable = setmetatable({ 10, 20, 30 }, {
__tostring = function(mytable)
sum = 0
for k, v in pairs(mytable) do
sum = sum + v
end
return "表所有元素的和为 " .. sum
end
})
print(mytable)
3.5 function
在 Lua 中，函数是被看作是"第一类值（First-Class Value）"，函数可以存在变量里：
-- function_test.lua 脚本文件
function function1()
end
function2 = function1
3.6 thread
在 Lua 里，最主要的线程是协同程序（coroutine）。它跟线程（thread）差不多，拥有自己独立的栈、局部变量和指令指针，可以跟其他协同程序共享全局变量和其他大部分东西。
3.6.1 线程跟协程的区别
- 线程可以同时多个运行，而协程任意时刻只能运行一个。
- 在任一指定时刻只有一个协同程序在运行，并且这个正在运行的协同程序只有在明确的被要求挂起（suspend）的时候才会暂停。
- 协同程序有点类似同步的多线程，在等待同一个线程锁的几个线程有点类似协同。
3.6.2 基本语法
| 方法 | 描述 |
|---|---|
| coroutine.create() | 创建 coroutine，返回 coroutine， 参数是一个函数，当和 resume 配合使用的时候就唤醒函数调用 |
| coroutine.resume() | 重启 coroutine，和 create 配合使用 |
| coroutine.yield() | 挂起 coroutine，将 coroutine 设置为挂起状态，这个和 resume 配合使用能有很多有用的效果 |
| coroutine.status() | 查看 coroutine 的状态 注：coroutine 的状态有三种：dead，suspended，running，具体什么时候有这样的状态请参考下面的程序 |
| coroutine.wrap() | 创建 coroutine，返回一个函数，一旦你调用这个函数，就进入 coroutine，和 create 功能重复 |
| coroutine.running() | 返回正在跑的 coroutine，一个 coroutine 就是一个线程，当使用running的时候，就是返回一个 corouting 的线程号 |
coroutine.running就可以看出来,coroutine在底层实现就是一个线程。
当create一个coroutine的时候就是在新线程中注册了一个事件。
当使用resume触发事件的时候，create的coroutine函数就被执行了，当遇到yield的时候就代表挂起当前线程，等候再次resume触发事件。
3.7 userdata
userdata 是一种用户自定义数据，用于表示一种由应用程序或 C/C++ 语言库所创建的类型，可以将任意 C/C++ 的任意数据类型的数据（通常是 struct 和 指针）存储到 Lua 变量中调用。
1605
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
