Lua-简洁、轻量、可扩展的脚本语言

转自：http://rmingwang.com/The-Programming-Language-Lua.html

 

1. 一、Lua安装及常用库的安装

2. 1.1 Ubuntu

1. $ sudo apt-get install lua5.2

3. 1.2 OS X

1. $ brew install lua luarocks # luarocks是lua的模块管理工具
2. $ sudo ln -s /usr/bin/make /usr/bin/gmake # 解决 sh: gmake: command not found

4. 1.3 luasocket库的安装

1. $ luarocks install luasocket
2. $ lua
3. > socket = require("socket")
4. > print(socket._VERSION)
5. LuaSocket 2.0.2

5. 1.4 lua-cjson库的安装

1. $ luarocks install lua-cjson
2. $ lua
3. > cjson = require("cjson")
4. > print(cjson.encode({ name = "linguofeng" }))
5. {"name":"linguofeng"}

6. 二、HelloWorld

1. $ lua
2. > print("Hello World!!")
3. Hello World!!

7. 三、数据类型 有8种基本数据类型

1. 类型 说明
2. nil 全局变量默认值，如果要删除一个全局变量可以赋值为nil
3. boolean 布尔值
4. number 数字型
5. string 字符串型
6. userdata 用户自定义类型，一般是C/C++中的类型
7. function 函数
8. thread 线程
9. table 表
10. print(type(nil)) -- 输出 nil
11. print(type(99.7+12*9)) -- 输出 number
12. print(type(true)) -- 输出 boolean
13. print(type("Hello Wikipedia")) -- 输出 string
14. print(type(print)) -- 输出 function
15. print(type{1, 2, test = "test"}) -- 输出 table

8. 四、函数 第一类值

第一类值指：在Lua中函数和其他值（数值、字符串）一样，函数可以被存放在变量中，也可以存放在表中，可以作为函数的参数，还可以作为函数的返回值。

1. function add(x, y) -- 定义一个函数add，并接收两个参数
2. local a = x + y -- 定义一个局部变量a，接收x+y的和，局部变量仅在函数add中有效
3. return a -- 返回
4. end -- 结束add函数
6. print("15 + 64 = " .. add(15, 64)); -- 打印add(15, 64)的结果
8. local x = 1 -- local 关键字表示该变量为局部变量，作用域为当前上下文
9. -- 无该关键字修饰时为全局变量，作用于整个Lua状态机
11. local add = function(x, y) -- 局部函数，作用于当前脚本（chumk）
12. Lib = {}
13. Lib.add = function(x, y) -- 表函数，作用于Lib表

9. 函数闭包

闭包是一个内部函数以及它的upvalues，内部函数使用了外部（父函数）局部变量。

1. function newCounter()
2. local i = 0 -- i为匿名函数的外部局部变量（upvalue）
3. return function() -- 匿名内部函数
4. i = i + 1 -- 使用了i，所以该匿名函数是一个闭包
5. return i
6. end
7. end
9. c1 = newCounter() -- 得到一个匿名函数的变量（闭包）
10. print(c1()) -- 调用匿名函数，打印出1
11. print(c1()) -- 调用匿名函数，打印出2
13. c2 = newCounter()
14. print(c2()) --> 1
15. print(c1()) --> 3
16. print(c2()) --> 2

10. 五、控制语句

1. for int i = 0, 10, 2 do -- for循环，2表示步长，省略时为1
2. print("i = " .. i) -- .. 表示字符串连接符
3. end -- 结束for
5. if a > b then -- if条件判断语句
6. print("a > b")
7. else
8. print("b > a")
9. end
11. while a > b do -- while循环
12. print("")
13. end
15. repeat -- repeat-until循环
16. print("")
17. until a > b

11. 六、逻辑运算符 and、or、not

逻辑运算符认为false和nil是假（false），其他为真，0也是true.

1. a and b -- 如果a为false，则返回a，否则返回b
2. a or b -- 如果a为true，则返回a，否则返回b
4. x = x or v -- 如果x为false或者nil时则给x赋初始值v
6. -- 等价于
7. if not x then
8. x = v
9. end
11. -- 三元运算符
12. a ? b : c => a and b or c -- and 的优先级别比 or 高
14. not -- not 的结果只返回false或true，作用类似于"非" "!"取反的意思
15. print(not nil) -- true
16. print(not false) -- true
17. print(not 0) -- false

12. 七、协同程序 coroutine

7.1 创建协同

1. co = coroutine.create(function () -- 创建一个协同函数，接收一个匿名函数，返回thread类型
2. print("hi")
3. end)
5. print(co) -- thread: 0x7fe1834127d0

7.2 协同的三个状态:挂起态（suspended）、运行态（running）、停止态（dead）。

1. print(coroutine.status(co)) -- 查看协同的状态，默认状态是挂起态 suspended
3. coroutine.resume(co) -- 改变协同的状态为运行太 hi
5. print(coroutine.status(co)) -- 协同运行完以后将变量停止态 dead

7.3 如此挂起正在运行的协同

1. co = coroutine.create(function ()
2. print("hi")
3. coroutine.yield() -- 协同运行到此状态将变成挂起
4. print("你好")
5. end)
7. coroutine.resume(co) -- hi
8. coroutine.resume(co) -- 你好
9. coroutine.resume(co) -- false，协同结束后将不能再使用

7.4 协同数据交换

1. co = coroutine.create(function (x, y) -- 接收两个参数
2. print("hi", coroutine.yield(x + y)) -- 返回一个值，同时参数也传递给了coroutine.yield
3. return 100 -- 第三种返回值的方式
4. end)
6. print(coroutine.resume(co, 12, 87)) -- 传递两个参数并接收返回值(true, 99)
8. -- 执行coroutine.yield(x + y)之前协同被挂起，但值被返回，因此print函数未被执行，下面执行
10. print(coroutine.resume(co, 12, 87)) -- 传递两个参数并接收返回值(true, 100)

13. 八、数据结构 table

8.1 表的创建

1. arrays = {} -- 创建一个空表
2. arrays[1] = "abc" -- 第一个索引值为1
3. arrays[2] = 123
5. arrays["key"] = "value" -- map
7. for key, value in pairs(arrays) do -- 迭代table
8. print(key .. " = " .. value)
9. end

8.2 表的增删改查

1. list = {123} -- 初始化表
2. list[2] = "abc" -- 增
3. list.x = 123
4. list.y = 987
5. list[1] = nil -- 删
6. list.y = nil
7. list[2] = 456 -- 改
8. list.x = 987
9. print(list[2]) -- 查
10. print(list.x)
11. print(list['x'])

8.3 数组

1. list = {} -- 初始空化数组，数组的下标是整数，遵循Lua的标准，下标从1开始
2. list[1] = "abc"
3. list[2] = "edg"
4. list[3] = "hij"

8.4 矩阵（二维数组）

1. mt = {} -- 创建矩阵matrix
2. for i = 1, N do -- 创建N行
3. mt[i] = {} -- 每行都是一个数组（table元素）
4. for j = 1, M do -- 创建M列
5. mt[i][j] = "a" -- 第N行第M行的值
6. end
7. end

8.5 链表

1. Singly-linked-list.svg
3. list = nil
4. list = {next = list, value = "hello3"}
5. list = {next = list, value = "hello2"}
6. list = {next = list, value = "hello1"}
8. -- 遍历
9. local l = list
10. while l do
11. print(l.value)
12. l = l.next
13. end

14. 九、metatable 元表

9.1 元表与元方法

元表也是普通表

1. t = {}
2. print(getmetatable(t)) -- 获取表的metatable nil，默认不带
4. mt = {}
5. setmetatable(t, mt) -- 设置一个元素
7. -- metamethod 元表的方法（元方法）
8. mt.__add -- 加 +
9. mt.__sub -- 减 -
10. mt.__mul -- 乘 *
11. mt.__div -- 除 /
12. mt.__unm -- 负 -
13. mt.__pow -- 幂 ^
14. mt.__concat -- 连接
16. mt.__eq -- 等于 =
17. mt.__lt -- 小于 <
18. mt.__le -- 大于 >
20. mt.__tostring -- print调用
21. mt.__metatable -- 设置该元表不被修改与访问
23. mt.__index -- 当访问不存在的元素时会去查询，相当于子类继承父类一样
24. mt.__newindex -- 更新表，如果增加一个不存在的元素，会去查询，有直接用，否则增加

9.2 表的代理

记录下表的增查记录

1. local index = {} -- 私有的key，用来记录原始表在代理表中的下标
2. local mt = { -- 创建元表
3. __index = function(t, k)
4. print("访问了" .. tostring(k) .. "元素")
5. return t[index][k] -- 从代理表中获取原始表中k下标的数据
6. end,
8. __newindex = function(t, k, v)
9. print("更新了 " .. tostring(k) .. " 元素的值为 " .. tostring(v))
10. t[index][k] = v -- 更新代理表中下标为index的原始表中的元素
11. end
12. }
14. function setProxy(t)
15. local proxy = {} -- 创建代理表
16. proxy[index] = t -- 把原始表加到代理表的index下标中
17. setmetatable(proxy, mt) -- 设置代理表的元表
18. return proxy -- 返回代理表，即所有操作都是直接操作代理表
19. end
21. p = setProxy({})
23. p[2] = 'abcdefg' -- 更新了 2 元素的值为 abcdefg
24. print(p[2]) -- 访问了2元素

15. 十、环境

10.1 全局变量 _G

1. > _G["ewgegw"] = "ddddddgege"
2. > table.foreach(_G, print)
3. string table: 0x7ffce3407a60
4. xpcall function: 0x7ffce3404780
5. package table: 0x7ffce3405780
6. tostring function: 0x7ffce3405020
7. print function: 0x7ffce3405160
8. os table: 0x7ffce34073e0
9. unpack function: 0x7ffce34050d0
10. ewgegw ddddddgege -- 上面添加的全局变量
11. require function: 0x7ffce3405e70
12. getfenv function: 0x7ffce3404db0
13. setmetatable function: 0x7ffce3404f60
14. next function: 0x7ffce3404d20
15. assert function: 0x7ffce3404a80
16. tonumber function: 0x7ffce3404fc0
17. io table: 0x7ffce3406bd0
18. rawequal function: 0x7ffce34051b0
19. collectgarbage function: 0x7ffce3404ad0
20. getmetatable function: 0x7ffce3404e00
21. module function: 0x7ffce3405e20
22. rawset function: 0x7ffce3405260
23. math table: 0x7ffce3408290
24. debug table: 0x7ffce3408c50
25. pcall function: 0x7ffce3404d70
26. table table: 0x7ffce3405f10
27. newproxy function: 0x7ffce34052e0
28. type function: 0x7ffce3405080
29. coroutine table: 0x7ffce3405380 -- 对应的是协同的表
30. _G table: 0x7ffce3404110
31. select function: 0x7ffce3404ec0
32. gcinfo function: 0x7ffce3404150
33. pairs function: 0x7ffce34048c0
34. rawget function: 0x7ffce3405210
35. loadstring function: 0x7ffce3404cc0
36. ipairs function: 0x7ffce3404830
37. _VERSION Lua 5.1
38. dofile function: 0x7ffce3404bd0
39. setfenv function: 0x7ffce3404f10
40. load function: 0x7ffce3404c70
41. error function: 0x7ffce3404c20
42. loadfile function: 0x7ffce3404e60
44. > table.foreach(_G.os, print)

10.2 非全局变量 setfenv

1. --pack.lua---------------------------------------------------------------------
2. local P = {}
4. -- 改变P表的__index,这里的_G代表全局环境
5. setmetatable(P, {__index = _G})
7. -- 改变当前的环境为P,setfenv前的所有定义都是在全局环境中进行的，后面的则都是在新环境中进行的，互不影响
8. setfenv(1, P)
10. -- 声明的add函数在环境P中，如果要在外部访问必须P.add
11. function add(x, y)
12. print(x .. ' + ' .. y .. ' = ' .. (x + y))
13. -- 由于当前新的环境中没有print函数，但是__index指向的是全局环境，所以print是全局的函数
14. end
16. return P
18. --pack1.lua--------------------------------------------------------------------
19. local P = {}
21. -- 如果需要改变环境后使用全局环境的方法需要记住，这种方法比上面的要快
22. local print = print
24. -- 改变当前的环境为P
25. setfenv(1, P)
27. -- 声明的add函数在环境P中，如果要在外部访问必须P.add
28. function add(x, y)
29. print(x .. ' + ' .. y .. ' = ' .. (x + y))
30. end
32. -- 私有方法
33. local function div(x, y)
34. end
36. return P
38. --main.lua---------------------------------------------------------------------
39. local p = require 'pack'
41. p.add(12, 34)
43. local p1 = require 'pack1'
45. p1.add(43, 19)

16. 十一、包 package

11.1 包的定义

1. -- student.lua
2. student = {}
4. function student.sayHi()
5. print('Hello')
6. end
8. return student
10. -- 使用
11. student = require("student")
12. student.sayHi() -- Hello
13. 11.2 私有函数
15. local function _add(x, y) -- 私有局部函数
16. return x + y
17. end
19. utils = { -- utils包
20. add = _add -- 对外公开的函数
21. }
23. return utils

17. 十二、面向对象

12.1 类与继承

1. --Person.lua
2. local Person = {name = ''}
4. function Person:getName()
5. return self.name
6. end
8. function Person:setName(name)
9. self.name = name
10. end
12. function Person:new(object)
13. object = object or {}
14. setmetatable(object, {__index = self}) -- 元表 类似继承的意思
15. return object
16. end
18. return Person
20. --main.lua
21. -- 类
22. local Person = require 'Person'
24. -- 对象
25. local student = Person:new({age = 23})
26. student:setName('Tom')
28. print('name: ' .. student:getName() .. ' age: ' .. student.age)

12.2 多重继承

实际就是记住所有父类，然后访问不存在的元素的时候去查询哪个父类中有，有就执行

1. local function search (k, plist)
2. for i=1, table.getn(plist) do
3. local v = plist[i][k] -- 去所有父类中获取
4. if v then return v end
5. end
6. end
8. function Person:new(...)
9. local o = {}
11. setmetatable(o, {__index = function (t, k)
12. local v = search(k, arg)
13. t[k] = v -- save for next access
14. return v
15. end})
17. return o
18. end

12.3 私有性

1. local function createAccount(_name) -- 工厂方法
2. local self = {name = _name}
4. local function _setName(name)
5. self.name = name
6. end
8. local function _getName()
9. return self.name
10. end
12. -- 公有方法表
13. local public = {
14. setName = _setName,
15. getName = _getName,
16. --name = self.name -- 不公开私有成员变量
17. }
19. return public
20. end
22. local account = createAccount('Tom')
23. print(account.name) -- 无法访问，因为没有公开

18. 十三、weak table

1. t = {name = 'table'} -- 创建一个普通表
2. setmatetable(t, {__made = 'k'}) -- k表示t表中的keys是weak的，v表示t表中的values是weak的
4. k = {} -- 创建一个空表，此时{}被k引用，引用值为1
5. t[k] = 1 -- 把空表作为key，由于t表的key是weak的，所以k值的引用如果为0则会被gc回收，如
6. k = {} -- 把k指向另一个新的{}，则旧的{}引用值减1变成0了，目前t[k] = 1还有效
7. t[k] = 2 -- 把新的{}作为key，值是2
9. collectgarbage() -- 调用gc，清除引用为0的内存空间，此时，第一个{}的引用是0，会被gc掉，所以第一个t[k]以及值会被删除
11. for k, v in pairs(a) do print(v) end
12. -- 此时应该只剩下2了，因为第2个k = {}时改变了k指向新的{}，而旧的{}引用会变成0，被gc掉
14. -------------------------------------------------------------------------
16. a = {};
17. setmetatable(a, {__mode = 'v'}); -- values为weak，当值的引用为0时，删除
18. v1 = {name = 'v1'}
19. v2 = {name = 'v2'}
21. a[1] = v1
22. a[2] = v2
24. v1 = v2
26. collectgarbage(); -- 调用GC，清掉weak表中没有引用的内存
28. for k, v in pairs(a) do print(v.name) end
29. -- 输出v2，因为v1重新指向{name = 'v2'}，则{name = 'v1'}引用减1为0
31. -------------------------------------------------------------------------
33. a = {};
34. setmetatable(a, {__mode = 'kv'}); -- 同时检查kv，是上面两种情况的组合
35. v1 = {name = 'v1'}
36. v2 = {name = 'v2'}
38. v = {}
39. k = {}
41. a[1] = v
42. v = {} -- value重新引用新值，旧值被gc，如果旧值在table则对应的记录被清空
43. a[2] = v
45. a[k] = 1
46. k = {} -- key重新引用新值，旧值被gc，如果旧值在table则对应的记录被清空
47. a[k] = 2
50. collectgarbage(); -- 调用GC，清掉weak表中没有引用的内存
52. for k, v in pairs(a) do
53. print(v)
54. end

19. 十四、标准库

19.1. 14.1 数学库 Mathematical Functions

1. 函数 说明
2. math.abs (x) 求绝对值
3. math.acos (x) 求反余弦
4. math.asin (x)
5. math.atan (x)
6. math.atan2 (y, x)
7. math.ceil (x)
8. math.cos (x)
9. math.cosh (x)
10. math.deg (x)
11. math.exp (x)
12. math.floor (x)

20. 14.2 table库

1. 函数 说明
2. table.concat (table [, sep [, i [, j]]]) 拼接成字符串，sep代表连接符，i开始位置，j结束位置
3. table.insert (table, [pos,] value) 插入一个元素，默认是最后一个，pos指定位置
4. table.maxn (table) 获取最大长度
5. table.remove (table [, pos]) 删除一个元素，默认删除最后一个，pos指定位置
6. table.sort (table [, comp]) 排序
7. tables = {1, 2, 3, 4, 5, 6, 7}
8. print(#tables) -- 5.1开始使用#获取长度 -- 7
10. table.insert(tables, 8)
11. print(table.concat(tables)) -- 12345678
12. table.insert(tables, 1, 0)
13. print(table.concat(tables)) -- 012345678
16. print(table.maxn(tables)) -- 9
18. table.remove(tables)
19. print(table.concat(tables)) -- 01234567
21. table.remove(tables, 5)
23. print(table.concat(tables)) -- 0123567
24. print(table.concat(tables, ',')) -- 0,1,2,3,5,6,7
25. print(table.concat(tables, '-', 2)) -- 1-2-3-5-6-7
26. print(table.concat(tables, '=', 1, 4)) -- 0=1=2=3
28. table.sort(tables)
29. print(table.concat(tables)) -- 0123567
31. table.sort(tables, function(t1, t2)
32. if t1 > t2 then
33. return true
34. else
35. return false
36. end
37. end)
38. print(table.concat(tables)) -- 7653210

21. 14.3 string库

1. 函数 说明
2. string.byte (s [, i [, j]]) 把字符转换成ASCII码
3. string.char (…) 把ASCII码转换成字符
4. string.dump (function)
5. string.find (s, pattern [, init [, plain]]) 查找，pattern查找的字符串，init从那里开始默认为1，plain
6. string.format (formatstring, …) 格式化字符串

22. 14.4 io库

1. 函数 说明
2. io.close ([file]) 等效file:close()，如果没有file则关闭默认输出
3. io.flush () 等效file:flush()
4. io.input ([file])
5. io.lines ([filename]) 等效io.input():lines()
6. io.open (filename [, mode]) 打开一个文件，模式：r,w,a,r+,w+,a+
7. io.output ([file])
8. io.popen (prog [, mode]) 依赖系统的，不是所有平台都能用
9. io.read (…) 等效io.input():read
10. io.tmpfile () 创建一个临时文件，当程序退出时自动删除
11. io.type (obj) 判断obj的类型，如果返回file是一个打开的文件句柄，返回close file是一个
12. 关闭的文件句柄，nil不是文件
13. io.write (…) 等效io.output():write
14. file:close () 关闭文件，会自动gc掉，但时间不确定
15. file:flush () 保存任何数据到文件中
16. file:lines () 迭代文件的每一行
17. file:read (…) 读取文件，*n,*a,*l,number
18. file:seek ([whence] [, offset]) 指定位置，默认是cur,1，set,end
19. file:setvbuf (mode [, size]) 设置buff缓存，no,full,line
20. file:write (…) 写文件，参数必须是string或者number
21. local file = io.open('tabletest.lua', 'r')
22. print(io.type(file))
24. for line in file:lines() do
25. --print(line)
26. end
28. --file:close()
29. io.close(file)
30. print(io.type(file))
32. ------------------------------------------------------
34. for line in io.input('tabletest.lua'):lines() do
35. print(line)
36. end
38. for line in io.lines('tabletest.lua') do
39. --print(line)
40. end

23. 14.5 os库

1. 函数 说明
2. os.clock () 返回程序所使用的cpu时间
3. os.date ([format [, time]]) 当前系统日期，或格式化某个日期
4. os.difftime (t2, t1) 时间差
5. os.execute ([command]) 执行shell命令
6. os.exit ([code]) 调用C的exit函数
7. os.getenv (varname) 获取系统环境变量，变量名，不包含$
8. os.remove (filename) 删除文件，文件名
9. os.rename (oldname, newname) 修改文件名
10. os.setlocale (locale [, category]) 设置地区，"all", “collate”, “ctype”, “monetary”, “numeric”, or “time”
11. os.time ([table]) 返回当前时间或把时间保存在table中，
12. os.tmpname () 临时文件名
13. table.foreach(os, print)
15. print(os.clock())
17. print(os.date())
19. print(os.date('%Y-%m-%d %H:%M'))
21. print(os.time())
23. print(os.difftime(1364957757, os.time()))
25. print(os.getenv ('PATH'))
27. print(os.tmpname ())

14.6 debug库

函数 说明

24. 十五、标准库

15.1 堆栈，后进先出原则

25. 压入

1. 函数 说明(栈底最后一个元素的索引是1,栈顶第一个元素是-1)
2. lua_pushnil(lua_State*) 压入一个空值
3. lua_pushboolean(lua_State*, int) 压入一个布尔值
4. lua_pushcclosure(lua_State*, lua_CFunction, int) 压入一个C闭包?
5. lua_pushcfunction(lua_State*, lua_CFunction) 压入一个C函数，由lua_pushcclosure(L, f, 0)宏定义出来
6. lua_pushlightuserdata(lua_State*, void*) 压入一个指针，不被gc管理
7. lua_pushinteger(lua_State*, lua_Integer) 压入一个数字
8. lua_pushnumber(lua_State*, lua_Number) 压入数字
9. lua_pushstring(lua_State*, const char*) 压入字符串
10. lua_pushfstring(lua_State*, const char*, …) 压入一个格式化的string
11. lua_pushvfstring(lua_State*, const char*, va_list) 同上，只是接收一个va_list
12. lua_pushlstring(lua_State*, const char*, size_t); 压入长字符串
13. lua_pushliteral(lua_State*, const char*) 压入文字
14. lua_pushthread(lua_State*) 压入一个线程?

26. 判断类型

1. 函数 说明
2. lua_isboolean(lua_State*, int) 是否是布尔类型
3. lua_iscfunction(lua_State*, int) 是否是C函数类型
4. lua_isfunction(lua_State*, int) 是否是C函数或者Lua函数
5. lua_islightuserdata(lua_State*, int) 是否是用户自定义类型指针
6. lua_isnil(lua_State*, int) 是否是空
7. lua_isnone(lua_State*, int) 是否是有效的
8. lua_isnoneornil(lua_State*, int) 是否是上面两者
9. lua_isnumber(lua_State*, int) 是否是数字
10. lua_isstring(lua_State*, int) 是否是字符串
11. lua_istable(lua_State*, int) 是否是table
12. lua_isthread(lua_State*, int) 是否是线程
13. lua_isuserdata(lua_State*, int) 是否是用户类型，包括full和light
14. lua_type(lua_State*, int) 返回元素的类型，对应LUA_TNIL等枚举
15. lua_typename(lua_State*, int) 返回元素的类型名称

27. 获取栈中的元素并转换成C类型

1. 函数 说明 返回值类型
2. lua_toboolean(lua_State*, int) 把元素转换成C的布尔类型的值 int
3. lua_tocfunction(lua_State*, int) 把元素转换成C的函数 lua_CFunction
4. lua_tointeger (lua_State*, int) lua_Integer
5. lua_tolstring (lua_State*, int, size_t *len) const char*
6. lua_tonumber (lua_State*, int) lua_Number
7. lua_topointer (lua_State*, int) const void*
8. lua_tostring (lua_State*, int) const char*
9. lua_tothread (lua_State*, int) lua_State
10. lua_touserdata (lua_State*, int) void*
11. 栈内元素的操作
13. 函数 说明
14. lua_gettop(lua_State*) 返回栈的元素个数，同时也是栈顶元素的索引
15. lua_settop(lua_State*, int) 设置某个元素为栈顶元素，该元素之上的元素会被清除
16. lua_pushvalue(lua_State*, int) 压入（拷贝）一个已经存在栈的元素至栈顶
17. lua_insert(lua_State*, int) 移动栈顶元素至某个位置
18. lua_remove(lua_State*, int) 删除栈中某个元素
19. lua_replace(lua_State*, int) 替换栈顶元素至某个位置，相应那个位置的元素至栈顶

参考：http://book.luaer.cn

参考：http://www.lua.org/manual/5.1/manual.html

原文地址:http://blog.linguofeng.com/pages/language/lua.html