Lua（下）

Lua 协同程序(coroutine)

---

什么是协同(coroutine)？

Lua 协同程序(coroutine)与线程比较类似：拥有独立的堆栈，独立的局部变量，独立的指令指针，同时又与其它协同程序共享全局变量和其它大部分东西。

协同是非常强大的功能，但是用起来也很复杂。

线程和协同程序区别

线程与协同程序的主要区别在于，一个具有多个线程的程序可以同时运行几个线程，而协同程序却需要彼此协作的运行。

在任一指定时刻只有一个协同程序在运行，并且这个正在运行的协同程序只有在明确的被要求挂起的时候才会被挂起。

协同程序有点类似同步的多线程，在等待同一个线程锁的几个线程有点类似协同。

基本语法

方法描述coroutine.create()创建coroutine，返回coroutine， 参数是一个函数，当和resume配合使用的时候就唤醒函数调用coroutine.resume()重启coroutine，和create配合使用coroutine.yield()挂起coroutine，将coroutine设置为挂起状态，这个和resume配合使用能有很多有用的效果coroutine.status()查看coroutine的状态
注：coroutine的状态有三种：dead，suspend，running，具体什么时候有这样的状态请参考下面的程序coroutine.wrap（）创建coroutine，返回一个函数，一旦你调用这个函数，就进入coroutine，和create功能重复coroutine.running()返回正在跑的coroutine，一个coroutine就是一个线程，当使用running的时候，就是返回一个corouting的线程号

以下实例演示了以上各个方法的用法：

-- coroutine_test.lua 文件co = coroutine.create(    function(i)        print(i);    end) coroutine.resume(co, 1)   -- 1print(coroutine.status(co))  -- dead print("----------") co = coroutine.wrap(    function(i)        print(i);    end) co(1) print("----------") co2 = coroutine.create(    function()        for i=1,10 do            print(i)            if i == 3 then                print(coroutine.status(co2))  --running                print(coroutine.running()) --thread:XXXXXX            end            coroutine.yield()        end    end) coroutine.resume(co2) --1coroutine.resume(co2) --2coroutine.resume(co2) --3 print(coroutine.status(co2))   -- suspendedprint(coroutine.running()) print("----------")

以上实例执行输出结果为：

1dead----------1----------123runningthread: 0x7fb801c05868falsesuspendedthread: 0x7fb801c04c88true----------

coroutine.running就可以看出来,coroutine在底层实现就是一个线程。

当create一个coroutine的时候就是在新线程中注册了一个事件。

当使用resume触发事件的时候，create的coroutine函数就被执行了，当遇到yield的时候就代表挂起当前线程，等候再次resume触发事件。

接下来我们分析一个更详细的实例：

function foo (a)    print("foo 函数输出", a)    return coroutine.yield(2 * a) -- 返回  2*a 的值end co = coroutine.create(function (a , b)    print("第一次协同程序执行输出", a, b) -- co-body 1 10    local r = foo(a + 1)         print("第二次协同程序执行输出", r)    local r, s = coroutine.yield(a + b, a - b)  -- a，b的值为第一次调用协同程序时传入         print("第三次协同程序执行输出", r, s)    return b, "结束协同程序"                   -- b的值为第二次调用协同程序时传入end)        print("main", coroutine.resume(co, 1, 10)) -- true, 4print("--分割线----")print("main", coroutine.resume(co, "r")) -- true 11 -9print("---分割线---")print("main", coroutine.resume(co, "x", "y")) -- true 10 endprint("---分割线---")print("main", coroutine.resume(co, "x", "y")) -- cannot resume dead coroutineprint("---分割线---")

以上实例执行输出结果为：

第一次协同程序执行输出110foo 函数输出2maintrue4--分割线----第二次协同程序执行输出rmaintrue11-9---分割线---第三次协同程序执行输出xymaintrue10结束协同程序---分割线---mainfalsecannot resume dead coroutine---分割线---

以上实例接下如下：

• 调用resume，将协同程序唤醒,resume操作成功返回true，否则返回false；
• 协同程序运行；
• 运行到yield语句；
• yield挂起协同程序，第一次resume返回；（注意：此处yield返回，参数是resume的参数）
• 第二次resume，再次唤醒协同程序；（注意：此处resume的参数中，除了第一个参数，剩下的参数将作为yield的参数）
• yield返回；
• 协同程序继续运行；
• 如果使用的协同程序继续运行完成后继续调用 resume方法则输出：cannot resume dead coroutine

resume和yield的配合强大之处在于，resume处于主程中，它将外部状态（数据）传入到协同程序内部；而yield则将内部的状态（数据）返回到主程中。

---

生产者-消费者问题

现在我就使用Lua的协同程序来完成生产者-消费者这一经典问题。

local newProductorfunction productor()     local i = 0     while true do          i = i + 1          send(i)     -- 将生产的物品发送给消费者     endendfunction consumer()     while true do          local i = receive()     -- 从生产者那里得到物品          print(i)     endendfunction receive()     local status, value = coroutine.resume(newProductor)     return valueendfunction send(x)     coroutine.yield(x)     -- x表示需要发送的值，值返回以后，就挂起该协同程序end-- 启动程序newProductor = coroutine.create(productor)consumer()

以上实例执行输出结果为：

12345678910111213

Lua 文件 I/O

Lua I/O 库用于读取和处理文件。分为简单模式（和C一样）、完全模式。

• 简单模式（simple model）拥有一个当前输入文件和一个当前输出文件，并且提供针对这些文件相关的操作。
• 完全模式（complete model） 使用外部的文件句柄来实现。它以一种面对对象的形式，将所有的文件操作定义为文件句柄的方法

简单模式在做一些简单的文件操作时较为合适。但是在进行一些高级的文件操作的时候，简单模式就显得力不从心。例如同时读取多个文件这样的操作，使用完全模式则较为合适。

打开文件操作语句如下：

file = io.open (filename [, mode])

mode 的值有：

模式描述r以只读方式打开文件，该文件必须存在。w打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。a以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）r+以可读写方式打开文件，该文件必须存在。w+打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。a+与a类似，但此文件可读可写b二进制模式，如果文件是二进制文件，可以加上b+号表示对文件既可以读也可以写

---

简单模式

简单模式使用标准的 I/O 或使用一个当前输入文件和一个当前输出文件。

以下为 file.lua 文件代码，操作的文件为test.lua(如果没有你需要创建该文件)，代码如下：

-- 以只读方式打开文件file = io.open("test.lua", "r")-- 设置默认输入文件为 test.luaio.input(file)-- 输出文件第一行print(io.read())-- 关闭打开的文件io.close(file)-- 以附加的方式打开只写文件file = io.open("test.lua", "a")-- 设置默认输出文件为 test.luaio.output(file)-- 在文件最后一行添加 Lua 注释io.write("--  test.lua 文件末尾注释")-- 关闭打开的文件io.close(file)

执行以上代码，你会发现，输出了 test.ua 文件的第一行信息，并在该文件最后一行添加了 lua 的注释。如我这边输出的是：

-- test.lua 文件

在以上实例中我们使用了 io."x" 方法，其中 io.read() 中我们没有带参数，参数可以是下表中的一个：

模式描述"*n"读取一个数字并返回它。例：file.read("*n")"*a"从当前位置读取整个文件。例：file.read("*a")"*l"（默认）读取下一行，在文件尾 (EOF) 处返回 nil。例：file.read("*l")number返回一个指定字符个数的字符串，或在 EOF 时返回 nil。例：file.read(5)

其他的 io 方法有：

• io.tmpfile():返回一个临时文件句柄，该文件以更新模式打开，程序结束时自动删除

• io.type(file): 检测obj是否一个可用的文件句柄

• io.flush(): 向文件写入缓冲中的所有数据

• io.lines(optional file name): 返回一个迭代函数,每次调用将获得文件中的一行内容,当到文件尾时，将返回nil,但不关闭文件

---

完全模式

通常我们需要在同一时间处理多个文件。我们需要使用 file:function_name 来代替 io.function_name 方法。以下实例演示了如同同时处理同一个文件:

-- 以只读方式打开文件file = io.open("test.lua", "r")-- 输出文件第一行print(file:read())-- 关闭打开的文件file:close()-- 以附加的方式打开只写文件file = io.open("test.lua", "a")-- 在文件最后一行添加 Lua 注释file:write("--test")-- 关闭打开的文件file:close()

执行以上代码，你会发现，输出了 test.ua 文件的第一行信息，并在该文件最后一行添加了 lua 的注释。如我这边输出的是：

-- test.lua 文件

read 的参数与简单模式一致。

其他方法:

• file:seek(optional whence, optional offset): 设置和获取当前文件位置,成功则返回最终的文件位置(按字节),失败则返回nil加错误信息。参数 whence 值可以是:

  • "set": 从文件头开始
  • "cur": 从当前位置开始[默认]
  • "end": 从文件尾开始
  • offset:默认为0
  不带参数file:seek()则返回当前位置,file:seek("set")则定位到文件头,file:seek("end")则定位到文件尾并返回文件大小

• file:flush(): 向文件写入缓冲中的所有数据

• io.lines(optional file name): 打开指定的文件filename为读模式并返回一个迭代函数,每次调用将获得文件中的一行内容,当到文件尾时，将返回nil,并自动关闭文件。
  若不带参数时io.lines() <=> io.input():lines(); 读取默认输入设备的内容，但结束时不关闭文件,如

  for line in io.lines("main.lua") do　　print(line)　　end

以下实例使用了 seek 方法，定位到文件倒数第 25 个位置并使用 read 方法的 *a 参数，即从当期位置(倒数第 25 个位置)读取整个文件。

-- 以只读方式打开文件file = io.open("test.lua", "r")file:seek("end",-25)print(file:read("*a"))-- 关闭打开的文件file:close()

我这边输出的结果是：

st.lua 文件末尾--test

Lua 错误处理

程序运行中错误处理是必要的，在我们进行文件操作，数据转移及web service 调用过程中都会出现不可预期的错误。如果不注重错误信息的处理，就会照成信息泄露，程序无法运行等情况。

任何程序语言中，都需要错误处理。错误类型有：

• 语法错误
• 运行错误

---

语法错误

语法错误通常是由于对程序的组件（如运算符、表达式）使用不当引起的。一个简单的实例如下：

-- test.lua 文件a == 2

以上代码执行结果为：

lua: test.lua:2: syntax error near '=='

正如你所看到的，以上出现了语法错误，一个 "=" 号跟两个 "=" 号是有区别的。一个 "=" 是赋值表达式两个 "=" 是比较运算。

另外一个实例:

for a= 1,10   print(a)end

执行以上程序会出现如下错误：

lua: test2.lua:2: 'do' expected near 'print'

语法错误比程序运行错误更简单，运行错误无法定位具体错误，而语法错误我们可以很快的解决，如以上实例我们只要在for语句下添加 do 即可：

for a= 1,10do   print(a)end

---

运行错误

运行错误是程序可以正常执行，但是会输出报错信息。如下实例由于参数输入错误，程序执行时报错：

function add(a,b)   return a+bendadd(10)

当我们编译运行以下代码时，编译是可以成功的，但在运行的时候会产生如下错误：

lua: test2.lua:2: attempt to perform arithmetic on local 'b' (a nil value)stack traceback:test2.lua:2: in function 'add'test2.lua:5: in main chunk[C]: ?

以下报错信息是由于程序缺少 b 参数引起的。

---

错误处理

我们可以使用两个函数：assert 和 error 来处理错误。实例如下：

local function add(a,b)   assert(type(a) == "number", "a 不是一个数字")   assert(type(b) == "number", "b 不是一个数字")   return a+bendadd(10)

执行以上程序会出现如下错误：

lua: test.lua:3: b 不是一个数字stack traceback:[C]: in function 'assert'test.lua:3: in local 'add'test.lua:6: in main chunk[C]: in ?

实例中assert首先检查第一个参数，若没问题，assert不做任何事情；否则，assert以第二个参数作为错误信息抛出。

error函数

语法格式：

error (message [, level])

功能：终止正在执行的函数，并返回message的内容作为错误信息(error函数永远都不会返回)

通常情况下，error会附加一些错误位置的信息到message头部。

Level参数指示获得错误的位置:

• Level=1[默认]：为调用error位置(文件+行号)
• Level=2：指出哪个调用error的函数的函数
• Level=0:不添加错误位置信息

---

pcall 和 xpcall、debug

Lua中处理错误，可以使用函数pcall（protected call）来包装需要执行的代码。

pcall接收一个函数和要传递个后者的参数，并执行，执行结果：有错误、无错误；返回值true或者或false, errorinfo。

语法格式如下

if pcall(function_name, ….) then-- 没有错误else-- 一些错误end

简单实例：

> =pcall(function(i) print(i) end, 33)33true   > =pcall(function(i) print(i) error('error..') end, 33)33false        stdin:1: error..

<p这里注意对返回值的逻辑判断：< p="" style="color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, STHeiti, 'Microsoft Yahei', sans-serif;">

> function f() return false,2 end> if f() then print '1' else print '0' end0

pcall以一种"保护模式"来调用第一个参数，因此pcall可以捕获函数执行中的任何错误。

通常在错误发生时，希望落得更多的调试信息，而不只是发生错误的位置。但pcall返回时，它已经销毁了调用桟的部分内容。

Lua提供了xpcall函数，xpcall接收第二个参数——一个错误处理函数，当错误发生时，Lua会在调用桟展看（unwind）前调用错误处理函数，于是就可以在这个函数中使用debug库来获取关于错误的额外信息了。

debug库提供了两个通用的错误处理函数:

• debug.debug：提供一个Lua提示符，让用户来价差错误的原因
• debug.traceback：根据调用桟来构建一个扩展的错误消息

>=xpcall(function(i) print(i) error('error..') end, function() print(debug.traceback()) end, 33) 33 stack traceback: stdin:1: in function [C]: in function 'error' stdin:1: in function [C]: in function 'xpcall' stdin:1: in main chunk [C]: in ? false nil

xpcall 使用实例 2:

function myfunction ()   n = n/nilendfunction myerrorhandler( err )   print( "ERROR:", err )endstatus = xpcall( myfunction, myerrorhandler )print( status)

执行以上程序会出现如下错误：

ERROR:test2.lua:2: attempt to perform arithmetic on global 'n' (a nil value)false

Lua 调试(Debug)

Lua 提供了 debug 库用于提供创建我们自定义调速器的功能。Lua 本身并未有内置的调速器，但很多开发者共享了他们的 Lua 调速器代码。

Lua 中 debug 库包含以下函数：

sethook ([thread,] hook, mask [, count]):序号方法 & 用途1.debug():

进入一个用户交互模式，运行用户输入的每个字符串。 使用简单的命令以及其它调试设置，用户可以检阅全局变量和局部变量， 改变变量的值，计算一些表达式，等等。 
输入一行仅包含 cont 的字符串将结束这个函数， 这样调用者就可以继续向下运行。

2.getfenv(object):

返回对象的环境变量。

3.gethook(optional thread):

返回三个表示线程钩子设置的值： 当前钩子函数，当前钩子掩码，当前钩子计数

4.getinfo ([thread,] f [, what]):

返回关于一个函数信息的表。 你可以直接提供该函数， 也可以用一个数字 f 表示该函数。 数字 f 表示运行在指定线程的调用栈对应层次上的函数： 0 层表示当前函数（getinfo 自身）； 1 层表示调用 getinfo 的函数 （除非是尾调用，这种情况不计入栈）；等等。 如果 f 是一个比活动函数数量还大的数字， getinfo 返回 nil。

5.debug.getlocal ([thread,] f, local):

此函数返回在栈的 f 层处函数的索引为 local 的局部变量 的名字和值。 这个函数不仅用于访问显式定义的局部变量，也包括形参、临时变量等。

6.getmetatable(value):

把给定索引指向的值的元表压入堆栈。如果索引无效，或是这个值没有元表，函数将返回 0 并且不会向栈上压任何东西。

7.getregistry():

返回注册表表，这是一个预定义出来的表， 可以用来保存任何 C 代码想保存的 Lua 值。

8.getupvalue (f, up)

此函数返回函数 f 的第 up 个上值的名字和值。 如果该函数没有那个上值，返回 nil 。 
以 '(' （开括号）打头的变量名表示没有名字的变量 （去除了调试信息的代码块）。

10.将一个函数作为钩子函数设入。 字符串 mask 以及数字 count 决定了钩子将在何时调用。 掩码是由下列字符组合成的字符串，每个字符有其含义：

• 'c': 每当 Lua 调用一个函数时，调用钩子；
• 'r': 每当 Lua 从一个函数内返回时，调用钩子；
• 'l': 每当 Lua 进入新的一行时，调用钩子。

11.setlocal ([thread,] level, local, value):

这个函数将 value 赋给 栈上第 level 层函数的第 local 个局部变量。 如果没有那个变量，函数返回 nil 。 如果 level 越界，抛出一个错误。

12.setmetatable (value, table):

将 value 的元表设为 table （可以是 nil）。 返回 value。

13.setupvalue (f, up, value):

这个函数将 value 设为函数 f 的第 up 个上值。 如果函数没有那个上值，返回 nil 否则，返回该上值的名字。

14.traceback ([thread,] [message [, level]]):

如果 message 有，且不是字符串或 nil， 函数不做任何处理直接返回 message。 否则，它返回调用栈的栈回溯信息。 字符串可选项 message 被添加在栈回溯信息的开头。 数字可选项 level 指明从栈的哪一层开始回溯 （默认为 1 ，即调用 traceback 的那里）。

上表列出了我们常用的调试函数，接下来我们可以看些简单的例子：

function myfunction ()print(debug.traceback("Stack trace"))print(debug.getinfo(1))print("Stack trace end")return 10endmyfunction ()print(debug.getinfo(1))

执行以上代码输出结果为：

Stack tracestack traceback:test2.lua:2: in function 'myfunction'test2.lua:8: in main chunk[C]: ?table: 0054C6C8Stack trace end

在以实例中，我们使用到了 debug 库的 traceback 和 getinfo 函数， getinfo 函数用于返回函数信息的表。

另一个实例

我们经常需要调试函数的内的局部变量。我们可以使用 getupvalue 函数来设置这些局部变量。实例如下：

function newCounter ()  local n = 0  local k = 0  return function ()    k = n    n = n + 1    return n    endendcounter = newCounter ()print(counter())print(counter())local i = 1repeat  name, val = debug.getupvalue(counter, i)  if name then    print ("index", i, name, "=", val)if(name == "n") thendebug.setupvalue (counter,2,10)end    i = i + 1  end -- ifuntil not nameprint(counter())

执行以上代码输出结果为：

12index1k=1index2n=211

在以上实例中，计数器在每次调用时都会自增1。实例中我们使用了 getupvalue 函数查看局部变量的当前状态。我们可以设置局部变量为新值。实例中，在设置前 n 的值为 2,使用 setupvalue 函数将其设置为 10。现在我们调用函数，执行后输出为 11 而不是 3。

---

调试类型

• 命令行调试
• 图形界面调试

命令行调试器有：RemDebug、clidebugger、ctrace、xdbLua、LuaInterface - Debugger、Rldb、ModDebug。

图形界调试器有：SciTE、Decoda、ZeroBrane Studio、akdebugger、luaedit。

Lua 垃圾回收

Lua 采用了自动内存管理。 这意味着你不用操心新创建的对象需要的内存如何分配出来， 也不用考虑在对象不再被使用后怎样释放它们所占用的内存。

Lua 运行了一个垃圾收集器来收集所有死对象 （即在 Lua 中不可能再访问到的对象）来完成自动内存管理的工作。 Lua 中所有用到的内存，如：字符串、表、用户数据、函数、线程、 内部结构等，都服从自动管理。

Lua 实现了一个增量标记-扫描收集器。 它使用这两个数字来控制垃圾收集循环： 垃圾收集器间歇率和垃圾收集器步进倍率。 这两个数字都使用百分数为单位 （例如：值 100 在内部表示 1 ）。

垃圾收集器间歇率控制着收集器需要在开启新的循环前要等待多久。 增大这个值会减少收集器的积极性。 当这个值比 100 小的时候，收集器在开启新的循环前不会有等待。 设置这个值为 200 就会让收集器等到总内存使用量达到 之前的两倍时才开始新的循环。

垃圾收集器步进倍率控制着收集器运作速度相对于内存分配速度的倍率。 增大这个值不仅会让收集器更加积极，还会增加每个增量步骤的长度。 不要把这个值设得小于 100 ， 那样的话收集器就工作的太慢了以至于永远都干不完一个循环。 默认值是 200 ，这表示收集器以内存分配的"两倍"速工作。

如果你把步进倍率设为一个非常大的数字 （比你的程序可能用到的字节数还大 10% ）， 收集器的行为就像一个 stop-the-world 收集器。 接着你若把间歇率设为 200 ， 收集器的行为就和过去的 Lua 版本一样了： 每次 Lua 使用的内存翻倍时，就做一次完整的收集。

---

垃圾回收器函数

Lua 提供了以下函数collectgarbage ([opt [, arg]])用来控制自动内存管理:

• collectgarbage("collect"): 做一次完整的垃圾收集循环。通过参数 opt 它提供了一组不同的功能：

• collectgarbage("count"): 以 K 字节数为单位返回 Lua 使用的总内存数。 这个值有小数部分，所以只需要乘上 1024 就能得到 Lua 使用的准确字节数（除非溢出）。

• collectgarbage("restart"): 重启垃圾收集器的自动运行。

• collectgarbage("setpause"): 将 arg 设为收集器的 间歇率 （参见 §2.5）。 返回 间歇率 的前一个值。

• collectgarbage("setstepmul"): 返回 步进倍率 的前一个值。

• collectgarbage("step"): 单步运行垃圾收集器。 步长"大小"由 arg 控制。 传入 0 时，收集器步进（不可分割的）一步。 传入非 0 值， 收集器收集相当于 Lua 分配这些多（K 字节）内存的工作。 如果收集器结束一个循环将返回 true 。

• collectgarbage("stop"): 停止垃圾收集器的运行。 在调用重启前，收集器只会因显式的调用运行。

以下演示了一个简单的垃圾回收实例:

mytable = {"apple", "orange", "banana"}print(collectgarbage("count"))mytable = nilprint(collectgarbage("count"))print(collectgarbage("collect"))print(collectgarbage("count"))

执行以上程序，输出结果如下(注意内存使用的变化)：

20.956054687520.9853515625019.4111328125

Lua 面向对象

面向对象编程（Object Oriented Programming，OOP）是一种非常流行的计算机编程架构。

以下几种编程语言都支持面向对象编程：

• C++
• Java
• Objective-C
• Smalltalk
• C#
• Ruby

---

面向对象特征

• 1） 封装：指能够把一个实体的信息、功能、响应都装入一个单独的对象中的特性。
• 2） 继承：继承的方法允许在不改动原程序的基础上对其进行扩充，这样使得原功能得以保存，而新功能也得以扩展。这有利于减少重复编码，提高软件的开发效率。
• 3） 多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。
• 4）抽象：抽象(Abstraction)是简化复杂的现实问题的途径，它可以为具体问题找到最恰当的类定义，并且可以在最恰当的继承级别解释问题。

---

Lua 中面向对象

我们知道，对象由属性和方法组成。LUA中最基本的结构是table，所以需要用table来描述对象的属性。

lua中的function可以用来表示方法。那么LUA中的类可以通过table + function模拟出来。

至于继承，可以通过metetable模拟出来（不推荐用，只模拟最基本的对象大部分时间够用了）。

Lua中的表不仅在某种意义上是一种对象。像对象一样，表也有状态（成员变量）；也有与对象的值独立的本性，特别是拥有两个不同值的对象（table）代表两个不同的对象；一个对象在不同的时候也可以有不同的值，但他始终是一个对象；与对象类似，表的生命周期与其由什么创建、在哪创建没有关系。对象有他们的成员函数，表也有：

Account = {balance = 0}function Account.withdraw (v)    Account.balance = Account.balance - vend

这个定义创建了一个新的函数，并且保存在Account对象的withdraw域内，下面我们可以这样调用：

Account.withdraw(100.00)

一个简单实例

以下简单的类包含了三个属性： area, length 和 breadth，printArea方法用于打印计算结果：

-- Meta classRectangle = {area = 0, length = 0, breadth = 0}-- 派生类的方法 newfunction Rectangle:new (o,length,breadth)  o = o or {}  setmetatable(o, self)  self.__index = self  self.length = length or 0  self.breadth = breadth or 0  self.area = length*breadth;  return oend-- 派生类的方法 printAreafunction Rectangle:printArea ()  print("矩形面积为 ",self.area)end

创建对象

创建对象是位类的实例分配内存的过程。每个类都有属于自己的内存并共享公共数据。

r = Rectangle:new(nil,10,20)

访问属性

我们可以使用点号(.)来访问类的属性：

print(r.length)

访问成员函数

我们可以使用冒号(:)来访问类的属性：

r:printArea()

内存在对象初始化时分配。

完整实例

以下我们演示了 Lua 面向对象的完整实例：

-- Meta classShape = {area = 0}-- 基础类方法 newfunction Shape:new (o,side)  o = o or {}  setmetatable(o, self)  self.__index = self  side = side or 0  self.area = side*side;  return oend-- 基础类方法 printAreafunction Shape:printArea ()  print("面积为 ",self.area)end-- 创建对象myshape = Shape:new(nil,10)myshape:printArea()

执行以上程序，输出结果为：

面积为 100

---

Lua 继承

继承是指一个对象直接使用另一对象的属性和方法。可用于扩展基础类的属性和方法。

以下演示了一个简单的继承实例：

 -- Meta classShape = {area = 0}-- 基础类方法 newfunction Shape:new (o,side)  o = o or {}  setmetatable(o, self)  self.__index = self  side = side or 0  self.area = side*side;  return oend-- 基础类方法 printAreafunction Shape:printArea ()  print("面积为 ",self.area)end

接下来的实例，Square 对象继承了 Shape 类:

Square = Shape:new()-- Derived class method newfunction Square:new (o,side)  o = o or Shape:new(o,side)  setmetatable(o, self)  self.__index = self  return oend

完整实例

以下实例我们继承了一个简单的类，来扩展派生类的方法，派生类中保留了继承类的成员变量和方法：

 -- Meta classShape = {area = 0}-- 基础类方法 newfunction Shape:new (o,side)  o = o or {}  setmetatable(o, self)  self.__index = self  side = side or 0  self.area = side*side;  return oend-- 基础类方法 printAreafunction Shape:printArea ()  print("面积为 ",self.area)end-- 创建对象myshape = Shape:new(nil,10)myshape:printArea()Square = Shape:new()-- 派生类方法 newfunction Square:new (o,side)  o = o or Shape:new(o,side)  setmetatable(o, self)  self.__index = self  return oend-- 派生类方法 printAreafunction Square:printArea ()  print("正方形面积为 ",self.area)end-- 创建对象mysquare = Square:new(nil,10)mysquare:printArea()Rectangle = Shape:new()-- 派生类方法 newfunction Rectangle:new (o,length,breadth)  o = o or Shape:new(o)  setmetatable(o, self)  self.__index = self  self.area = length * breadth  return oend-- 派生类方法 printAreafunction Rectangle:printArea ()  print("矩形面积为 ",self.area)end-- 创建对象myrectangle = Rectangle:new(nil,10,20)myrectangle:printArea()

执行以上代码，输出结果为：

面积为 100正方形面积为 100矩形面积为 200

---

函数重写

Lua 中我们可以重写基础类的函数，在派生类中定义自己的实现方式：

-- 派生类方法 printAreafunction Square:printArea ()  print("正方形面积 ",self.area)end

Lua 数据库访问

本文主要为大家介绍 Lua 数据库的操作库：LuaSQL。他是开源的，支持的数据库有：ODBC, ADO, Oracle, MySQL, SQLite 和 PostgreSQL。

本文为大家介绍MySQL的数据库连接。

LuaSQL 可以使用 LuaRocks 来安装可以根据需要安装你需要的数据库驱动。

LuaRocks 安装方法：

$ wget http://luarocks.org/releases/luarocks-2.2.1.tar.gz$ tar zxpf luarocks-2.2.1.tar.gz$ cd luarocks-2.2.1$ ./configure; sudo make bootstrap$ sudo luarocks install luasocket$ luaLua 5.3.0 Copyright (C) 1994-2015 Lua.org, PUC-Rio> require "socket"

Window 下安装 LuaRocks：https://github.com/keplerproject/luarocks/wiki/Installation-instructions-for-Windows

安装不同数据库驱动：

luarocks install luasql-sqlite3luarocks install luasql-postgresluarocks install luasql-mysqlluarocks install luasql-sqliteluarocks install luasql-odbc

你也可以使用源码安装方式，Lua Github 源码地址：https://github.com/keplerproject/luasql

Lua 连接MySql 数据库：

require "luasql.mysql"--创建环境对象env = luasql.mysql()--连接数据库conn = env:connect("数据库名","用户名","密码","IP地址",端口)--设置数据库的编码格式conn:execute"SET NAMES UTF8"--执行数据库操作cur = conn:execute("select * from role")row = cur:fetch({},"a")--文件对象的创建file = io.open("role.txt","w+");while row do    var = string.format("%d %s\n", row.id, row.name)    print(var)    file:write(var)    row = cur:fetch(row,"a")endfile:close()  --关闭文件对象conn:close()  --关闭数据库连接env:close()   --关闭数据库环境