1 #include <lua.hpp>   
  2 #include <lauxlib.h>   
  3 #include <lualib.h>   
  4 #include <limits.h>   
  5    
  6 #define BITS_PER_WORD (CHAR_BIT * sizeof(int))   
  7 #define I_WORD(i)     ((unsigned int)(i))/BITS_PER_WORD   
  8 #define I_BIT(i)      (1 << ((unsigned int)(i)%BITS_PER_WORD))   
  9   
  10 typedef struct NumArray {  
  11     int size;  12     unsigned int values[1];  
  13 } NumArray;  
  14   
  15 extern "C" int newArray(lua_State* L)  
  16 {  
  17     //1. 检查第一个参数是否为整型。以及该参数的值是否大于等于1.  
  18     int n = luaL_checkint(L,1);  
  19     luaL_argcheck(L, n >= 1, 1, "invalid size.");  
  20     size_t nbytes = sizeof(NumArray) + I_WORD(n - 1) * sizeof(int);  
  21     //2. 参数表示Lua为userdata分配的字节数。同时将分配后的userdata对象压入栈中。  
  22     NumArray* a = (NumArray*)lua_newuserdata(L,nbytes);  
  23     a->size = n;  
  24     for (int i = 0; i < I_WORD(n - 1); ++i)  
  25         a->values[i] = 0;  
  26     //获取注册表变量myarray，该key的值为metatable。  
  27     luaL_getmetatable(L,"myarray");  
  28     //将userdata的元表设置为和myarray关联的table。同时将栈顶元素弹出。  
  29     lua_setmetatable(L,-2);  
  30     return 1;  
  31 }  
  32   
  33 extern "C" int setArray(lua_State* L)  
  34 {  
  35     //1. Lua传给该函数的第一个参数必须是userdata，该对象的元表也必须是注册表中和myarray关联的table。  
  36     //否则该函数报错并终止程序。  
  37     NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");  
  38     int index = luaL_checkint(L,2) - 1;  
  39     //2. 由于任何类型的数据都可以成为布尔值，因此这里使用any只是为了确保有3个参数。  
  40     luaL_checkany(L,3);  
  41     luaL_argcheck(L,a != NULL,1,"'array' expected.");  
  42     luaL_argcheck(L,0 <= index && index < a->size,2,"index out of range.");  
  43     if (lua_toboolean(L,3))  
  44         a->values[I_WORD(index)] |= I_BIT(index);  
  45     else  
  46         a->values[I_WORD(index)] &= ~I_BIT(index);  
  47     return 0;  
  48 }  
  49   
  50 extern "C" int getArray(lua_State* L)  
  51 {  
  52     NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");  
  53     int index = luaL_checkint(L,2) - 1;  
  54     luaL_argcheck(L, a != NULL, 1, "'array' expected.");  
  55     luaL_argcheck(L, 0 <= index && index < a->size,2,"index out of range");  
  56     lua_pushboolean(L,a->values[I_WORD(index)] & I_BIT(index));  
  57     return 1;  
  58 }  
  59   
  60 extern "C" int getSize(lua_State* L)  
  61 {  
  62     NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");  
  63     luaL_argcheck(L,a != NULL,1,"'array' expected.");  
  64     lua_pushinteger(L,a->size);  
  65     return 1;  
  66 }  
  67   
  68 extern "C" int array2string(lua_State* L)  
  69 {  
  70     NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");  
  71     lua_pushfstring(L,"array(%d)",a->size);  
  72     return 1;  
  73 }  
  74   
  75 static luaL_Reg arraylib_f [] = {   
  76     {"new", newArray},  
  77     {NULL, NULL}   
  78 };   
  79   
  80 static luaL_Reg arraylib_m [] = {  
  81     {"set", setArray},  
  82     {"get", getArray},  
  83     {"size", getSize},  
  84     {"__tostring", array2string}, //print(a)时Lua会调用该元方法。  
  85     {NULL, NULL}   
  86 };  
  87   
  88 extern "C" __declspec(dllexport)  
  89 int luaopen_testuserdata(lua_State* L)  
  90 {  
  91     //1. 创建元表，并将该元表指定给newArray函数新创建的userdata。在Lua中userdata也是以table的身份表现的。  
  92     //这样在调用对象函数时，可以通过验证其metatable的名称来确定参数userdata是否合法。  
  93     luaL_newmetatable(L,"myarray");  
  94     lua_pushvalue(L,-1); 
  95     //2. 为了实现面对对象的调用方式，需要将元表的__index字段指向自身，同时再将arraylib_m数组中的函数注册到  
  96     //元表中，之后基于这些注册函数的调用就可以以面向对象的形式调用了。  
  97     //lua_setfield在执行后会将栈顶的table弹出。  
  98     lua_setfield(L,-2,"__index");  
  99     //将这些成员函数注册给元表，以保证Lua在寻找方法时可以定位。NULL参数表示将用栈顶的table代替第二个参数。   
  100    luaL_register(L,NULL,arraylib_m); 
  101     //这里只注册的工厂方法。 
  102     luaL_register(L,"testuserdata",arraylib_f); 
  103     return 1; 
  104 }

1 #include <stdio.h>  
2 #include <string.h>  
3 #include <lua.hpp>  
4 #include <lauxlib.h>  
5 #include <lualib.h>  
6   
7 //待Lua调用的C注册函数。  
8 static int add2(lua_State* L)  
9 { 
10     //检查栈中的参数是否合法，1表示Lua调用时的第一个参数(从左到右)，依此类推。 
11     //如果Lua代码在调用时传递的参数不为number，该函数将报错并终止程序的执行。 
12     double op1 = luaL_checknumber(L,1); 
13     double op2 = luaL_checknumber(L,2); 
14     //将函数的结果压入栈中。如果有多个返回值，可以在这里多次压入栈中。 
15     lua_pushnumber(L,op1 + op2); 
16     //返回值用于提示该C函数的返回值数量，即压入栈中的返回值数量。 
17     return 1; 
18 } 
19  
20 //另一个待Lua调用的C注册函数。 
21 static int sub2(lua_State* L) 
22 { 
23     double op1 = luaL_checknumber(L,1); 
24     double op2 = luaL_checknumber(L,2); 
25     lua_pushnumber(L,op1 - op2); 
26     return 1; 
27 } 
28  
29 const char* testfunc = "print(add2(1.0,2.0)) print(sub2(20.1,19))"; 
30  
31 int main() 
32 { 
33     lua_State* L = luaL_newstate(); 
34     luaL_openlibs(L); 
35     //将指定的函数注册为Lua的全局函数变量，其中第一个字符串参数为Lua代码 
36     //在调用C函数时使用的全局函数名，第二个参数为实际C函数的指针。 
37     lua_register(L, "add2", add2); 
38     lua_register(L, "sub2", sub2); 
39     //在注册完所有的C函数之后，即可在Lua的代码块中使用这些已经注册的C函数了。 
40     if (luaL_dostring(L,testfunc)) 
41         printf("Failed to invoke.\n"); 
42     lua_close(L); 43     return 0; 44 }

1 #include <stdio.h>  
2 #include <string.h>  
3 #include <lua.hpp>  
4 #include <lauxlib.h>  
5 #include <lualib.h>  
6   
7 //待注册的C函数，该函数的声明形式在上面的例子中已经给出。  
8 //需要说明的是，该函数必须以C的形式被导出，因此extern "C"是必须的。  
9 //函数代码和上例相同，这里不再赘述。 
10 extern "C" int add(lua_State* L)  
11 { 12     double op1 = luaL_checknumber(L,1); 
13     double op2 = luaL_checknumber(L,2); 
14     lua_pushnumber(L,op1 + op2); 
15     return 1; 
16 } 
17  
18 extern "C" int sub(lua_State* L) 
19 { 
20     double op1 = luaL_checknumber(L,1);
21     double op2 = luaL_checknumber(L,2); 
22     lua_pushnumber(L,op1 - op2); 
23     return 1; 
24 } 
25  
26 //luaL_Reg结构体的第一个字段为字符串，在注册时用于通知Lua该函数的名字。 
27 //第一个字段为C函数指针。 
28 //结构体数组中的最后一个元素的两个字段均为NULL，用于提示Lua注册函数已经到达数组的末尾。 
29 static luaL_Reg mylibs[] = {  
30     {"add", add}, 
31     {"sub", sub}, 
32     {NULL, NULL}  
33 };  
34  
35 //该C库的唯一入口函数。其函数签名等同于上面的注册函数。见如下几点说明： 
36 //1. 我们可以将该函数简单的理解为模块的工厂函数。 
37 //2. 其函数名必须为luaopen_xxx，其中xxx表示library名称。Lua代码require "xxx"需要与之对应。 
38 //3. 在luaL_register的调用中，其第一个字符串参数为模块名"xxx"，第二个参数为待注册函数的数组。 
39 //4. 需要强调的是，所有需要用到"xxx"的代码，不论C还是Lua，都必须保持一致，这是Lua的约定， 
40 //   否则将无法调用。 
41 extern "C" __declspec(dllexport) 
42 int luaopen_mytestlib(lua_State* L)  
43 { 
44     const char* libName = "mytestlib"; 
45     luaL_register(L,libName,mylibs); 
46     return 1; 
47 }

1 require "mytestlib"  --指定包名称 
2  
3 --在调用时，必须是package.function 
4 print(mytestlib.add(1.0,2.0)) 
5 print(mytestlib.sub(20.1,19))

 1 #include <stdio.h>
 2 #include <string.h>
 3 #include <lua.hpp>
 4 #include <lauxlib.h>
 5 #include <lualib.h>
 6 
 7 int main(void)
 8 {
 9     const char* buff = "print(\"hello\")";
10     int error;
11     lua_State* L = luaL_newstate();
12     luaL_openlibs(L);
13 
14     error = luaL_loadbuffer(L,buff,strlen(buff),"line") || lua_pcall(L,0,0,0);
15     int s = lua_gettop(L);
16     if (error) {
17         fprintf(stderr,"%s",lua_tostring(L,-1));
18         lua_pop(L,1);
19     }
20     lua_close(L);
21     return 0;
22 }

 1 static void stackDump(lua_State* L) 
 2 {
 3     int top = lua_gettop(L);
 4     for (int i = 1; i <= top; ++i) {
 5         int t = lua_type(L,i);
 6         switch(t) {
 7         case LUA_TSTRING:
 8             printf("'%s'",lua_tostring(L,i));
 9             break;
10         case LUA_TBOOLEAN:
11             printf(lua_toboolean(L,i) ? "true" : "false");
12             break;
13         case LUA_TNUMBER:
14             printf("%g",lua_tonumber(L,i));
15             break;
16         default:
17             printf("%s",lua_typename(L,t));
18             break;
19         }
20         printf("");
21     }
22     printf("\n");
23 }

 1 int main()
 2 {
 3     lua_State* L = luaL_newstate();
 4     lua_pushboolean(L,1);
 5     lua_pushnumber(L,10);
 6     lua_pushnil(L);
 7     lua_pushstring(L,"hello");
 8     stackDump(L); //true 10 nil 'hello'
 9 
10     lua_pushvalue(L,-4);
11     stackDump(L); //true 10 nil 'hello' true
12 
13     lua_replace(L,3);
14     stackDump(L); //true 10 true 'hello'
15 
16     lua_settop(L,6);
17     stackDump(L); //true 10 true 'hello' nil nil
18 
19     lua_remove(L,-3);
20     stackDump(L); //true 10 true nil nil
21 
22     lua_settop(L,-5);
23     stackDump(L); //true
24 
25     lua_close(L);
26     return 0;
27 }

 1 dd = os.date("*t",os.time())  --如果格式化字符串为"*t"，函数将返回table形式的日期对象。如果为"!*t"，则表示为UTC时间格式。
 2 print("year = " .. dd.year)
 3 print("month = " .. dd.month)
 4 print("day = " .. dd.day)
 5 print("weekday = " .. dd.wday)  --一个星期中的第几天，周日是第一天
 6 print("yearday = " .. dd.yday)  --一年中的第几天，1月1日是第一天
 7 print("hour = " .. dd.hour)
 8 print("min = " .. dd.min)
 9 print("sec = " .. dd.sec)
10     
11 --[[
12 year = 2012
13 month = 4
14 day = 5
15 weekday = 5
16 yearday = 96
17 hour = 11
18 min = 13
19 sec = 44
20 --]]

1 local x = os.clock()
2 local s = 0
3 for i = 1, 10000000 do 
4     s = s + i 
5 end
6 print(string.format("elapsed time: %.2f\n", os.clock() - x))
7 
8 --输出结果为：
9 --elapsed time: 0.21    

1 for count = 1,math.huge do
2     local line = io.read("*line")  --如果不传参数，缺省值也是"*line"
3     if line == nil then 
4         break
5     end
6     io.write(string.format("%6d  ",count),line,"\n")
7 end

1 local lines = {}
2 for line in io.lines() do   --通过迭代器访问每一个数据
3     lines[#lines + 1] = line
4 end
5 table.sort(lines)  --排序，Lua标准库的table库提供的函数。
6 for _,l in ipairs(lines) do
7     io.write(l,"\n")
8 end

 1 --[[
 2     6.0  -3.23   1000
 3     ... ...
 4     下面的代码读取注释中的数字
 5 --]]
 6 while true do
 7     local n1,n2,n3 = io.read("*number","*number","*number")
 8     if not n1 then
 9         break
10     end
11     print(math.max(n1,n2,n3))
12 end

1 while true do
2     local block = io.read(2^13)
3     if not block then
4         break
5     end
6     io.write(block)
7 end

1 local f = assert(io.open(filename,"r"))
2 local t = f:read("*all")  --对于read而言，其参数完全等同于简单模型下read的参数。
3 f:close()

1 local temp = io.input()   --将当前文件句柄保存
2 io.input("newInputfile")  --打开新的输入文件
3 io.input():close()        --关闭当前文件
4 io.input(temp)            --恢复原来的输入文件

 1 local BUFSIZE = 8192
 2 local f = io.input(arg[1])  --打开输入文件
 3 local cc, lc, wc, = 0, 0, 0  --分别计数字符、行和单词    
 4 while true do
 5     local lines,rest = f:read(BUFSIZE,"*line")
 6     if not lines then
 7         break
 8     end
 9     if rest then
10         lines = lines .. rest .. "\n"
11     end
12     cc = cc + #lines
13     --计算单词数量
14     local _, t = string.gsub(lines."%S+","")
15     wc = wc + t
16     --计算行数
17     _,t = string.gsub(line,"\n","\n")
18     lc = lc + t
19 end
20 print(lc,wc,cc)

1 function fsize(file)
2     local current = file:seek()   --获取当前位置
3     local size = file:seek("end") --获取文件大小
4     file:seek("set",current)      --恢复原有的当前位置
5     return size
6 end

1 s = "hello world"
2 i, j = string.find(s,"hello")  
3 print(i, j)        --输出1  5
4 i, j = string.find(s,"l")
5 print(i, j)        --输出3  3
6 print(string.find(s,"lll"))  --输出nil

1 local t = {}
2 local i = 0
3 while true do
4     i = string.find(s,"\n",i+1)
5     if i == nil then
6         break
7     end
8     t[#t + 1] = i
9 end

1 date = "Today is 2012-01-01"
2 d = string.match(date,"%d+\-%d+\-%d+")
3 print(d)  --输出2012-01-01

1 words = {}
2 s = "hello world"
3 for w in string.gmatch(s,"%a+") do
4     print(w)
5     words[#words + 1] = w
6 end
7 --输出结果为：
8 --hello
9 --world

1 pair = "name = Anna"
2 key,value = string.match(pair,"(%a+)%s*=%s*(%a+)")
3 print(key,value)  --输出name anna
4 
5 date = "Today is 2012-01-02"
6 y,m,d = string.match(date,"(%d+)\-(%d+)\-(%d+)")
7 print(y,m,d)      --输出2012    01      02

1 print(string.gsub("hello Lua","(.)(.)","%2%1"))  --将相邻的两个字符对调，输出为ehll ouLa
2 print(string.gsub("hello Lua!","%a","%0-%0"))    --输出为h-he-el-ll-lo-o L-Lu-ua-a!

 1 function expand(s)
 2     return (string.gsub(s,"$(%w+)",_G))
 3 end
 4 
 5 name = "Lua"; status = "great"
 6 print(expand("$name is $status, isn't it?"))  --输出 Lua is great, isn't it?
 7 print(expand("$othername is $status, isn't it?"))  --输出 $othername is great, isn't it?
 8 
 9 function expand2(s)
10     return (string.gsub(s,"$(%w+)",function(n) return tostring(_G[n]) end))
11 end
12 
13 print(expand2("print = $print; a = $a")) --输出 print = function: 002B77C0; a = nil

 1 a = {}
 2 key = {}
 3 a[key] = 1
 4 key = {}
 5 a[key] = 2
 6 collectgarbage()
 7 for k,v in pairs(a) do
 8     print(v)
 9 end    
10 --输出1和2

 1 a = {}
 2 b = {__mode = "k"}
 3 setmetatable(a,b)
 4 key = {}
 5 a[key] = 1
 6 key = {}
 7 a[key] = 2
 8 collectgarbage()
 9 for k,v in pairs(a) do
10     print(v)
11 end    
12 --仅仅输出2

 1 local results = {}
 2 setmetatable(results,{__mode = "v"}) --results表中的key是字符串形式的Lua代码
 3 function mem_loadstring(s)
 4     local res = results[s]
 5     if res == nil then
 6         res = assert(loadstring(s))
 7         results[s] = res
 8     end
 9     return res
10 end

1 Account = {balance = 0}
2 function Account.withdraw(v)
3     Account.balance = Account.balance - v
4 end
5 --下面是测试调用函数
6 Account.withdraw(100.00)

1 a = Account; Account = nil
2 a.withdraw(100.00)  --将会导致访问空nil的错误。

1 function Account.withdraw(self,v)
2     self.balance = self.balance - v
3 end
4 --下面是基于修改后代码的调用：
5 a1 = Account; Account = nil
6 a1.withdraw(a1,100.00)  --正常工作。

1 function Account:withdraw(v)
2     self.balance = self.balance - v
3 end
4 --调用代码可改为：
5 a:withdraw(100.00)

 1 --[[
 2 在这段代码中，我们可以将Account视为class的声明，如Java中的：
 3 public class Account 
 4 {
 5     public float balance = 0;
 6     public Account(Account o);
 7     public void deposite(float f);
 8 }
 9 --]]
10 --这里balance是一个公有的成员变量。
11 Account = {balance = 0}
12 
13 --new可以视为构造函数
14 function Account:new(o)
15     o = o or {} --如果参数中没有提供table，则创建一个空的。
16     --将新对象实例的metatable指向Account表(类)，这样就可以将其视为模板了。
17     setmetatable(o,self)
18     --在将Account的__index字段指向自己，以便新对象在访问Account的函数和字段时，可被直接重定向。
19     self.__index = self
20     --最后返回构造后的对象实例
21     return o
22 end
23 
24 --deposite被视为Account类的公有成员函数
25 function Account:deposit(v)
26     --这里的self表示对象实例本身
27     self.balance = self.balance + v
28 end
29 
30 --下面的代码创建两个Account的对象实例
31 
32 --通过Account的new方法构造基于该类的示例对象。
33 a = Account:new()
34 --[[
35 这里需要具体解释一下，此时由于table a中并没有deposite字段，因此需要重定向到Account，
36 同时调用Account的deposite方法。在Account.deposite方法中，由于self(a对象)并没有balance
37 字段，因此在执行self.balance + v时，也需要重定向访问Account中的balance字段，其缺省值为0。
38 在得到计算结果后，再将该结果直接赋值给a.balance。此后a对象就拥有了自己的balance字段和值。
39 下次再调用该方法，balance字段的值将完全来自于a对象，而无需在重定向到Account了。
40 --]]
41 a:deposit(100.00)
42 print(a.balance) --输出100
43 
44 b = Account:new()
45 b:deposit(200.00)
46 print(b.balance) --输出200

 1 --需要说明的是，这段代码仅提供和继承相关的注释，和类相关的注释在上面的代码中已经给出。
 2 Account = {balance = 0}
 3 
 4 function Account:new(o)
 5     o = o or {}
 6     setmetatable(o,self)
 7     self.__index = self
 8     return o
 9 end
10 
11 function Account:deposit(v)
12     self.balance = self.balance + v
13 end
14 
15 function Account:withdraw(v)
16     if v > self.balance then
17         error("Insufficient funds")
18     end
19     self.balance = self.balance - v
20 end
21 
22 --下面将派生出一个Account的子类，以使客户可以实现透支的功能。
23 SpecialAccount = Account:new()  --此时SpecialAccount仍然为Account的一个对象实例
24 
25 --派生类SpecialAccount扩展出的方法。
26 --下面这些SpecialAccount中的方法代码(getLimit/withdraw)，一定要位于SpecialAccount被Account构造之后。
27 function SpecialAccount:getLimit()
28     --此时的self将为对象实例。
29     return self.limit or 0
30 end
31 
32 --SpecialAccount将为Account的子类，下面的方法withdraw可以视为SpecialAccount
33 --重写的Account中的withdraw方法，以实现自定义的功能。
34 function SpecialAccount:withdraw(v)
35     --此时的self将为对象实例。
36     if v - self.balance >= self:getLimit() then
37         error("Insufficient funds")
38     end
39     self.balance = self.balance - v
40 end
41 
42 --在执行下面的new方法时，table s的元表已经是SpecialAccount了，而不再是Account。
43 s = SpecialAccount:new{limit = 1000.00}
44 --在调用下面的deposit方法时，由于table s和SpecialAccount均未提供该方法，因此访问的仍然是
45 --Account的deposit方法。
46 s:deposit(100)
47 
48 
49 --此时的withdraw方法将不再是Account中的withdraw方法，而是SpecialAccount中的该方法。
50 --这是因为Lua先在SpecialAccount(即s的元表)中找到了该方法。
51 s:withdraw(200.00)
52 print(s.balance) --输出-100

 1 --这里我们需要一个闭包函数作为类的创建工厂
 2 function newAccount(initialBalance)
 3     --这里的self仅仅是一个普通的局部变量，其含义完全不同于前面示例中的self。
 4     --这里之所以使用self作为局部变量名，也是为了方便今后的移植。比如，以后
 5     --如果改为上面的实现方式，这里应用了self就可以降低修改的工作量了。
 6     local self = {balance = initialBalance} --这里我们可以将self视为私有成员变量
 7     local withdraw = function(v) self.balance = self.balance - v end
 8     local deposit = function(v) self.balance = self.balance + v end
 9     local getBalance = function() return self.balance end
10     --返回对象中包含的字段仅仅为公有方法。事实上，我们通过该种方式，不仅可以实现
11     --成员变量的私有性，也可以实现方法的私有性，如：
12     --local privateFunction = function() --do something end
13     --只要我们不在输出对象中包含该方法的字段即可。
14     return {withdraw = withdraw, deposit = deposit, getBalance = getBalance}
15 end
16 
17 --和前面两个示例不同的是，在调用对象方法时，不再需要self变量，因此我们可以直接使用点(.)，
18 --而不再需要使用冒号(:)操作符了。
19 accl = newAccount(100.00)
20 --在函数newAccount返回之后，该函数内的“非局部变量”表self就不再能被外部访问了，只能通过
21 --该函数返回的对象的方法来操作它们。
22 accl.withdraw(40.00)
23 print(acc1.getBalance())

1 require "mod"
2 mod.foo()
3 local m2 = require "mod2"
4 local f = mod2.foo
5 f()   

 1 --将模块名设置为require的参数，这样今后重命名模块时，只需重命名文件名即可。
 2 local modname = ...
 3 local M = {}
 4 _G[modname] = M
 5 
 6 M.i = {r = 0, i = 1}  --定义一个模块内的常量。
 7 function M.new(r,i) return {r = r, i = i} end
 8 function M.add(c1,c2) 
 9     return M.new(c1.r + c2.r,c1.i + c2.i)
10 end
11 
12 function M.sub(c1,c2)
13     return M.new(c1.r - c2.r,c1.i - c2.i)
14 end
15 --返回和模块对应的table。
16 return M

 1 --模块设置和初始化。这一点和上例一致。
 2 local modname = ...
 3 local M = {}
 4 _G[modname] = M
 5 
 6 --声明这个模块将会用到的全局函数，因为在setfenv之后将无法再访问他们，
 7 --因此需要在设置之前先用本地变量获取。
 8 local sqrt = mat.sqrt
 9 local io = io
10 
11 --在这句话之后就不再需要外部访问了。
12 setfenv(1,M)
13 
14 --后面的函数和常量定义都无需模块限定符了。
15 i = {r = 0, i = 1}
16 function new(r,i) return {r = r, i = i} end
17 function add(c1,c2) 
18     return new(c1.r + c2.r,c1.i + c2.i)
19 end
20  
21 function sub(c1,c2)
22     return new(c1.r - c2.r,c1.i - c2.i)
23 end
24 --返回和模块对应的table。
25 return M

1 local modname = ...
2 local M = {}
3 _G[modname] = M
4 package.loaded[modname] = M
5     --[[
6     和普通Lua程序块一样声明外部函数。
7     --]]
8 setfenv(1,M)

 1 --该table用于存储所有已经声明过的全局变量名
 2 local declaredNames = {} 
 3 local mt = {
 4     __newindex = function(table,name,value)
 5         --先检查新的名字是否已经声明过，如果存在，这直接通过rawset函数设置即可。
 6         if not declaredNames[name] then
 7             --再检查本次操作是否是在主程序或者C代码中完成的，如果是，就继续设置，否则报错。
 8             local w = debug.getinfo(2,"S").what
 9             if w ~= "main" and w ~= "C" then
10                 error("attempt to write to undeclared variable " .. name)
11             end
12             --在实际设置之前，更新一下declaredNames表，下次再设置时就无需检查了。
13             declaredNames[name] = true
14         end
15         print("Setting " .. name .. " to " .. value)
16         rawset(table,name,value)
17     end,
18     
19     __index = function(_,name)
20         if not declaredNames[name] then
21             error("attempt to read undeclared variable " .. name)
22         else
23             return rawget(_,name)
24         end
25     end
26 }    
27 setmetatable(_G,mt)
28 
29 a = 11
30 local kk = aa
31 
32 --输出结果为：
33 --[[
34 Setting a to 11
35 lua: d:/test.lua:21: attempt to read undeclared variable aa
36 stack traceback:
37         [C]: in function 'error'
38         d:/test.lua:21: in function <d:/test.lua:19>
39         d:/test.lua:30: in main chunk
40         [C]: ?
41 --]]

 1 a = 1
 2 setfenv(1,{})
 3 print(a)
 4 
 5 --输出结果为：
 6 --[[
 7 lua: d:/test.lua:3: attempt to call global 'print' (a nil value)
 8 stack traceback:
 9         d:/test.lua:3: in main chunk
10         [C]: ?
11 --]]

 1 a = 1
 2 local newgt = {}  --新环境表
 3 setmetatable(newgt,{__index = _G})
 4 setfenv(1,newgt)
 5 print(a)  --输出1
 6 
 7 a = 10
 8 print(a)  --输出10
 9 print(_G.a) --输出1
10 _G.a = 20
11 print(a)  --输出10

 1 function factory()
 2     return function() return a end
 3 end
 4 a = 3
 5 f1 = factory()
 6 f2 = factory()
 7 print(f1())  --输出3
 8 print(f2())  --输出3
 9 
10 setfenv(f1,{a = 10})
11 print(f1())  --输出10
12 print(f2())  --输出3

1 local count = 0
2 --这里预先定义了Entry函数，以便在执行dofile中的数据代码时，可以找到匹配的该函数。
3 function Entry() count = count + 1 end
4 dofile("d:/lua_data.conf")
5 print("number of entries: " .. count)
6 
7 --输出结果为：
8 --number of entries: 2

 1 local personInfo = {}
 2 function Entry(b) 
 3     --这里将table对象b的name字段值作为personInfo的key信息。
 4     if b.name then
 5         personInfo[b.name] = true 
 6     end
 7 end
 8 
 9 dofile("d:/lua_data.conf")
10 for name in pairs(personInfo) do
11     print(name)
12 end
13 
14 --输出结果为：
15 --Jerry Tian
16 --Stephen Liu

 1 function serialize(o)
 2     if type(o) == "number" then
 3         io.write(o)
 4     elseif type(o) == "string" then
 5         --string.format函数的"%q"参数可以转义字符串中的元字符。
 6         io.write(string.format("%q",o)) 
 7     elseif type(o) == "table" then
 8         io.write("{\n")
 9         --迭代table中的各个元素，同时递归的写出各个字段的value。
10         --由此可以看出，这个简单例子可以支持嵌套的table。
11         for k,v in pairs(o) do
12             --这样做是为了防止k中包含非法的Lua标识符。
13             io.write(" ["); serialize(k); io.write("] = ")
14             serialize(v)
15             io.write(",\n")
16         end
17         io.write("}\n")
18     else
19         error("cannot serialize a " .. type(o))
20     end
21 end

1 a = {}
2 for i = 1, 1000 do
3     a[i] = 0
4 end
5 print("The length of array 'a' is " .. #a)
6 --The length of array 'a' is 1000

1 mt = {}
2 for i = 1, N do
3     mt[i] = {}
4     for j = 1, M do
5         mt[i][j] = i * j
6     end
7 end

1 mt = {}
2 for i = 1, N do
3     for j = 1, M do
4         mt[(i - 1) * M + j] = i * j
5     end
6 end

 1 list = nil
 2 for i = 1, 10 do
 3     list = { next = list, value = i}
 4 end
 5 
 6 local l = list
 7 while l do
 8     print(l.value)
 9     l = l.next
10 end

 1 List = {}
 2 
 3 function List.new()
 4     return {first = 0, last = -1}
 5 end
 6 
 7 function List.pushFront(list, value)
 8     local first = list.first - 1
 9     list.first = first
10     list[first] = value
11 end
12 
13 function List.pushBack(list, value)
14     local last = list.last + 1
15     list.last = last
16     list[last] = value
17 end
18 
19 function List.popFront(list)
20     local first = list.first
21     if first > list.last then
22         error("List is empty")
23     end
24     local value = list[first]
25     list[first] = nil
26     list.first = first + 1
27     return value
28 end
29 
30 function List.popBack(list)
31     local last = list.last
32     if list.first > last then
33         error("List is empty")
34     end
35     local value = list[last]
36     list[last] = nil
37     list.last = last - 1
38     return value
39 end

1 function insert(bag, element)
2     bag[element] = (bag[element] or 0) + 1
3 end
4 
5 function remove(bag, element)
6     local count = bag[element]
7     bag[element] = (count and count > 1) and count - 1 or nil
8 end

1 local buff = ""
2 for line in io.lines() do
3     buff = buff .. line .. "\n"
4 end

 1 local t = {}
 2 for line in io.lines() do
 3     t[#t + 1] = line .. "\n"
 4 end
 5 local s = table.concat(t)
 6 
 7 --concat方法可以接受两个参数，因此上面的方式还可以改为：
 8 local t = {}
 9 for line in io.lines() do
10     t[#t + 1] = line
11 end
12 local s = table.concat(t,"\n")

1 function dofile(filename)
2     local f = assert(loadfile(filename))
3     return f()
4 end

1 i = 0
2 f()  
3 print(i) --将输出1
4 f()
5 print(i) --将输出2

1 i = 32
2 local i = 0
3 f = loadstring("i = i + 1; print(i)")
4 g = function() i = i + 1; print(i) end
5 f()   --f函数中的i为全局变量i，因此输出33
6 g()   --g函数中的i为局部变量i，因此输出1

1 i = 32
2 f = loadstring("i = i + 1; return i * 2")
3 print(f()) --输出66
4 print(f()) --输出68。由于loadstring返回的就是正规的函数，因此可以被反复调用。

1 local i = 30
2 --下面的...表示变长实参，将值赋给局部变量x。
3 local f = assert(loadstring("local x = ...; return (x + 10)    * 2")) 
4 for i = 1, 20 do
5     print(string.rep("*",f(i)))
6 end

 1 function foo()
 2     local a = 10
 3     print(a[2])
 4 end
 5 
 6 r, msg = pcall(foo)
 7 if r then
 8     print("This is ok.")
 9 else
10     print("This is error.")
11     print(msg)
12 end
13 --输出结果为：
14 --This is error.
15 --d:/test.lua:3: attempt to index local 'a' (a number value)

 1 r, msg = pcall(function() error({code = 121}) end)
 2 if r then
 3     print("This is ok.")
 4 else
 5     print("This is error.")
 6     print(msg.code)
 7 end
 8 --输出结果为：
 9 --This is error.
10 --121

 1 function errorFunc()
 2     local a = 20
 3     print(a[10])
 4 end
 5 
 6 function errorHandle()
 7     print(debug.traceback())
 8 end
 9 
10 if xpcall(errorFunc,errorHandle) then
11     print("This is OK.")
12 else
13     print("This is error.")
14 end
15 
16 --输出结果为：
17 --[[stack traceback:
18         d:/test.lua:7: in function <d:/test.lua:6>
19         d:/test.lua:3: in function <d:/test.lua:1>
20         [C]: in function 'xpcall'
21         d:/test.lua:10: in main chunk
22         [C]: ?
23 This is error.
24 --]]

 1 function values(t)
 2     local i = 0
 3     return function()
 4         i = i + 1
 5         return t[i]
 6     end
 7 end
 8 t = {10, 20, 30}
 9 it = values(t)
10 while true do
11     local element = it()
12     if element == nil then
13         break
14     end
15     print(element)
16 end
17 --另外一种基于foreach的调用方式(泛型for)
18 t2 = {15, 25, 35}
19 for element in values(t2) do
20     print(element)
21 end
22 --输出结果为：
23 --10
24 --20
25 --30
26 --15
27 --25
28 --35

1 function ipairs2(a)
2     return iter,a,0
3 end

1 local function iter(a, i)
2     i = i + 1
3     local v = a[i]
4     if v then
5         return i, v
6     else
7         return nil, nil
8     end
9 end

 1 function ipairs2(a)
 2     return iter,a,0
 3 end
 4 
 5 
 6 local function iter(a, i)
 7     i = i + 1
 8     local v = a[i]
 9     if v then
10         return i, v
11     else
12         return nil, nil
13     end
14 end
15 
16 a = {"one","two","three"}
17 for k,v in ipairs2(a) do
18     print(k, v)
19 end
20 --输出结果为：
21 --1       one
22 --2       two
23 --3       three    

 1 local function iter(a, i)
 2     i = i + 1
 3     local v = a[i]
 4     if v then
 5         return i, v
 6     else
 7         return nil, nil
 8     end
 9 end
10 
11 function ipairs2(a)
12     return iter,a,0
13 end
14 
15 a = {"one","two","three"}
16 do
17     local _it,_s,_var = ipairs2(a)
18     while true do
19         local var_1,var_2 = _it(_s,_var)
20         _var = var_1
21         if _var == nil then  --注意，这里只判断迭代器函数返回的第一个是否为nil。
22             break
23         end
24         print(var_1,var_2)
25     end
26 end
27 --输出结果同上。

 1 local function getnext(list, node)  --迭代器函数。
 2     if not node then
 3         return list
 4     else
 5         return node.next
 6     end
 7 end
 8 
 9 function traverse(list)  --泛型(for)的expression
10     return getnext,list,nil
11 end
12 
13 --初始化链表中的数据。
14 list = nil
15 for line in io.lines() do
16     line = { val = line, next = list}
17 end
18 
19 --以泛型(for)的形式遍历链表。
20 for node in traverse(list) do
21     print(node.val)
22 end

 1 local iterator
 2 function allwords()
 3     local state { line = io.read(), pos = 1 }
 4     return iterator, state
 5 end
 6 --iterator函数将是真正的迭代器
 7 function iterator(state)
 8     while state.line do
 9         local s,e = string.find(state.line,"%w+",state.pos)
10         if s then
11             state.pos = e + 1
12             return string.sub(state.line,s,e)
13         else
14             state.line = io.read()
15             state.pos = 1
16         end
17     end
18     return nil
19 end

1 s,e = string.find("Hello Lua users","Lua")
2 print("The begin index is " .. s .. ", the end index is " .. e .. ".");
3 -- The begin index is 7, the end index is 9.

 1 function maximum(a)
 2     local mi = 1
 3     local m = a[mi]
 4     for i, val in ipairs(a) do
 5         if val > m then
 6             mi,m = i,val
 7         end
 8     end
 9     return m,mi
10 end
11 print(maximum{8,10,23,12,5})
12 --23   3

1 function unpack(t,i)
2     i = i or 1
3     if t[i] then
4         return t[i], unpack(t,i + 1)
5     end
6 end

1 function add(...)
2     local s = 0
3     for i, v in ipairs{...} do
4         s = s + v
5     end
6     return s
7 end
8 print(add(3,4,5,6,7))
9 --输出结果为：25

1 for i = 1, select('#',...) do  --这里'#'值表示让select返回变参的数量(其中包括nil)。
2     local arg = select(i, ...) --这里的i表示获取第i个变参，1为第一个。
3     --do something
4 end

 1 function newCounter() 
 2     local i = 0
 3     return function() --匿名函数
 4         i = i + 1
 5         return i
 6     end
 7 end
 8 c1 = newCounter()
 9 print("The return value of first call is " .. c1())
10 print("The return value of second call is " .. c1())
11 --输出结果为：
12 --The return value of first call is 1
13 --The return value of second call is 2

 1 function newCounter() 
 2     local i = 0
 3     return function() --匿名函数
 4         i = i + 1
 5         return i
 6     end
 7 end
 8 c1 = newCounter()
 9 c2 = newCounter()
10 print("The return value of first call with c1 is " .. c1())
11 print("The return value of first call with c2 is " .. c2())
12 print("The return value of second call with c1 is " .. c1())
13 --输出结果为：
14 --The return value of first call with c1 is 1
15 --The return value of first call with c2 is 1
16 --The return value of second call with c1 is 2

 1 do
 2     --这里将原有的文件打开函数赋值给"私有变量"oldOpen，该变量在块外无法访问。
 3     local oldOpen = io.open
 4     --新增一个匿名函数，用于判断本次文件打开操作的合法性。
 5     local access_OK = function(filename,mode) <检查访问权限> end
 6     --将原有的io.open函数变量指向新的函数，同时在新函数中调用老函数以完成真正的打开操作。
 7     io.open = function(filename,mode)
 8         if access_OK(filename,mode) then
 9             return oldOpen(filename,mode)
10         else
11             return nil,"Access denied"
12         end
13     end
14 end

1 do
2     local f = function(x,y) return x + y end
3     --do something with f.
4     f(4,5)
5 end  

1 a = {}
2 a.x = 1
3 a.y = 0
4 b = {}
5 b.x = 1
6 b.y = 1
7 c = a

 1 days = {"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}
 2 for i = 1,#days do
 3     print(days[i])
 4 end
 5 --输出结果为
 6 --Sunday
 7 --Monday
 8 --Tuesday
 9 --Wednesday
10 --Thursday
11 --Friday
12 --Saturday

polyline = {color = "blue", thickness = 2, npoints = 4, 
    {x = 0, y = 0},
    {x = 10, y = 0},
    {x = -10, y = 1},
    {x = 0, y = 1} }
print(polyline["color"]);
print(polyline[2].x)
print(polyline[4].y)
--输出结果如下：
--blue
--10
--1

1 opnames = { ["+"] = "add", ["-"] = "sub", ["*"] = "mul", ["/"] = "div"}
2 print(opnames["+"])
3 i = 20; s = "-"
4 a = { [i + 0] = s, [i + 1] = s .. s, [i + 2] = s..s..s }
5 print(a[22])

1 while i <= x do
2     local x = i * 2
3     print(x)
4     i = i + 1
5 end

1 do
2     local a2 = 2 * a
3     local d = (b ^ 2 - 4 * a) ^ (1 / 2)
4     x1 = (-b + d) / a2
5     x2 = (-b - d) / a2
6 end  --a2和d的作用域至此结束。

 1 days = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }
 2 revDays = {}
 3 for k, v in ipairs(days) do
 4     revDays[v] = k
 5 end
 6 
 7 for k in pairs(revDays) do
 8     print(k .. " = " .. revDays[k])
 9 end
10 
11 --输出结果为：
12 --Saturday = 7
13 --Tuesday = 3
14 --Wednesday = 4
15 --Friday = 6
16 --Sunday = 1
17 --Thursday = 5
18 --Monday = 2

 1 function fact(n)
 2     if n == 0 then
 3         return 1
 4     else
 5         return n * fact(n - 1)
 6     end
 7 end
 8 print("Enter a number:")
 9 a = io.read("*number")
10 print(fact(a))

1 a = 1
2 b = a * 2
3     
4 a = 1;
5 b = a * 2;
6     
7 a = 1; b = a * 2;
8 a = 1  b = a * 2

1 function fact(n)
2     if n == 0 then
3         return 1
4     else
5         return n * fact(n - 1)
6     end
7 end

1 a = "one string"
2 b = string.gsub(a,"one","another")
3 print(a)
4 print(b)

1 line = io.read()
2 n = tonumber(line)
3 if n == nil then
4     error(line .. " is not a valid number")
5 else
6     print(n * 2)
7 end

1 a = "hello"
2 print(#a)

1 a = {}              -- 创建一个table对象，并将它的引用存储到a
2 k = "x"
3 a[k] = 10           -- 创建了新条目，key = "x", value = 10
4 a[20] = "great"     -- 新条目，key = 20， value = "great"
5 print(a["x"])
6 k = 20
7 print(a[k])         -- 打印great
8 a["x"] = a["x"] + 1
9 print(a["x"])       -- 打印11

 1 a = {}
 2 for i = 1, 100 do
 3     a[i] = i * 2
 4 end
 5 print(a[9])
 6 a["x"] = 10
 7 print(a["x"])
 8 print(a["y"])      --table中的变量和全局变量一样，没有赋值之前均为nil。
 9 
10 --输出结果为
11 --18
12 --10
13 --nil

1 a.x = 10      --等同于a["x"] = 10
2 print(a.x)    --等同于print(a["x"])
3 print(a.y)    --等同于print(a["y"])

1 a = {}
2 for i = 1,10 do
3     a[i] = i * 2
4 end
5 
6 for i = 1,10 do
7     print(a[i])
8 end

1 a = {}
2 for i = 1,10 do
3     a[i] = i * 2
4 end
5 
6 for i = 1,#a do
7     print(a[i])
8 end

1 a = {}
2 a[1000] = 1
3 print(table.maxn(a))    
4 
5 -- 输出1000