《Lua程序设计》笔记之一——语言篇

怼烎@ 2022-09-19 15:21 242阅读 0赞

1. Lua 是一个小巧而简单的语言。

Lua很容易与传统的C/C++整合，Lua以来C语言完成性能，底层操作以及第三方软件的接口。Lua提供了C所不擅长的，高级语言，动态结构，简洁，抑郁测试与调试。

Lua是一种易于扩展的语言，也是一种易整合语言。

Lua特点：

可扩展性：Lua扩展性很好，可以通过Lua代码或C代码扩展，Lua很多功能通过外部库来扩展。

简单： Lua本身简单，小巧，内容少但功能强大，易于实现小的应用。

高效：Lua有很高的执行效率

与平台无关：几乎可以运行在所有的系统上，Lua不是通过条件编译实现平台无关，完全使用ANSI C，只要有ANSI C编译器就可以编译并使用Lua。

Lua应用场景：

使用Lua嵌入在应用程序中。

作为一种独立运行的语言，用于文本处理或者只运行一次的小程序

使用其他语言开发，把Lua当做库使用，使用C语言开发，但使用Lua简历简单灵活易于使用的接口

2. 起点

print("Hello World");
     
    function fact(n)
           if n == 0 then
                  return 1;
           else
                  returnn*fact(n-1);
           end
    end
     
    print("enter a number:");
    a = io.read("*number");
    print(fact(a));
     
    5
    Hello World
    enter a number:
    120

Lua中的Chunks，交互模式下，一般是一行为一个Chunk，还可以是一个函数，MByte的Chunk也很常见。

全局变量：全局变量不需声明，给一个变量赋值即创建这个全局变量，没有初始化的全局变量初始化为nil

and break do else elseif end false for function if in local nil not or repeat return then true until while

Lua大小写敏感，单行注释 -- 多行注释–\[\[ --\]\]

\--\[\[

print(10) -- no action(comment)

\--\]\]

命令行方式： lua \[options\] \[script \[args\]\]

prompt>lua –e “print(math.sin(12))” à

全局变量里面存储了命令行参数，

3. 类型和数值

Lua是动态类型语言，变量不要类型定义。8个基本类型为：nil，boolean，number，string，userdata，function，thread，table。

type可以测试给定变量或值得类型：

print(type(“Hello world”))

print(type(10.4 \* 3))

print(type(print))

print(type(type))

print(type(true))

print(type(nil))

print(type(type(X)))

**Nil**是Lua中特殊的类型，全局变量没有被赋值以前默认为nil。

**Booleans**可以取false和true，可以作为条件。在控制结构中，除了false和nil为假以外，其他都为真，包括0和空串为真

**Numbers**表示实数，Lua中没有整数。

**Strings**指字符的序列。Lua是8位字节，字符串可以包含任何字符，但是Lua中字符串不可以修改，只能创建一个新的变量存放字符串。可以使用单引号或者双引号表示字符串

a= “a line”

b= ‘anthor line’

为了统一风格使用一种，当表示嵌套时才使用两种，对于含有引号情况使用转义符\\

\\a bell \\b 后退 \\f 换页 \\n 换行 \\r 回车 \\t 制表符 \\’ 单引号 \\” 双引号

\[\[… \]\]表示字符串，可以包含多行，也可以嵌套不会解释转义序列。

Lua会在string和numbers之间自动进行类型转换，使用算术操作符，string自动转为数字。

print(“10” + 1) print(“10 + 1”) print(“-5.3e-10” \* “2”)

“..”在Lua中是字符串连接符，其前后最好加空格，防止解释错误。

n = tonumber(line)

if n == nil then

error( line .. "isnot a valid number");

else

print( n \* 2);

end

数字与字符串之间的转换： tonumber() tostring()

Functions函数式第一类值，意味着函数可以存储在变量中，可以作为函数的参数，也可以作为返回值。

Lua可以调用lua或C实现的函数，Lua所有标准库都是用C实现的，标准库包括string库，table库，I/O库，OS库，算术库以及debug库。

Userdata和Threads：userdata可以将C数据存放在Lua变量中，userdata在Lua中除了赋值和相等比较外没有预定义的操作。Userdata用来描述应用程序或使用C实现的库创建的新类型。

4. 表达式：

Lua中表达式包括数字常量，字符串常量，变量，一元和二元运算符，函数调用以及非传统的函数定义和表构造。

算术运算符： + - \* / ^

关系运算符： < > <= >= == ~=

其中，nil只和自己相等，对于tables，userdata和functions的比较，仅当两者表示同一个对象时相等。

逻辑运算符：and or not

逻辑运算符认为false和nil为假，其他的都为真，0也是true。

and和 or的运算都是运算截断的，对于and，只要前面式子为假，则不计算后面式子，对于or则是相反，只要第一个参数为真，不再计算第二个参数。

C语言的三元运算符：a ? b: c 可以用这个语句实现： (a and b) or c;

链接运算符： .. 连接两个字符串

运算符的优先级：

not - (unary)

\* /

\+ --

< > <= >= ~= ==

and

表的构造：

构造器是创建和初始化表的表达式，表是Lua特有的功能强大的东西。\{\}构造空表，可以初始化数组：days=\{“Sunday”, “Mondy”,“Tuesday”, “Wednesday”, “Thursday”\}

初始化表为record： a = \{ x = 0, y = 0\}

不管用何种方式创建table，可以向表中添加或者删除任何类型的域，构造函数仅影响表的初始化。

创建一个链表：

list= nil

forline in io.lines() do

list= \{ next = list, value = line\};

end

这样就创建了一个链表。

一个构造函数中可以混合列表风格和record风格进行初始化：

polyline= \{ color = “blue”, thickness = 2, npoints = 2,

\{x = 0, y = 0\}

\{x = -10, y = 0\}

\{x = -100, y = 1\}

\{x = 0, y = 1\}

另一种更一般的初始化方式，用\[expresson\]显示的表示将被初始化的索引：

opnames= \{ \[“+”\] = “add”, \[“-”\] = “sub”, \[“\*”\] = “mul”\}

5. 基本语法

赋值语句，控制结构语句，函数调用，还有多变量赋值，局部变量声明

多变量赋值： a, b = 10, 2 \* x;

可以用于交换变量的值： x, y = y, x;

当变量和值得个数不一致时，lua以变量个数为基础：

1.变量个数 > 值得个数， 按变量个数不足nil

2.变量个数 < 值得个数， 多余的值会被忽略

函数调用也是使用这个原则。

使用local创建一个局部变量，局部变量只在被声明的代码块内有效。代码块：一个控制结构内，一个函数体，或者一个chunk

尽可能使用局部变量：避免命名冲突，访问局部变量的速度比全局变量更快

可以使用do … end代码块来控制程序的范围

控制语句： if … then … end if … then … else … end; if … then … elseif … then … end

while… do … end repeat … until ;

forvar = exp1, exp2, exp3 do loop-part end

注意：

exp三个如果是式子，那么他们只会被计算一次

控制变量var是局部变量自动被声明，只在循环内有效

循环中不要改变控制变量的值，会造成不可预知的效果，退出循环使用break

泛型for循环

break和return语句用来退出当前循环(for, repeat, while)，break和return只能出现在block的结尾一句。Chunk最后的一句，end之前或者else前，或者until前。如果必须在代码中间出现，则可以加入do … end 代码段，在其中加入一个return或break即可。

6. 函数：

函数用途：完成指定的任务，作为调用语句使用；计算并返回值，作为赋值语句的表达式使用。

functionfunc\_name (arguments-list)

statements-list;

end;

Lua的面向对象方式调用函数的语法： o:foo(x) 与 o.foo(o, x)是等价的

返回多个结果值：

Lua函数可以返回多个结果值，比如 s, e = string.find( “helloLua users”, “Lua”);其返回的是匹配串 开始和结束的下标。

function maximum(a)

localmi = 1;

localm = a\[mi\];

fori, val in ipairs(a) do

if val > m then

mi= i; m = val;

end

returnm, mi;

end

可变参数：

Lua函数接受可变数目的参数，使用三点(…)表示函数有可变的参数。Lua将函数的参数放在一个叫做arg的表中，除了参数之外，arg表中有一个域n，表示参数的个数。

命名参数：

Lua的函数式和位置相关的，调用实时参数按照顺序一次传给形参。有时候用名字指定参数是很有用的。

Lua中的函数式带有词法界定的第一类值。第一类值指Lua中的函数和其他（数值，字符串）一样，函数被存在变量中，也可以放在表中。

词法定界指：被嵌套的函数可以访问他外部函数中的变量。Lua中关于函数比较难以理解的是匿名的，我们提到函数名，实际上说一个指向函数的变量，像其他类型值变量一样。

a= \{p = print\};

a.p(“Helloworld!”);

print= math.sin;

a.p(print(1));

函数是值，那么表达式可以创建函数，Lua可以这样写：

functionfoo(x) return 2 \* x end

原本的函数是这样的：foo = function (x) return2 \* x end; 即使用function(x) … end来定义一个函数。

table 标准库提供一个排序函数，接受一个表作为输入参数切排序表中的元素。Lua没有尽可能多地提供参数来满足不同值得需求，而是接受一个排序函数作为参数，类似C++的函数对象。排序函数接受两个排序元素作为输入参数，且返回两者的大小关系。

network = {
           { name = “grauna”,  IP = “210.26.30.34”},
           { name = “arraial”,  IP = “210.26.30.23”},
           { name = “lua”,  IP = “210.26.23.12”},
           { name = “derain”,  IP = “210.26.23.20”},
    }
           相对表进行那么域的排序：
           table.sort(network,function (a, b), return (a.name > b.name) end);
          
           结果：
            grauna = 210.26.30.34        arraial = 210.26.30.23        lua = 210.26.23.12        derain = 210.26.23.20        lua = 210.26.23.12        grauna = 210.26.30.34        derain = 210.26.23.20        arraial = 210.26.30.23 
     
    
    
    
    
     
     将第一类值函数应用在表中是Lua实现面向对象和包机制的关键。 
            当一个函数内部嵌套另一个函数定义时，内部的函数体可以访问外部的函数的局部变量，这种特征称为此法界定 
            词法定界加上第一类函数在编程语言里是一个功能强大的概念。 
            一个简单的例子：一个学生姓名的列表和一个学生名和成绩对应的表，现在想根据学生的成绩从高到底对学生进行排序： 
     names = { "Peter", "Paul", "Mary"};
    grades = { Mary = 10, Paul = 7, Peter = 8};
    for i = 1, #names do
           print( names[i]);
    end
     
    table.sort(names, function (n1, n2) return grades[n1] > grades[n2] end)
    print("\n");
    for i = 1, #names do
           print( names[i]);
    end 
            上述排序函数中，匿名函数中的grades不是全局变量也不是局部变量，称为外部的局部变量。 
            例如： 
            function newCounter() 
                   local i = 0; 
                   return function() 
                          i = i + 1; 
                          return i; 
                   end; 
            end 
       
            c1 = newCounter(); 
            print(c1()); 
            print(c1()); 
            运行结果： 
            1 
            2 
            匿名函数使用i保存它的计数，调用匿名函数的时候，i已经超出了作用范围。然而Lua用闭包的思想正确处理了这种情况。简单说闭包是一个函数加上它可以正确访问的upvalues。如果再次调用newCounter，将创建一个新的局部变量i，得到一个作用在新的变量i上的新闭包。 
            如： 
            c2= newCounter(); 
            print(c2()); 
            print(c1()); 
            print(c2()); 
            运行结果： 
            1 
            3 
            2 
            c1和c2是建立在同一个函数上，但作用在同一个局部变量的不同实例上的两个不同的闭包。 
            从技术上讲，闭包指值而不是指函数，函数仅仅是闭包的一个原型声明；在不会导致混淆的情况下继续使用属于函数代指闭包。 
            闭包在上下文环境中提供很有用的功能，可以作为高级函数的参数，作为函数嵌套的函数，也可以作为毁掉函数。 
            需要将原始函数有一个新的实现时可以重新定义函数： 
     do
           local oldSin = math.sin;
           local k = math.pi / 180;
           math.sin = function (x)
                  return oldSin(x *k);
           end
    end 
            Lua中函数可以作为全局变量也可以作为局部变量。函数作为table的域，这种情况要注意函数和表语法： 
            表和函数在一起： 
     --表和函数放在一起
    Lib = {}
    Lib.foo = function (x, y) return x + y end;
    Lib.goo = function (x, y) return x - y end;
     
    --表构造函数
    Lib = {
           foo = function (x, y)return x + y end,
           goo = function (x, y)return x - y end
    }
     
    --Lua的另一种方式
    Lib = {}
    function Lib.foo (x, y)
           return  x + y;
    end
     
    function Lib.goo (x, y)
           return  x - y;
    end 
            将函数保存在一个局部变量内时，得到一个局部变量，也就是说局部函数像局部变量一样在一定范围内有效。这种定义在包中很有用，Lua把chunk当做函数处理，chunk内可以声明局部函数，词法定界保证了包内的其他函数可以调用此函数。 
            localf = function (…) 
                   … 
            end 
            
            localg = function (…) 
                   … 
                   f() 
                   … 
            end 
            或者 
            localfunction f(…) 
                   … 
            end 
            在声明递归时，注意局部函数的声明方式： 
            localfact = function(n) 
                   ifn == 0 then 
                          return1; 
                   else 
                          returnn * fact(n-1); 
                   end 
            end 
            这种方式编译会出问题，当编译到fact(n-1)时，Lua并不知道fact是局部函数。为了解决问题，可以事先声明fact为局部变量，再写函数 
            localfact； 
            fact =function(n) 
                   ifn == 0 then 
                          return1; 
                   else 
                          returnn * fact(n-1); 
                   end 
            end 
            尾调用：Lua中函数的一个有趣的特征是可以正确处理尾调用（proper tailrecursion），或者叫做尾递归。 
            尾调用是一种类似在函数结尾的goto调用，当函数最后一个动作时调用另外一个函数时，称这种调用为尾调用。 
            functionf( x) 
                   returng(x); 
            end 
            对g的调用是尾调用。f调用g后不会再做任何事情，这种情况下当被调用函数g结束时程序不需要返回调用者f，所以尾调用之后程序不需要再栈中保留关于调用者的任何信息。Lua解释器利用这种特性，在处理尾调用时不适用额外的栈，称这种语言支持正确的尾调用。 
            关于尾调用的界定：必须明确什么是尾调用。 
            functionf(x) 
                   g(x) 
                   return; 
            end 
            虽然调用者函数调用其他函数后没有做其他的事情，但是不属于尾调用。f在调用g后，不得丢弃g的返回值，不是尾调用，下面的例子也不是尾调用。 
            returng(x) + 1;     return x or g(x);   return (g(x)); 
            可以将尾调用理解为一种goto，在状态机的编程领域尾调用非常有红。 
     7. 迭代器和泛型for 
            迭代器是一种支持指针类型的结构，便利集合的每一个元素。Lua中常使用函数来描述迭代器，每次调用该函数就返回集合的下一个元素。 
            闭包是一个内部函数，可以访问一个或者多个外部函数的局部变量。每次闭包的成功调用后，这些局部变量都保存他们的值，当然如果要创建一个闭包必须要创建其外部局部变量。一个典型的闭包的结构包含两个函数：一个闭包自己，另一个是工厂（创建闭包的函数）。 
            为list写一个简单迭代器，迭代器返回元素的值，而不是索引下标： 
            function list_iter(t) 
                   local i = 0; 
                   local n = table.getn(t); 
                   return function () 
                          i = i + 1; 
                          if i <= n thenreturn t[i] end; 
                   end 
            end 
            list_iter是一个工厂，每次调用它都会创建一个新的闭包，闭包保存内部局部变量，每次调用它返回list的下一个元素值，list没有值时返回nil。 
            unctionlist_iter(t) 
                   local i = 0; 
                   local n = table.getn(t); 
                   return function () 
                          i = i + 1; 
                          if i <= n thenreturn t[i] end; 
                   end 
            end 
       
            t = {10, 20, 30}; 
            iter = list_iter(t); 
            while true do 
                   local element = iter(); 
                   if element == nil thenbreak end; 
                   print(element); 
            end 
       
            -- 用于泛型for语句 
            t = {10, 20, 30} 
            for element in list_iter(t) do 
                   print(element); 
            end 
            泛型for为迭代循环处理所有的簿记：首先调用迭代工厂；内部保留迭代函数，因此不需要iter变量，然后再每一个新的迭代处调用迭代函数。当迭代器返回nil时循环结束。 
            
            泛型for的语义： 
            for<var-list> in <exp-list> 
                   <body> 
            end 
            <var-list>是一个或多个逗号分隔的变量名列表, <exp-list>是一个或多个以逗号分隔的表达式列表，exp-list通常只有一个值：迭代工厂的调用。 
            fork, v in pairs(t) do 
                   print(k, v) 
            end 
            很多情况下变量列表只有一个变量， 
            forline in  io.lines() do 
                   io.write(line, ‘\n’); 
            end 
            变量列表中第一个变量为控制变量，其值为nil时循环结束。 
            泛型for的执行过程： 
            1.初始化，计算in后面表达式的值，表达式应该返回泛型for需要的三个值：迭代函数，状态常量和控制变量；如果表达式返回的结果个数不足三个，自动用nil补足。 
            2.将状态常量和控制变量作为参数调用迭代函数。 
            3.将迭代函数返回的值赋给变量列表 
            4.如果返回的第一个值为nil，循环结束，否则执行循环体 
            5.回到第二步再次调用爹哎函数。 
            forvar_1, … , var_n  in explist  do block end 
            等价于： 
            do 
                   local_f, _s, _var = explist; 
                   whiletrue do 
                          localvar_1, …, var_n = _f( _s, _var); 
                          _var= var_1; 
                          if_var == nill then break end; 
                          loop-block 
                   end 
            end 
            
            无状态迭代器是指不保留任何状态的迭代器，利用无状态迭代器避免创建闭包话费额外的代价。 
            每一次迭代，迭代函数都用两个变量（状态变量和控制变量）的值作为参数被调用，一个无状态的迭代器只利用这个值获取下一个元素。这种无状态迭代器的典型的简单的例子是ipairs，遍历数组的每一个元素。 
            a= {"one", "two", "three"}; 
            for i, v in ipairs(a) do 
                   print( i, v); 
            end 
            输出结果： 
            1       one 
            2       two 
            3       three 
            
     8. 编译，运行，调试 
            dofileloadfile 以及 loadstring将lua代码加载到Lua解释器进行运行。 
            其中loadfile只是将Lua代码加载到Lua解释器，并不运行，需要写运行语句进行运行。 
            
            require函数： 
            Lua提供高级的require函数来加载运行库： 
            require回搜索目录加载文件，require回判断是否文件已经加载，避免重复加载同一个文件 
            require使用的路径和普通的路径有些区别，一般看到的路径是一个目录列表，require路径是一个模式列表，每一个模式指明一种由需文件名转成文件名的方法。每一个模式是一个包含可选的问好的文件名，匹配的时候将问号用虚文件名替换，看是否存在这样的文件。 
            如?:?.lua;c:\windows\?;/usr/local/lua/?/?.lua 
            调用require “lili”时会试着打开这些文件 
            lili 
            lili.lua 
            c:\windows\lili 
            /usr/local/lua/lili/lili.lua 
            
            CPackages 
            C包在使用以前必须加载并连接，绝大多数系统中最容易的实现方式是动态链接库，然而动态链接库并不是ANSI C的一部分，在标准C中实现动态链接很困难。 
            Lua通常不包含任何不能用标准C实现的机制，动态链接库是一个特例。动态链接库机制是其他机制之母：拥有了动态链接机制，可以动态加载Lua中不存在的机制。Lua打破平台兼容的原则，通过条件编译方式为一些平台实现了动态链接机制。 
            Lua在一个loadlib函数内提供了所有的动态链接的功能，这个函数有两个参数：库的绝对路径和初始化参数，典型的调用例子如下： 
            localpath = “/usr/local/lua/lib/libluasocket.so” 
            localf = loadlib( path, “luaopen_socket”); 
            
            localpath = “/usr/local/lua/lib/libluasocket.so” 
            --or path = “C:\\windows\\luasocket.dll” 
            localf = assert(loadlib( path, “luaopen_socket”)); 
            f()  -- actually open the library 
            二进制的发布库包含一个与前面代码相似的stub文件，安装二进制库的时候，可以随便放在某个目录，只需要修改stub文件对应二进制库的世纪路径即可。将stub文件所在的目录加入到LUA_PATH，这样设定后可以使用require函数加载C库。 
            
            错误： 
            Lua遇到不期望的情况时回跑出错误，可以通过调用error函数显示的抛出错误，error的参数也是要抛出的错误信息。Lua提供了专门的内置函数assert来完成这个功能： 
            print“enter a number:” 
            n= assert( io.read(“*number”), “inlalid input”); 
            assert首先检查第一个参数的返回错误，如果不返回错误assert简单的返回，否则assert以第二个参数抛出错误信息。第二个参数是可选的。 
            遇到异常时，有两个基本的动作：返回错误代码或者抛出错误。有一个一般的原则：容易避免的异常应该抛出错误，否则返回错误代码。 
            
            如果在Lua中需要处理错误，使用pcall函数封装代码： 
            想运行一段Lua代码，这段代码运行过程中可以捕捉所有的异常和错误。 
            第一步：将代码封装在一个函数内： 
            functionfoo() 
                   … 
                   ifunexpected_condition then error() end 
                   … 
                   print(a[i]); 
            end 
            第二步：使用pcall调用这个函数 
            ifpcal(foo) then 
                   …    -- no errors while running ‘foo’ 
            else 
                   …    -- ‘foo’ raised an error: take appropriateactions 
            end 
            pcall在保护模式下调用他的第一个参数并运行，因此可以补货所有的异常和错误。没有异常和错误，pcall返回true和调用返回的任何值：否则返回nil加错误信息。 
            错误信息不一定非要是一个字符串，传递给error的任何信息都会被pcall返回 
            localstatus, err = pcall( function() error ({code=121}) end); 
            print(err.code); 
            这种机制提供了在Lua中处理异常和错误所需要的全部内容，通过error抛出异常，然后通过pcall捕获。 
            
            当错误发生时，Lua会在栈释放以前调用错误处理函数，可以使用debug收集错误相关的信息，有两个常用的debug处理函数：debug和debug.traceback，前者给出Lua的提示符，可以手动查看错误发生时的情况，后者通过traceback创建更多错误信息。可以在任何时候，调用debug.traceback来获取当前运行的traceback信息： 
            print(debug.traceback()) 
       
     9. 协同程序： 
            协同程序与多线程情况下的线程比较类似：有自己的堆栈，局部变量，指令指针，但是和其他的协同程序共享全局变量等很多信息。线程和协同程序的不同在于：在多处理器情况下，从概念上来讲多线程程序同时运行多个线程，而协同程序则是通过协作来完成，在任一指定时刻只有一个协同程序在运行，运行的协同程序只有在明确被要求挂起时才会被挂起。 
            Lua通过table提供所有得协同函数，create函数创建一个新的协同程序，create只有一个参数，协同程序将要运行的代码封装而成的函数，返回值为thread类型的值表示创建一个新的协同程序。 
            co= coroutine.create(function () print(“hi”)  end); 
            print(co); 
            协同有三个状态：挂起态，运行态，停止态。创建协同程序后为挂起状态，不会自动运行，使用status检查协同的状态。 
            coroutine.resume(co); 使得程序由挂起状态变为运行态。 
            corouting.yield(co); 使得运行的程序挂起 
            
     例如： 
            co = coroutine.create( function () 
                   for i = 1, 10 do 
                          print("co",i); 
                          coroutine.yield(); 
                   end 
            end); 
            coroutine.resume( co); 
            print(coroutine.status( co)); 
       
            运行结果： 
            co      1 
            suspended 
            从协同的观点，使用函数yield可以使程序挂起，yield返回后继续程序的执行直到再次遇到yield或者程序结束，则停止。 
            coroutine.resume(co)     --> co  2 
            coroutine.resume(co)     --> co  3 
            … 
            coroutine.resume(co)     --> co  10 
            resume运行在保护模式下，如果协同内部存在错误，并不会抛出错误而是将错误返回给resume函数。 
            Lua中一对resume-yield可以相互交换数据。 
            只有resume，没有相应的yield，resume把额外的参数传递给协同的主程序： 
            co = coroutine.create( function (a, b,c ) 
                   print("co",a, b, c); 
            end);       
            print( coroutine.resume( co, 1, 2, 3)); 
            运行结果： 
            co      1       2       3 
            true 
            
            resume返回除了true以外的其他部分讲作为参数传递给yield 
            co = coroutine.create(function (a, b) 
                   coroutine.yield(a + b, a - b); 
            end);       
            print( coroutine.resume(co, 20, 10)); 
       
            true  30    10 
            对称性，yield返回的额外的参数也会传递给resume 
            co = coroutine.create( function () 
                   print("co",coroutine.yield()); 
            end); 
            coroutine.resume( co); 
            coroutine.resume( co, 4, 5); 
       
            co    4     5 
            协同函数结束时，主函数返回的值都会传递给相应的resume： 
            co= coroutine.create( function () 
                   return6, 7; 
            end); 
            Lua提供的这种协同称为不对称的协同，挂起一个正在执行的协同的函数与使一个被挂起的协同再次执行的函数时不同的。提供对称的协同的语言，这种情况下由执行到挂起之间状态转换的函数是相同的。 
            管道和过滤器： 
            
            用作迭代器的协同 
       
            非抢占式多线程： 
       
     10. 完整示例 
     function fwrite (fmt, ...)
           returnio.write(string.format(fmt, unpack(arg)));
    end
     
    function BEGIN()
           io.write([[
                  <HTML>
                  <HEAD><TITLE>Projectsusing Lua</TITLE></HEAD>
                  <BODY BGCOLOR= "#FFFFFF">
                  Here are briefdescriptions of some projects around the world
                  that use <AHREF = "home.html">Lua</A>
           ]]);
    end
     
    function entry0 (o)
           N = N + 1;
           local title = o.title or'(no title)';
           fwrite('<LI><AHREF = "#%d">%s</A>\n', N, title);
    end
     
    function entry1 (o)
           N = N + 1;
           local title = o.title oro.org or 'org';
           fwrite('<HR>\n<H3>\n');
           local href = '';
           if o.url then
                  href = string.format("HREF=%s",o.url);
           end
           fwrite('<ANAME="%d"%s>%s</A>\n', N, href, title);
          
           if o.title and o.orgthen
                  fwrite('\n<SMALL><EM>%s</EM></SMALL>',o.org);
           end
           fwrite('\n</H3>\n');
          
           if o.description then
                  fwrite('$s',string.gsub(o.description, '\n\n\n*', '<P>\n'));
                  fwrite('<P>\n');
           end
          
           if o.email then
                  fwrite('Contact:<A HREF="mailto:%s">%s</A>', o.email, o.contact,o.email);
           elseif o.contact then
                  fwrite('Contact:%s\n', o.contact);
           end
    end
     
    function END()
           fwrite('</BODY></HTML>\n');
    end
     
    BEGIN()
     
    N = 0;
    entry = entry0
    fwrite('<UL>\n');
    dofile('E:\\Lua\\Demo\\ProgramInLua\\db.lua');
    fwrite('</UL>\n');
     
    N = 0;
    entry = entry1
    dofile('E:\\Lua\\Demo\\ProgramInLua\\db.lua');
     
    END() 
     将下面的table读出，并写入到文件中去： 
     entry = {
           title ="Tecgraf",
           org = "ComputerGraphics Technology Group, PUC-Rio",
           url ="http://www.tecgraf.puc-rio.br/",
           contact = "WaldemarCeles",
           description = [[
                  TeCGraf is theresult of a partnership between PUC-Rio,
                  the PontificalCatholic University of Rio de Janeiro,
                  and <AHREF="http://www.petrobras.com.br/">PETROBRAS</A>,
                  the Brazilian OilCompany.
                  TeCGraf is Lua'sbirthplace,
                  and the languagehas been used there since 1993.
                  Currently, morethan thirty programmers in TeCGraf use
                  Lua regularly;they have written more than two hundred
                  thousand lines ofcode, distributed among dozens of
                  final products.]]
    } 
    
    
    
     
     By Andy @ 2013-12-29