Lua5.1编程1：Lua语言基础

Lua的设计目的是依赖C的高效，并提供C所没有动态结构、高层抽象、内存回收、高阶函数等功能。

Lua本身很小，功能有限，大部分功能来源于其标准库。但本身提供的简单、高效、高扩展、可移植等特性，使得在特定场景中Lua有用武之地。

1 语言基础
1.1 词法约定
Lua语言是一种区分大小写的语言。变量命名和C一样，只能使用字母数字和下划线，数字不能位于开始。以下划线开始的变量默认为Lua自己使用的变量。

Lua中有20+个关键字，不能作为变量使用。诸如for while do end之类的。

Lua中的语句最好以;进行分隔。

1.2 注释
-- 这是行注释
--[[ 这是块
     注释 
  ]]

1.3 变量
变量不需要声明，无修饰的变量默认为全局变量，变量未初始化时值为nil。如果需要删除一个变量，将其置为nil即可。

系统初始化的全局变量 ： _VERSION lua的版本号；_PROMPT  解释器的提示符样式

局部变量使用local来修饰，如local x = 0; 局部变量的作用域只限于声明它们的块。

lua的变量为词法变量，在局部作用域中，局部变量会覆盖全局作用域中的同名变量。

1.4 lua解析器程序

lua代码有几种方式执行：

lua prog.lua args 
lua -e "lua code;"
如果传递了脚本参数，则会创建一个名为arg的表，脚本名位于索引0上，其后的参数索引从1开始，其前的参数则位于负数索引上。

2 类型与值

Lua是动态类型语言，类型不在变量名上绑定，而在值中存储。

Lua中有8种基础类型，nil bool number string function thread table userdata。所有的类型均为FirstClass的。type()可以返回一个变量的类型。

number 表示的为双精度浮点数，取值范围大约在1.79e-308,1.79e+308之间，计算时不会出现四舍五入的错误。
string 表示一个字符序列，采用8位编码，可以包含C的转义序列。其为不可修改的值对象。类似于python的doc string 可以将使用[[]]将一大块字符串包含在其中，而避免其中的特殊字符被转义。 #"hello" = 5
   tonumber()  将字符串转换为数
   tostring()      将数字转换为字符串
   ..                     字符串连接符
table  类似于python中的dict，表示关联数组。不仅可用整数来索引，也可用字符串等类型来索引。索引从1开始。
   初始化 t = {1，2，3}; t = {x=1,y=2}; t ={['key']=value, }; 
   取值   t[1] = 10; t['key'] = value; t.key = value; 
userdata 用于存储C语言传递的数据结构。

3 表达式与语法

3.1 运算符
算法运算符  + - * / ^ % 
关系运算符  < <= > >= ~= ==
逻辑运算符 and or not 

赋值 x=1; x,y = y,x; t[1] = 0;  如果右侧值过少，则多余的变量赋值为nil

3.2 控制结构
Lua不支持switch，if..else结构会比较常见

[plain]  view plain copy print ?

1. if a < 0 then  
2.     t = -1;  
3. elseif a = 0 then  
4.     t = 0  
5. else  
6.     t = 1  
7. end  

while结构

[plain]  view plain copy print ?

1. while i < 10 do  
2.     print(i*2);  
3.     i = i + 1;  
4. end  

repeat结构

[plain]  view plain copy print ?

1. repeat  
2.     print(2*i);  
3.     i = i + 1;  
4. until  
5.     i < 10;  

for结构

[plain]  view plain copy print ?

1. for i = 1, 10, 1 do  
2.    print(2*i)  
3. end  

泛型for

[plain]  view plain copy print ?

1. for k,v in pairs(t) do  
2.     print(k,v)  
3. end  

支持break退出当前循环，return用于从当前函数返回。

5 函数

函数调用时需要将参数放在括号中，但如果只有一个参数且参数为字符串或table构造表达式时，可不使用括号。

[plain]  view plain copy print ?

1. function foo(str,key)  
2.     local start,end = string.find(string,key);  
3.     return start,end  
4. end  

传递参数时和多重赋值类似，如果形参少，则未能赋值的值为nil，多余的参数将丢弃。此外函数可以返回多重值。

unpack可以将数组中的元素解出来，作为多重值返回。

...可以作为变长参考来进行传递和使用。...的行为类似于一个具有多重返回值的函数，返回所有参数。

[plain]  view plain copy print ?

1. function add(...)  
2.     local s = 0;  
3.     for i,v in ipairs(...)  
4.         s = s + v  
5.     end  
6.     return s  
7. end  

利用table，可以使用键值参数，如

[plain]  view plain copy print ?

1. fun(arg)  
2.     return arg.old,arg.new;  
3. end  
4.   
5. fun({old="1",new="2"});  

6 闭包
Lua支持词法作用域，同时函数又是第一类的。因此可以实现函数式编程的范式。高阶函数可以使用函数处理逻辑。
这样内部定义的函数可以访问外层函数的局部变量。并将外层的变量闭包在自己的对象中。从而可以脱离外层函数来单独调用。

Lua中的模块即使用在了table结合函数指针。

[plain]  view plain copy print ?

1. Lib = {}  
2. Lib.fun = function() ... end  
3. Lib.foo = function() ... end  

对于递归调用，支持尾递归。但需要实现尾调用。即函数在调用完另一个函数之后，是否无其他事情需要做了。
只有形式上是return <fun>(args); 这样的调用才算是尾调用。只要args在调用前能求出值即可。


7 迭代器与泛型for
和ipairs等价的迭代器

[plain]  view plain copy print ?

1. function values(t)  
2.     local i = 0;  
3.     return function() i=i+1 return t[i] end  
4. end  

for的实现

[plain]  view plain copy print ?

1. for var_1,...,var_n in <explist> do  
2.     <block>  
3. end  
4. --等价于下面的代码  
5. do  
6.     local _func, _state,_var = <explist>  
7.     while true do  
8.         local var1,...,var_n = _func(_state,_var)  
9.         _var = var1  
10.         if _var == nil then  
11.             break  
12.         end  
13.         <block>  
14.     end  
15. end  

8 文件加载与错误处理
8.1 加载文件
loadfile只加载文件，但不执行。dofile()则不仅仅会加载而且会执行。loadstring()则加载一段代码的字符串。需要注意的是对于字符串，其在运行时编译时，会在全局变量环境中查找变量。调用会返回一个函数闭包。

[plain]  view plain copy print ?

1. function dofile(file)  
2.     local f = assert(loadfile(file))  
3.     f()  
4. end  

只有执行了f()，文件中的定义才能生效，接下来才能使用文件中定义的函数等。

8.2 加载C库
Lua提供的底层关于动态链接的功能聚集在package.loadlib函数上。

[plain]  view plain copy print ?

1. local f = package.loadlib("/usr/lib/socket.so","luaopen_socket").  

通常我们并不需要直接使用它，只需要require("socket")即可。

8.3 错误与异常处理
assert(expr,msg) 当expr表达式为true时返回expr，为假时触发错误，并打印msg信息。
error("msg")     抛出异常并输出msg,error可以返回任何类型的数据，如返回table
pcall(func,fun_args)      以try..catch类似的方式，捕获func调用中出现的error异常，其返回两个参数，第一个参数表示是否出现异常，第二个异常或func返回值。

[plain]  view plain copy print ?

1. if pcall (func) then  
2.    <block> --成功执行func  
3. else then  
4.     <block> --异常处理  
5. end  

xpcall(func,errHandler)  当出现异常时，在异常现场调用errHandler
debug.traceback()  打印当前的调用栈

9 协同例程(coroutine)
coroutine类似于一个独立的执行线程逻辑，但与线程的区别是，多个coroutine并不是同时执行的，而互相协调，串行执行的。不执行的将让出CPU，以让其他的coroutine来执行。
coroutine.create(func)             创建一个协程，返回协程的id，此时co处于suspended状态
coroutine.resume(co,args)    执行创建的协程，
coroutine.status(co)                返回协程的状态
coroutine.yield(args)               当前运行的协程，通过调用yield挂起自己，使得之前的resume调用可以返回yield传递的参数。只有再次调用resume时，yield()才返回resume调用传 入的参数，使得协程可以向下运行，并交换数据。

运行中协程处于running状态，运行结束则处于dead状态。对于一个死亡状态的协程，调用resume将返回false和一个错误消息。如果协程A在运行中resume了协程B，则A处于normal状态。

示例：使用协程实现生产者和消费者

[plain]  view plain copy print ?

1. function producer(consumer)  
2.     while(true) do  
3.         x=io.read("*number");  
4.         send(x,consumer)  
5.     end  
6. end  
7.   
8. function filter(consumer)  
9.     while(true) do  
10.         x = receive();  
11.         x = x*x ;  
12.         send(x,consumer)  
13.     end  
14. end  
15.   
16. function consumer()  
17.     while(true) do  
18.         x = receive()  
19.         print("In consumer use ",x)  
20.     end  
21. end  
22.   
23. function send(x,consumer)  
24.     coroutine.resume(consumer,x)  
25. end  
26.   
27. function receive()  
28.     value = coroutine.yield();  
29.     return value;  
30. end  
31.   
32. coc = coroutine.create(consumer);  
33. cof = coroutine.create(filter);  
34. cop = coroutine.create(producer);  
35.   
36. coroutine.resume(coc)  
37. coroutine.resume(cof,coc);  
38. coroutine.resume(cop,cof)  

参考文献

Lua程序设计第二版
Lua Reference 翻译 http://www.photoneray.com/Lua-5.2-Reference-Manual-ZH_CN/