Lua标准库

-----------------------------------------------------------------------------------------
-- lua标准库
-- 方括号里表示可选的参数
-----------------------------------------------------------------------------------------


-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
-- table库
-- table库默认对表的数组部分产生影响，对整个table有效会另外说明
-- table的数组部分指的是所以从1开始的连续元素，碰到元素为nil即结束
-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
table.sort (table [, comp])
作用:     对table进行排序
comp参数: 如果不存在，对表进行升序排序。
          如果存在，可以用来自定义sort函数的排序标准。
          comp必须为一个函数，该函数接受table的两个元素作为参数，并返回布尔值。
          table.sort按照comp函数返回为true的标准排序
例：
names = {"Peter", "Paul", "Mary", "Hepeng"}
sortFunc = function(a, b) return a < b end
table.sort(names,sortFunc)
print(table.concat(names,","))
--result
Hepeng,Mary,Paul,Peter


例:按各人的数值比较
names = {"Peter", "Paul", "Mary", "Hepeng"}
grades = {Mary = 10, Paul = 7, Peter = 8, Hepeng = 6}
table.sort(names, function (n1, n2) return grades[n1] > grades[n2] end)
print(table.concat(names,","))
--result
Mary,Peter,Paul,Hepeng
-----------------------------------------------------------------------------------------


table.concat (table [, sep [, i [, j]]]))
作用： 函数列出参数中指定table的数组部分从start位置到end位置的所有元素, 元素间分隔符(sep)隔开.  
       分隔符的默认值是空字符, start的默认值是1, end的默认值是数组部分的总长.
       sep, start, end这三个参数是顺序读入的，如果要指定靠后的参数, 必须同时指定前面的参数
例：
names = {"Peter", "Paul", "Mary", "Hepeng"}
print(table.concat(names,","))
print(table.concat(names,",", 2,3))
--result
Peter,Paul,Mary,Hepeng
Paul,Mary
-----------------------------------------------------------------------------------------


table.insert (table, [pos,] value)
作用： 函数在table的数组部分指定位置(pos)插入值为value的一个元素. pos参数可选, 默认为数组部分末尾
例：
names = {"Peter", "Paul", "Mary", "Hepeng",dfe = 2}
table.insert(names,3,"ni")
table.insert(names,"wo")
--result
Peter,Paul,ni,Mary,Hepeng
Peter,Paul,ni,Mary,Hepeng,wo
-----------------------------------------------------------------------------------------


table.remove(table [, pos])
作用： 函数删除并返回table数组部分位于pos位置的元素. 其后的元素会被前移. 
       pos参数可选, 默认为table长度, 即从最后一个元素删起
例：
names = {"Peter", "Paul", "Mary", "Hepeng",dfe = 2}
table.remove(names,3)
print(table.concat(names,","))
table.remove(names)
print(table.concat(names,","))
--result
Peter,Paul,Hepeng
Peter,Paul
-----------------------------------------------------------------------------------------


table.maxn(table)
作用： 函数返回指定table中所有正数key值中最大的key值. 如果不存在key值为正数的元素, 则返回0. 
       此函数不限于table的数组部分
例：
tb = {[1] = "a", [2] = "b", [3] = "c", [26] = "z",[-28] = "d"}
print(table.maxn(tb))
--result
26
-----------------------------------------------------------------------------------------


table.getn(table)
作用： 得到table数组部分的长度
例：
tb = {[1] = "a", [2] = "b", [3] = "c", [26] = "z",[-28] = "d",n = 1000}
print(table.getn(tb))
--result
3
-----------------------------------------------------------------------------------------


table.foreach(table, function(i, v))
作用： 迭代整个表，以key和value逐对进行function(i,v)操作
例：
t1 = {2, 4, 6, language="Lua", version="5", 8, 10}
table.foreach(t1, function(i, v) print (i, v) end) ; 
2 4
3 6
4 8
5 10
language Lua
version 5
-----------------------------------------------------------------------------------------


table.foreachi(table, function(i, v))
作用： 遍历table中的数组，以key和value逐对进行function(i, v)操作
例：
t1 = {2, 4, 6, language="Lua", version="5", 8, 10}
table.foreachi(t1, function(i, v) print (i, v) end) ; --等价于foreach(t1, print)
1 2
2 4
3 6
4 8
5 10
-----------------------------------------------------------------------------------------




-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
-- string库
-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
string.byte(s [, i [, j]])
将字符串s的第i到j个字符的转换成整数；默认i = 1, j = i
例：
print(string.byte("woshi",1,2))
--result
119 111
-----------------------------------------------------------------------------------------


string.char(...)
将数字转化为字符
例：
print(string.char(97,98))
--result
ab
-----------------------------------------------------------------------------------------


string.dump(function)
将函数转化为二进制字符串，可以通过loadString加载字符串调用该函数
例：
function DumpTest(t)
    print(t)
end
local a = string.dump(DumpTest)--将函数DumpTest转换成二进制码
print(a)
local b = loadstring(a)
print(b)
b(3)
--result
LuaQ
function: 0000000006CE7A10
3
-----------------------------------------------------------------------------------------


string.find (s, pattern [, init [, plain]])
查找字符串s中模式为pattern的子串。返回找到的第一个子串的起止下标，默认从第一个字符查找
init:查找的起始位置
plain:为true表示不支持正则表达式模式匹配，pattern只能为普通的字符串
注：用圆括号括起来的一个模式串，就指定了一个捕获。有多少个圆括号就可以额外返回多少个值
例：
pair = " name = Anna "  
print(string.find(pair, "(%a+)%s*=%s*(%a+)", 1, true)) 
print(string.find(pair, "(%a+)%s*=%s*(%a+)", 1, false)) 
--result
nil
2 12 nameAnna


--lua正则表达式字符
. 任意单个字符
%a 字母
%c 控制字符
%d 数字
%l 小写字母
%p 标点字符
%s 空白符
%u 大写字母
%w 字母和数字
%x 十六进制数字
%z 代表0的字符
--
大写字母表示小写字母的补集，如%A表示非字母
-- lua支持的特殊字符，如要匹配特殊字符，使用%转义
( ) 把括号内看成一个整体匹配
 .  任意单个字符
 %  转义用
 +  匹配前面指定的 1 或多个同类字符， 尽可能匹配更长的符合条件的字串
 -  匹配前面指定的 0 或多个同类字符， 尽可能匹配更短的符合条件的字串。还可表示连接符
 *  匹配前面指定的 0 或多个同类字符， 尽可能匹配更长的符合条件的字串
 ?  匹配前面指定的 0 或 1 个同类字符，等价{0,1}. {}表示匹配几次
 [] 匹配括号内的其中一个
 ^  补集
 $  从结束位置往前匹配
-----------------------------------------------------------------------------------------


string.format (formatstring, ···)
格式化字符串，与printf相似
%f,%d,%s,%u,%c
-----------------------------------------------------------------------------------------


string.gmatch(s, pattern) 同 string.gfind(s,pattern)
返回一个迭代器，每调用一次，返回下个查到的字符串
模式串pattern中有圆括号指定的捕获，返回值为匹配圆括号的子串
例：
s = "hello world from Lua"
for w in string.gmatch(s, "%a+") do
    print(w)
end
-----
s = "from=world, to=Lua"
for k, v in string.gmatch(s, "(%w+)=(%w+)") do       
    print(k,v)
end
--result
hello
world
from
Lua
from world
to Lua
-----------------------------------------------------------------------------------------


string.gsub(s, pattern, repl [, n])
用来查找匹配模式的串，并将使用替换串将其替换掉，返回替换后的串和成功配对的次数
当repl为字符串时, 所有成功配对的子字符串均会被替换成指定的repl字串.
当repl为table时, 对每个成功配对的子字符串, 函数均会试图寻找以其为key值的table中的元素, 并返回该元素. 如果该配对包含任何捕获信息, 则以编号为1号的捕获作为key值进行查找.
当repl为函数时, 每个成功配对的子字符串均会作为参数被传入到该函数中去并执行函数.
在repl是table或函数时, 如果该table或函数返回了字串或数字的值, 这个值依然会被用于替换副本字串中的配对子字串. 如果该table或函数返回的值为空, 将不发生替换.
n参数可选, 当它被指定时, string.gsub()函数只对源字符串中的前n个成功配对的成员进行替换操作.
%1~%9 表示几个捕获。%0表示所有匹配
例：
print(string.gsub("hello world", "(%w+)", "%1 %1"))
print("--")
print(string.gsub("hello world", "(%w+)", "%1 %1",1))
print("--")
print(string.gsub("hello Lua", "(%w+)%s*(%w+)", "%2 %1"))
print("--")
print(string.gsub("hello world", "%w+", print))
print("--")
lookupTable = {["hello"] = "hola", ["world"] = "mundo"}
print(string.gsub("hello world", "(%w+)", lookupTable))
--result
hello hello world world 2
--
hello hello world 1
--
Lua hello 1
--
hello
world
hello world 2
--
hola mundo 2
-----------------------------------------------------------------------------------------


string.len (s)
返回字符串的长度
-----------------------------------------------------------------------------------------


string.lower (s)
将字符串中的大写字母都变成小写
-----------------------------------------------------------------------------------------


string.upper (s)
将字符串中的小写字母都变成大写
-----------------------------------------------------------------------------------------


string.rep (s, n)
返回重复n次字符串s的串
-----------------------------------------------------------------------------------------


string.reverse (s)
将字符串反序
-----------------------------------------------------------------------------------------


string.match (s, pattern [, init])
查找第一个匹配模式的字符串
函数将返回配对表达式中的所有捕获结果
如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil
例：
print("-------")
print(string.match("hello world", "(%w+)"))
print("-------")
m,n = string.match("helLua", "(he).(Lua)")
print(m)
print(n)
print("-------")
--result
-------
hello
-------
he
Lua
-------
-----------------------------------------------------------------------------------------


string.sub (s, i [, j])
函数截取字符串s的从第i个字符到第j个字符之间的串
i,j可以为负数，表示从末尾向前开始截取
-----------------------------------------------------------------------------------------


-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
-- math库
-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
--以下三角函数均用弧度制表示
math.acos(x)    --反余弦
math.asin(x)    --反正弦
math.atan(x)    --反正切
math.atan2(x,y) --反正切，根据x/y计算，x,y的符号不同结果不同
math.cos(x)     --余弦
math.sin(x)     --正弦
math.tan(x)     --正切
math.cosh(x)    --双曲线余弦
math.sinh(x)    --双曲线正弦
math.tanh(x)    --双曲线正切


math.rad(x)     --将x转为弧度制
math.deg(x)     --将x转为度数
例：
print(math.deg(math.acos(0.5)))
print(math.deg(math.asin(0.5)))
print(math.deg(math.atan(1)))
print(math.deg(math.atan2(-1,1)))
print(math.deg(math.atan2(1,-1)))
print(math.cos(math.rad(60)))
print(math.sin(math.rad(30)))
print(math.tan(math.rad(45)))
--result
60
30
45
-45
135
0.5
0.5
1


math.abs(x)    --x的绝对值
math.max(x,...) --返回参数的最大值
math.min(x,...) --返回参数的最小值


math.ceil(x)   --向上取整
math.floor(x)  --向下取整


math.sqrt(x)   --开根号
math.pow(x,y)  --x的y次方


math.pi  --圆周率
math.huge  --大于或等于 -->最大数值型所能表示的数


math.exp(x)  --e的x次方
math.log(x)  --x的自然对数
math.log10(x)  --x的以10为底数的对数


math.fmod(x,y)  --x模y  等价于math.mod(x,y)
math.modf(x)    --返回两个值，取x的整数部分与小数部分


math.frexp(x)    --x = m * (2的e次方) 返回m 和 e
math.ldexp(m,e)  --返回 m * (2的e次方)


例：
print(math.modf(20.12))
print(math.fmod(5,3))
print(math.frexp(160))
print(math.ldexp(3,4))
--result
20 0.12
2
0.625 8
48




math.random ([m [, n]])
--产生一个随机数，当m,n都不填时产生的随机数在[0,1)之间，当m填写时，产生[1,m]，当m,n都填写时，产生[m,n]
math.randomseed (x)
--设置随机数种子


-----------------------------------------------------------------------------------------


-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
-- io库
--分为完全模式和简单模式
-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
--简单模式
简单模式使用已存在的输入输出句柄读写。当不存在输入输出句柄是，默认为标准输入输出(键盘与显示器)
io.read(...)
该函数的参数可以使用下列四种类型之一
"*all"    读取整个文件，比较高效。一般使用此参数读出所有字符，然后使用string.gsub或string.gfind处理
"*line"   读取下一行，此是默认方式，读取一行
"*number" 从串中转换出一个数值，读取一个数值,返回一个最多包含n个字符的串
num       读取num个字符到串。io.read(0)可以测试是否到了文件末尾。返回nil
例：使用io.lines()迭代器，排序(io.read("*liine")))
local lines = {}
-- read the lines in table 'lines'
for line in io.lines() do
table.insert(lines, line)
end
table.sort(lines)
例：使用"*number"
如果一个文件类似：
6.0 -3.23 15e12
4.3 234 1000001
则找出每行最大值：
while true do
local n1, n2, n3 = io.read("*number", "*number", "*number")
if not n1 then break end
print(math.max(n1, n2, n3))
end


-----------------------------------------------------------------------------------------
io.write(...)  --将字符写入当前输出
io.close()     --关闭当前输入
io.flush()     --强制刷新缓存
-----------------------------------------------------------------------------------------
io.input ([file])
当参数为空时：返回当前句柄，当参数为文件句柄是，设置为当前句柄。当参数为文件名时，以文本方式打开
并设为当前句柄
-----------------------------------------------------------------------------------------
io.output ([file])  --类似io.input。 设置为输出句柄
-----------------------------------------------------------------------------------------
io.lines([filename])
当没有参数时，返回一个迭代器，逐行读出字符串
当参数为文件名时，打开文件，返回一个迭代器，逐行读出字符串
-----------------------------------------------------------------------------------------
io.open (filename [, mode])
"r": 只读模式，默认模式，文件必须存在
"w": 只写模式，文件不存在就创建，文件存在会清零
"a": 追加模式
"r+": 读写模式，文件必须存在，写的时候从文件头开始写
"w+": 读写模式，文件不存在就创建，文件存在会清零
"a+": 追加，从文件末尾写
--可以再末尾加上b标志，以二进制读写追加
例：
f = io.open("he.txt","r+")
if f == nil then
print("nihao")
else
print("wohao")
io.output(f)
io.write("nihaoma")
io.close()
end
--result
wohao
文件he.twx里写入了nihaoma
例：
f = io.open("he.txt","r+")
if f == nil then
    print("nihao")
else
    print("wohao")
    io.output(f)
    print(io.type(f))
    io.close()
    print(io.type(f))
    print(io.type(a))
end
--result
wohao
file
closed file
nil
-----------------------------------------------------------------------------------------
io.tmpfile()
--返回一个临时文件句柄，可读可写
f = io.tmpfile()
if f then
f:write("nihaomama")
f:seek("set",1)
c = f:read("*a")
print(c)
end
--result
ihaomama
-----------------------------------------------------------------------------------------
--完全模式
完全模式必须显示使用文件句柄调用，其功能类似于简单模式


file:close ()
file:flush ()
file:lines ()
file:read (···)
file:write (···)
-----------------------------------------------------------------------------------------


file:seek(([whence] [, offset]))
设置文件指针流的位置，并返回文件开始位置到当前位置的字节数
whence可取如下三个参数
"set"  --设置文件指针流为文件的起始位置
"cur"  --文件的当前位置，为该函数默认值，并返回文件开始位置到当前位置的字节数
"end"  --文件的结尾，并返回文件大小
offset  --位置偏移，默认为0
file:seek() --返回当前位置
-----------------------------------------------------------------------------------------


file:setvbuf (mode [, size])
--输出文件时设置缓冲区
mod 可取三个值
"no": 当写操作是立即写入文件 
"full": 只有缓冲区满了才会写入文件，除非显示刷新缓冲区 file:flush()
"line": 缓冲区有换行符时写入。
当mod取full 或 line 时，可以设置缓冲区大小。不设置则为一个默认缓冲区大小
当程序执行完毕时，进程结束时，会立即刷新缓冲区
例：
f = io.open("he.txt","w+")
while(1)
do
    if not i then
        f:setvbuf("full",12)
        f:write("nihaomama")
        f:write("heheh")
        i = 1
    end
end
--result
he.txt文件里写入了：nihaomamaheh 12个字符
-----------------------------------------------------------------------------------------


-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
-- os库
-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
os.time ([table])
当没有参数是，返回当前时间距某一标准时间的秒数
如果有参数，必须是一个表，该表必须有3个域。year,month,day。返回该表指定的时间距某一标准时间的秒数
表中的域可取：
year   --数值
month  01-12
day    01-31
hour   01-31
min    00-59
sec    00-59
isdst  --夏令时 false或true


os.date ([format [, time]])
--当不带参数是返回值依赖与具体系统，等价于os.date("%c")
--当有格式无time参数时，格式化当前时间
--格式化串
--如果格式化串以字符！开头，则按照世界标准时间格式化
%a abbreviated weekday name (e.g., Wed)
%A full weekday name (e.g., Wednesday)
%b abbreviated month name (e.g., Sep)
%B full month name (e.g., September)
%c date and time (e.g., 09/16/98 23:48:10)
%d day of the month (16) [01-31]
%H hour, using a 24-hour clock (23) [00-23]
%I hour, using a 12-hour clock (11) [01-12]
%M minute (48) [00-59]
%m month (09) [01-12]
%p either "am" or "pm" (pm)
%S second (10) [00-61]
%w weekday (3) [0-6 = Sunday-Saturday]
%x date (e.g., 09/16/98)
%X time (e.g., 23:48:10)
%Y full year (1998)
%y two-digit year (98) [00-99]
%% the character '%'


--格式化串使用"*t" 时，返回一个table,含有以下域：
{year = 1998, month = 9, day = 16, yday = 259, wday = 4, hour = 23, min = 48, sec = 10, isdst = false}


例：
print(os.date("%m-%d-%Y %H:%M:%S"))
print(os.date("!%m-%d-%Y %H:%M:%S"))
--result
09-11-2014 14:37:06
09-11-2014 06:37:06


os.clock()
--返回执行CPU程序花去的秒数，一般两次计算后相减


os.difftime (t2, t1)
--返回t2-t1


os.execute ([command])
--执行系统shell命令，等价于c中的system函数，返回值依赖于具体系统


os.exit ([code])
--以某错误码退出程序


os.getenv (varname)
--得到环境变量的值，如果没有该环境变量，则返回nil


os.remove(filename)
--删除一个文件或一个空目录，非空目录可以使用os.execute执行命令删除
--如果函数失败，返回nil和一个描述错误的字符串


os.rename(oldname, newname)
--重命名文件或文件夹
--如果函数失败，返回nil和一个描述错误的字符串


os.tmpname ()
--返回一个文件名，该文件使用时必须显示打开，不需要时必须显示删除


os.setlocale(locale, category)
--设置本地化，函数返回新设置的locale的子串，失败则返回nil
locale: 是一个locale的字符串
category：描述locale的哪一部分可以改变。可以设为："all", "collate", "ctype", "monetary", "numeric", or "time";
默认为"all"，即改变locale的所有属性
一个locale的书写格式为: 语言[_地域[.字符集]]


-----------------------------------------------------------------------------------------
-- package库
-----------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------
package.path      --字符串，存放require("模块")时, 需要从何路径搜寻模块的lua文件，使用loadfile加载
package.cpath     --字符串，存放require("模块")时, 当从路径找不到lua文件，需要从何路径搜寻C程序库，使用loadlib加载
package.loaded[modename]   --一个表，存放已经加载的模块名
package.seeall()  --类似setmetatable(M, {__index = _G})。使module可以访问全局变量，一般作为module的选项
package.loadlib(libname, funcname) --动态链接C函数库方式加载Lua扩展库，libname是库名，funcname入口函数
package.preload   --一个表，存放的是一个函数，通过该函数来加载modename
package.loaders   --一个表，控制require加载模块的顺序，该表中存放的是函数，每个函数负责加载一种类型的模块。
                  --默认顺序为加载package.preload,Lua Loader加载package.path,loader加载package.cpath以及all-in-one loader


-----------------------------------------------------------------------------------------
-- 全局
-----------------------------------------------------------------------------------------
_G
--全局变量表，存放所有的全局变量和函数
_VERSION
--存放当前解析器版本
assert(v, message)
--断言，如果V是false或nil，则终止程序并打印消息
collectgarbage(opt, arg)
--垃圾收集的借口
--opt可选以下参数：
"stop":停止垃圾收集
"restart":重启垃圾收集
"collect":执行完全的垃圾收集循环
"count":返回lua使用的总内存KB
"Step": 单步执行一个垃圾收集. 步长 "Size" 由参数arg指定　(大型的值需要多步才能完成)，如果要准确指定步长，需要多次实验以达最优效果。如果步长完成一次收集循环，将返回True
"Setpause": 设置 arg/100 的值作为暂定收集的时长 
"Setstepmul": 设置 arg/100 的值，作为步长的增幅(即新步长＝旧步长*arg/100)
dofile(filename)
--打开文件，并逐行执行，当参数为空是，dofile从标准输入中获取内容执行
error(message,level)
--终止程序执行，抛出错误信息message. level代表错误发生的位置，
--Level参数指示获得错误的位置,
--Level=1[默认]：为调用error位置(文件+行号)
--Level=2：指出哪个调用error的函数的函数
--Level=0:不添加错误位置信息
getfenv(f)
--得到当前函数的执行环境，是一张表，f表示level.level为0表示全局表，level为1表示调用getfenv函数的函数
getmetatable(object) 
--返回指定对象的元表
--如果没有元表，返回nil，如果元表有__metatable字段，返回这个值，如果没，则返回元表
ipairs(t) 
--迭代器，通过索引遍历表，返回3个值,只能用于数组
load(func, chunkname) 
-- 功能：装载一个块中的函数，每次调用func将返回一个连接前一结的字串，在块结尾处将返回nil
-- 当没有发生错误时，将返回一个编译完成的块作为函数,否则返回nil加上错误信息，此函数的环境为全局环境
-- chunkname用于错误和调试信息
loadfile ([filename])
--功能：与load类似，但装载的是文件或当没有指定filename时装载标准输入(stdin)的内容
loadstring (string [, chunkname])
--功能：与load类似，但装载的内容是一个字串
--如：assert(loadstring(s))()
next (table [, index])
-- 功能：允许程序遍历表中的每一个字段，返回下一索引和该索引的值。
-- 参数：table：要遍历的表
-- 　　　index：要返回的索引的前一索中的号，当index为nil[]时，将返回第一个索引的值，当索引号为最后一个索引或表为空时将返回nil
-- 注：可以用next(t)来检测表是否为空(此函数只能用于以数字索引的表与ipairs相类似)
pairs(t)
--迭代器，遍历表t，可以包括key-value对
pcall(f, ...)
--保护模式下调用f,...是函数的参数
--pcall第一个返回值为调用结果false或者true,第二个及以后返回值为错误信息或函数f的返回结果
print(...)
--打印输出结果到标准输出
rawequal (v1, v2)
功能：检测v1是否等于v2，此函数不会调用任何元表的方法
rawget (table, index)
功能：获取表中指定索引的值，此函数不会调用任何元表的方法，成功返回相应的值，当索引不存在时返回nil
rawset (table, index, value)
功能：设置表中指定索引的值，此函数不会调用任何元表的方法，此函数将返回table
index不一定为数字
require(modename)
--加载模块
查找package.loaded[modename]有无模块名，有则返回，如没有
根据package.loaders设置的顺序查找，默认顺序为：
查找package.preload[modename],有就使用该函数加载
查找package.path，存在则加载
查找package.cpath,存在则加载
查找all-in-one loader
select(index, ...) 
返回调用select()函数收到的在index以后的参数
如果index为"#"，则返回所有参数
setfenv(f, table)
功能：设置函数f的环境表为table，返回该函数
参数：f可以为函数或调用栈的级别，级别1[默认]为当前的函数,级别0将设置当前线程的环境表，这种情况无返回值
setmetatable (table, metatable)
功能：为指定的table设置元表metatable，如果metatable为nil则取消table的元表，当metatable有__metatable字段时，将触发错误。返回table
tonumber (e [, base])
功能：尝试将参数e转换为数字，当不能转换时返回nil
base(2~36)指出参数e当前使用的进制，默认为10进制，如tonumber(11,2)=3
tostirng(e)
功能：将参数e转换为字符串，此函数将会触发元表的__tostring事件
type(v)
功能：返回参数的类型名("nil"，"number", "string", "boolean", "table", "function", "thread", "userdata")
unpack (list [, i [, j]])
等价于return list[i], list[i+1], ..., list[j]
功能：返回指定表的索引的值,i为起始索引，j为结束索引
注：本函数只能用于以数字索引访问的表,否则只会返回nil 如：t={"1","cash"}
i:默认为1，j默认为表的长度
xpcall(f, err) 
保护模式下调用f,正确调用则返回true以及f的返回值
如果错误，则调用err函数处理。类似pcall