Lua学习二

来源：互联网发布：淘宝网页面布局分析编辑：程序博客网时间：2024/05/16 14:49

再论函数

Lua中的函数是带有词法定界（lexical scoping）的第一类值（first-class values）

第一类值指：在Lua中函数和其他值（数值、字符串）一样，函数可以被存放在变量中，也可以存放在表中，可以作为函数的参数，还可以作为函数的返回值。

词法定界指：被嵌套的函数可以访问他外部函数中的变量。这一特性给Lua提供了强大的编程能力。

function foo (x) return 2*x end <---------> foo = function (x) return 2*x end

函数定义实际上是一个赋值语句，将类型为function的变量赋给一个变量。我们使用function (x) ... end来定义一个函数和使用{}创建一个表一样。

闭包

当一个函数内部嵌套另一个函数定义时，内部的函数体可以访问外部的函数的局部变量，这种特征我们称作词法定界。

外部的局部变量（external local variable）或者upvalue

function newCounter()
local i = 0
return function() -- anonymous function
i = i + 1
return i
end
end
c1 = newCounter()
print(c1()) --> 1
print(c1()) --> 2

非全局函数

Lua中函数可以作为全局变量也可以作为局部变量，如函数作为table的域（大部分Lua标准库使用这种机制来实现的比如io.read、math.sin）

当我们将函数保存在一个局部变量内时，我们得到一个局部函数，也就是说局部函数像局部变量一样在一定范围内有效

正确的尾调用

尾调用是一种类似在函数结尾的goto调用，当函数最后一个动作是调用另外一个函数时，我们称这种调用尾调用。

function f(x)
return g(x)
end

g的调用是尾调用。

例子中f调用g后不会再做任何事情，这种情况下当被调用函数g结束时程序不需要返回到调用者f；所以尾调用之后程序不需要在栈中保留关于调用者的任何信息。

由于尾调用不需要使用栈空间，那么尾调用递归的层次可以无限制的。

一些调用者函数调用其他函数后也没有做其他的事情但不属于尾调用。

function f (x)
g(x)
return
end

迭代器与范型for

迭代器与闭包

迭代器是一种支持指针类型的结构，它可以遍历集合的每一个元素。在Lua中我们常常使用函数来描述迭代器，每次调用该函数就返回集合的下一个元素。

迭代器需要保留上一次成功调用的状态和下一次成功调用的状态，也就是他知道来自于哪里和将要前往哪里

范型for的语义

文法

for <var-list> in <exp-list> do
<body>
end

<var-list>是一个或多个以逗号分割的变量名列表，<exp-list>是一个或多个以逗号分割的表达式列表，通常情况下exp-list只有一个值：迭代工厂的调用。

变量列表中第一个变量为控制变量，其值为nil时循环结束

执行过程

首先，初始化，计算in后面表达式的值，表达式应该返回范性for需要的三个值：迭代函数，状态常量和控制变量；与多值赋值一样，如果表达式返回的结果个数不足三个会自动用nil补足，多出部分会被忽略。
第二，将状态常量和控制变量作为参数调用迭代函数（注意：对于for结构来说，状态常量没有用处，仅仅在初始化时获取他的值并传递给迭代函数）。
第三，将迭代函数返回的值赋给变量列表。

第四，如果返回的第一个值为nil循环结束，否则执行循环体。
第五，回到第二步再次调用迭代函数。

更精确的来说：
for var_1, ..., var_n in explist do block end
等价于
do
local _f, _s, _var = explist
while true do
local var_1, ... , var_n = _f(_s, _var)
_var = var_1
if _var == nil then break end
block
end
end
如果我们的迭代函数是f，状态常量是s，控制变量的初始值是a0，那么控制变量将循环：a1=f(s,a0)、a2=f(s,a1)、⋯⋯，直到ai=nil。

无状态的迭代器

无状态的迭代器是指不保留任何状态的迭代器，因此在循环中我们可以利用无状态迭代器避免创建闭包花费额外的代价。

每一次迭代，迭代函数都是用两个变量（状态常量和控制变量）的值作为参数被调用，一个无状态的迭代器只利用这两个值可以获取下一个元素。

a = {"one", "two", "three"}
for i, v in ipairs(a) do
print(i, v)
end

迭代的状态包括被遍历的表（循环过程中不会改变的状态常量）和当前的索引下标（控制变量）

多状态的迭代器

很多情况下，迭代器需要保存多个状态信息而不是简单的状态常量和控制变量，最简单的方法是使用闭包，还有一种方法就是将所有的状态信息封装到table内，将table作为迭代器的状态常量，因为这种情况下可以将所有的信息存放在table内，所以迭代函数通常不需要第二个参数。

编译.运行.调试

dofile实际上是一个辅助的函数。真正完成功能的函数是loadfile；与dofile不同的是loadfile编译代码成中间码并且返回编译后的chunk作为一个函数，而不执行代码；另外loadfile不会抛出错误信息而是返回错误代

loadstring与loadfile相似，只不过它不是从文件里读入chunk，而是从一个串中读入.

f = loadstring("i = i + 1") <-----------> f = function () i = i + 1 end

i = 0
f(); print(i) --> 1
f(); print(i) --> 2

loadstring函数功能强大，但使用时需多加小心。确认没有其它简单的解决问题的方法再使用。
Lua把每一个chunk都作为一个匿名函数处理。例如：chunk "a = 1"，loadstring返回与其等价的function () a = 1 end

loadfile和loadstring都不会有边界效应产生，他们仅仅编译chunk成为自己内部实现的一个匿名函数

require函数

Lua提供高级的require函数来加载运行库。粗略的说require和dofile完成同样的功能但有两点不同：
1. require会搜索目录加载文件
2. require会判断是否文件已经加载避免重复加载同一文件。由于上述特征，require在Lua中是加载库的更好的函数。

require使用的路径和普通我们看到的路径还有些区别，我们一般见到的路径都是一个目录列表。require的路径是一个模式列表，每一个模式指明一种由虚文件名（require的参数）转成实文件名的方法。更明确地说，每一个模式是一个包含可选的问号的文件名。匹配的时候Lua会首先将问号用虚文件名替换，然后看是否有这样的文件存在。

require关注的问题只有分号（模式之间的分隔符）和问号，其他的信息（目录分隔符，文件扩展名）在路径中定义。

为了确定路径，Lua首先检查全局变量LUA_PATH是否为一个字符串，如果是则认为这个串就是路径；否则require检查环境变量LUA_PATH的值，如果两个都失败require使用固定的路径（典型的"?;?.lua"）

C Packages

Lua和C是很容易结合的，使用C为Lua写包。与Lua中写包不同，C包在使用以前必须首先加载并连接

错误

Lua经常作为扩展语言嵌入在别的应用中，所以不能当错误发生时简单的崩溃或者退出。相反，当错误发生时Lua结束当前的chunk并返回到应用中。

当Lua遇到不期望的情况时就会抛出错误，比如：两个非数字进行相加；调用一个非函数的变量；访问表中不存在的值等

你也可以通过调用error函数显示的抛出错误，error的参数是要抛出的错误信息

ssert首先检查第一个参数是否返回错误，如果不返回错误assert简单的返回，否则assert以第二个参数抛出错误信息。第二个参数是可选的。

当函数遇到异常有两个基本的动作：返回错误代码或者抛出错误。这两种方式选择哪一种没有固定的规则，但有一般的原则：容易避免的异常应该抛出错误否则返回错误代码。

require的另一个功能是避免重复加载同一个文件两次

异常和错误处理

不需要在Lua进行错误处理，一般有应用来完成。通常应用要求Lua运行一段chunk，如果发生异常，应用根据Lua返回的错误代码进行处理。在控制台模式下的Lua解释器如果遇到异常，打印出错误然后继续显示提示符等待下一个命令。
如果在Lua中需要处理错误，需要使用pcall函数封装你的代码。

假定你想运行一段Lua代码，这段代码运行过程中可以捕捉所有的异常和错误。
第一步：将这段代码封装在一个函数内

第二步：使用pcall调用这个函数

通过error抛出异常，然后通过pcall捕获他

错误信息和回跟踪

当错误发生的时候，我们常常需要更多的错误发生相关的信息，而不单单是错误发生的位置。至少期望有一个完整的显示导致错误发生的调用栈的tracebacks，当pcall返回错误信息的时候他已经释放了保存错误发生情况的栈的信息。因此，如果我们想得到tracebacks我们必须在pcall返回以前获取。Lua提供了xpcall来实现这个功能，xpcall接受两个参数：调用函数和错误处理函数。当错误发生时。Lua会在栈释放以前调用错误处理函数，因此可以使用debug库收集错误相关的信息。有两个常用的debug处理函数：debug。debug和debug.traceback,前者给出Lua的提示符，你可以自己动手察看错误发生时的情况；后者通过traceback创建更多的错误信息,后者是控制台解释器用来构建错误信息的函数。你可以在任何时候调用debug.traceback获取当前运行的traceback信息：
print(debug.traceback())

协同程序

协同基础

协同程序（coroutine）与多线程情况下的线程比较类似：有自己的堆栈，自己的局部变量，有自己的指令指针，但是和其他协同程序共享全局变量等很多信息

线程和协同程序的主要不同在于：在多处理器情况下，从概念上来讲多线程程序同时运行多个线程；而协同程序是通过协作来完成，在任一指定时刻只有一个协同程序在运行，并且这个正在运行的协同程序只有在明确的被要求挂起的时候才会被挂起

Lua通过table提供了所有的协同函数，create函数创建一个新的协同程序，create只有一个参数：协同程序将要运行的代码封装而成的函数，返回值为thread类型的值表示创建了一个新的协同程序。

co = coroutine.create(function ()
print("hi")
end)
print(co) --> thread: 0x8071d98

协同有三个状态：挂起态、运行态、停止态。当我们创建一个协同程序时他开始的状态为挂起态，也就是说我们创建协同程序的时候不会自动运行，可以使用status函数检查协

同的状态：
print(coroutine.status(co)) --> suspended

函数coroutine.resume可以使程序由挂起状态变为运行态：
coroutine.resume(co) --> hi
这个例子中，协同体仅仅打印出"hi"之后便进入终止状态：
print(coroutine.status(co)) --> dead

协同看起来只是一种复杂的调用函数的方式，真正的强大之处体现在yield函数，它可以将正在运行的代码挂起

coroutine.yield()

从协同的观点看：使用函数yield可以使程序挂起,当我们激活被挂起的程序时，yield返回并继续程序的执行直到再次遇到yield或者程序结束。

注意:resume运行在保护模式下，因此如果协同内部存在错误Lua并不会抛出错误而是将错误返回给resume函数。

管道和过滤器

协同是一种非抢占式的多线程。管道的方式下，每一个任务在独立的进程中运行，而协同方式下，每个任务运行在独立的协同代码中。管道在读（consumer）与写（producer）之间提供了一个缓冲，因此两者相关的的速度没有什么限制，在上下文管道中这是非常重要的，因为在进程间的切换代价是很高的。协同模式下，任务间的切换代价较小，与函数调用相当，因此读写可以很好的协同处理

用作迭代器的协同

将循环的迭代器看作生产者-消费者模式的特殊的例子。迭代函数产生值给循环体消费。所以可以使用协同来实现迭代器。协同的一个关键特征是它可以不断颠倒调用者与被调用者之间的关系，这样我们毫无顾虑的使用它实现一个迭代器，而不用保存迭代函数返回的状态

非抢占式多线程

Lua中的协同是一协作的多线程，每一个协同等同于一个线程，yield-resume可以实现在线程中切换。然而与真正的多线程不同的是，协同是非抢占式的。当一个协同正在运行时，不能在外部终止他。只能通过显示的调用yield挂起他的执行。

0 0