每天早晨叫醒你的不是闹钟,而是梦想

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

Lua中的table就是一种对象，但是如果直接使用仍然会存在大量的问题，见如下代码：

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

    在上面的withdraw函数内部依赖了全局变量Account，一旦该变量发生改变，将会导致withdraw不再能正常的工作，如：

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

    这种行为明显的违反了面向对象封装性和实例独立性。要解决这一问题，我们需要给withdraw函数在添加一个参数self，他等价于Java/C++中的this，见如下修改：

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)  --正常工作。

    针对上述问题，Lua提供了一种更为便利的语法，即将点(.)替换为冒号(:)，这样可以在定义和调用时均隐藏self参数，如:

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

    1. 类：
    Lua在语言上并没有提供面向对象的支持，因此想实现该功能，我们只能通过table来模拟，见如下代码及关键性注释：

 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

    2. 继承：
    继承也是面向对象中一个非常重要的概念，在Lua中我们仍然可以像模拟类那样来进一步实现面向对象中的继承机制，见如下代码及关键性注释：

 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

    3. 私密性：
    私密性对于面向对象语言来说是不可或缺的，否则将直接破坏对象的封装性。Lua作为一种面向过程的脚本语言，更是没有提供这样的功能，然而和模拟支持类与继承一样，我们仍然可以在Lua中通过特殊的编程技巧来实现它，这里我们应用的是Lua中的闭包函数。该实现方式和前面两个示例中基于元表的方式有着很大的区别，见如下代码示例和关键性注释：

 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())

    事实上，上面的代码只是给出一个简单的示例，在实际应用中，我们可以将更多的私有变量存放于上例的局部self表中。

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