Lua基础编译、运行、错误处理

你的名字 2022-03-17 09:44 365阅读 0赞

尽管Lua是一门解析型的语言，但是在运行前也会被编译成某个中间状态。一门解析型的语言需要编译，这听起来有点不合常理。但是，实际上，解析型语言的与众不同，不是说它不需要编译，而是说它把编译作为其运行时的一部分，因此，它就可以执行各种来自外部的代码（例如网上的）。也许因为Lua中存在的如*dofile* 这样的函数，才使Lua可以被称为一门解析型语言。

# 1. 编译 #

之前我们介绍了*dofile* 来执行代码块，但是*dofile* 只是一个辅助函数。这里介绍一下*loadfile* 函数，它会从一个file中加载语句块，但是不运行；而是仅仅编译并作为一个函数返回。*loadfile* 不会像*dofile* 那样在运行时直接报错退出，而是返回错误码，这样我们就可以根据错误码做相应的处理。我们可以像下面这样定义*dofile* ，这也可以看出*dofile* 和*loadfile* 的区别

function dofile (filename)
        local f = assert(loadfile(filename))
        return f()
    end

注意，*assert* 可以使*loadfile* 发生错误时，报错退出。

*dofile* 在处理有些简单的任务时，使用起来比较方便，只需要一次调用，它会完成所有的操作（编译，运行啥的）。但是，*loadfile*更加灵活。发生错误的时候，*loadfile* 会返回**nil** \+ 'err\_msg'，我们可以根据实际情况对错误做出相应的处理。除此之外，如果想要运行一个file多次，可以先调用一次*loadfile* ，然后调用*loadfile* 返回的结果多次，就可以了。这比调用几次*dofile* 开销要小很多，因为*loadfile* 只会执行一次编译，而*dofile* 每次都用都要编译。

*loadstring* 跟*loadfile* 差不多，区别是从一个string中加载代码块，而不是从file中。例如：

f = loadstring("i = i + 1")

*f* 是*loadstring* 的返回值，应该是function类型， 调用的时候，会执行i = i + 1 :

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

*loadstring* 函数功能非常强大，但是运行起来，开销也不小，并且有时会导致产生一些莫名其妙的代码。因此，在用*loadstring* 之前，先考虑下有没有更简单的办法。

下面这行代码，不太好看，但是很方便。（不鼓励这种调用方法）

loadstring(s)()

如果有语法错误，*loadstring* 会返回**nil **\+ 类似‘attempt to call a nil value’这样的err\_msg。如果想获取更详细的err\_msg，那就需要用*assert* ：

assert(loadstring(s))()

下面这样的使用方式（对一个字面值string使用loadstring），没什么意思，

f = loadstring("i = i + 1")

粗略的等价于：

f = function () i = i + 1 end

但是，也不是完全相同，且继续往下看。第二种方式的代码运行起来更快，因为它只需要编译一次，而*loadstring* 每次都需要编译。下面我们来看看，上面两段代码到底有什么不同，如下示例：

i = 32
    local i = 0
    f = loadstring("i = i + 1; print(i)")
    g = function () i = i + 1; print(i) end
    f() --> 33
    g() --> 1

*g* 函数处理的事局部变量i ， 而*f* 函数处理的是全局变量i ，*loadstring* 总是在全局环境中进行编译。

*loadstring* 最典型的用途是：运行外来代码，例如网络上的，别人的。。。注意，*loadsting* 只能load语句，不能load表达式， 如果你想算一个表达式的值，那么前面要加上一个*return* 来返回给定表达式的值。下面是一个示例帮助理解：

print "enter your expression:"
    local l = io.read()
    local func = assert(loadstring("return " .. l))
    print("the value of your expression is " .. func())

看一下运行情况：（注意第一个为什么报错了，想想什么才叫表达式）

![1366206267_9634.PNG][]

*loadstring* 返回的就是一个普通的函数，可以多次调用：

print "enter function to be plotted (with variable 'x'):"
    local l = io.read()
    local f = assert(loadstring("return " .. l))
    for i=1,20 do
        x = i -- global 'x' (to be visible from the chunk)
        print(string.rep("*", f()))
    end

（*string.rep* 函数复制一个string给定的次数），下面是运行结果：

![1366206317_1906.PNG][]

如果我们在深究一下，其实不管*loadstring* 也好，*loadfile* 也好，Lua中最基础的函数是*load* 。*loadfile* 从一个file中加载代码块，*loadstring* 从一个string中加载代码块，而*load* 调用一个*reader* 函数来获取代码块，这个*reader* 函数分块返回代码块，*load* 调用它，直到它返回**nil** 。我们很少使用*load* 函数；通常只有在代码块不是位于一个file中，但是又太大了，不适合放到内存中（如果适合放到内存中，那就可以用*loadstring* 了）的时候，才会用load 。

Lua将每一个独立的代码块看作是一个含有不定数量参数的匿名函数。例如，*loadstring*("a = 1")跟下面的表达式基本等价：

function (...) a = 1 end

跟其他函数一样，代码块也可以声明局部变量：

f = loadstring("local a = 10; print(a + 20)")
    f() --> 30

利用这个特性，我们可以重写上面的一个例子：

print "enter function to be plotted (with variable 'x'):"
    local l = io.read()
    local f = assert(loadstring("local x = ...; return " .. l))
    for i=1,20 do
        print(string.rep("*", f(i)))
    end

在代码的开始处，加了“local x = ...”，将x声明为局部变量。调用*f*  函数的时候，实参i 就变成了变参表达式"..."的值。运行结果，跟上面一样，就不截图了。

*load *函数不会发生运行时错误崩溃。如果出错了，总是返回**nil**\+err\_msg：

![1366205266_8658.PNG][]

一个很常见的误解：将load代码块与定义函数划等号。在Lua中，函数定义实际上是赋值行为，而且是在运行时才发生，而不是在编译时。例如，我们有个文件foo.lua：

function foo (x)
        print(x)
    end

接着运行下面这条cmd：

f = loadfile("foo.lua")

这个时候，foo被编译了，但是还没有被定义。要定义它，必须运行这个代码块：

print(foo) --> nil
    f() -- defines 'foo'
    foo("ok") --> ok

在生产环境中的程序，在运行外部代码的时候，要尽可能的捕获所有的错误并作出处理。甚至，如果这些代码不被信任，那就应该在一个安全的环境中运行，避免在运行这些外来代码的时候，产生一些不愉快的事情。

# 2. C代码 #

不像Lua代码，C代码必须先跟程序链接才能被使用。在大多数系统中，做这个链接动作的做简单的方法是：使用动态链接功能。那么怎么检测你的环境是否已经支持这个功能呢？

运行  *print(package.loadlib("a", "b"))*。如果出现类似说文件不存在这样的错误，那么就说明你的环境支持这个动态链接功能啦。否则，出现的错误信息会告诉你这个功能不支持，或者没有被安装。下面是我的环境的表现：

![1366206835_3719.PNG][]

*package.loadlib* 有两个string类型的参数，第一个是库的完整路径，第二个是函数的名字。因此，一个典型的调用应该跟下面很相似：

local path = "/usr/local/lib/lua/5.1/socket.so"
    local f = package.loadlib(path, "luaopen_socket")

*loadlib* 函数，加载一个给定的库，并链接，但是并没有去调用那个函数。而是将这个C 函数当作Lua函数返回。如果这个过程出现什么错误，那么*loadlib* 会返回**nil** \+ err\_msg。

要使用*loadlib* 函数，我们必须要给出库的完整路径和准确的函数名字，好像有点麻烦。这里有个替代方案，*require* 函数。我们后面在讨论这个函数，这里只需知道有这么个东西就可以了。

# 3. 错误 #

是个人就难免会犯错。因此我们要尽可能的处理可捕获的错误。因为Lua是一个扩展语言，通常是被嵌入到别的程序（姑且叫做宿主程序吧）中，在出错的时候，不能简单的让它崩溃掉或者退出。而是结束执行当前的代码块，并返回到宿主程序中。

Lua遇到任何非期望的条件，都会产生一个错误。例如，对非数值进行加运算，调用一个非函数的值，索引一个非table的值，等等。可以显式地调用error 函数来产生一个错误。例如：

print "enter a number:"
    n = io.read("*number")
    if not n then error("invalid input") end

*if not condition then error end*，在Lua中被封装成了assert 函数：

print "enter a number:"
    n = assert(io.read("*number"), "invalid input")

*assert* 检查它的第一个参数，如果为**nil**或者**false**，就产生一个error。第二个参数是可选的。

在函数发现错误时，有两种处理方式，一个是返回error code，另一个是产生错误（联想下C语言中的*assert*）。如何选择呢？建议如下：可以轻松避免的错误，可以通过编码来修改并规避的，产生错误；否则返回errcode。  
  
举个例子，sin 函数，如果参数用了一个table，假设它返回了一个error code，如果我们需要去检查一下这个错误，那么代码应该像下面这样写：

local res = math.sin(x)
    if not res then -- error?
        <error-handling code>

但是，实际上，我们可以在调用sin 函数之前就检查一下x 是否合法：

if not tonumber(x) then -- x is not a number?
        <error-handling code>

如果参数x不是一个数值，那么意味着你的程序中某个地方出错了。这种情况下，停止运行并产生一个错误信息，是最简单有效的方式来处理这个错误。

我们再来看下*io.open* 函数，当我去open一个并不存在的file时，会怎么样呢？这个情况，并不能提前检查这个file是否存在，因为在很多系统中，要想知道某个file是否存在，只有去尝试打开它。因此，如果函数*io.open* 因为一些外部原因（例如file does not exist, permisson denied)而不能打开一个file，它会返回**nil** + err\_msg。这样的话，我们就可以进行一些处理，例如要求用户重新输入一个文件名：

local file, msg
    repeat
        print "enter a file name:"
        local name = io.read()
        if not name then return end -- no input
        file, msg = io.open(name, "r")
        if not file then print(msg) end
    until file

如果仅仅希望保证*io.open* 能够正常工作，可以简单的使用：

file = assert(io.open(name, "r"))

这是Lua中的一个习惯用法，如果*io.open*失败了，就会产生一个错误。

# 4. 错误处理和异常 #

对大多数程序来说，不需要在Lua代码中进行错误处理，宿主程序本身会对错误进行相应处理。所有的Lua动作基本都是由宿主程序调用起来的，如果发生错误，Lua代码块只需要返回相应的err\_code，宿主程序本身针对err\_code做出相应的处理。在独立的Lua解析器中，出错的时候，也只是打印出相应的错误信息，然后继续提示用户继续进行运行其他的命令。

如果想要在Lua中对错误进行处理，那么必须用*pcall* （protected call）函数来封装代码。

假设我们运行一段lua代码，并捕获到运行过程中出现的错误。我们首先要做的就是封装这段代码，假设封装成函数*foo* ：

function foo ()
        <some code>
        if unexpected_condition then error() end
        <some code>
        print(a[i]) -- potential error: 'a' may not be a table
        <some code>
    end

然后用*pcall* 去调用这个函数：

if pcall(foo) then
        -- no errors while running 'foo'
        <regular code>
    else
        -- 'foo' raised an error: take appropriate actions
        <error-handling code>
    end

上面的*foo* 函数也可以替换成匿名函数的。

*pcall* 会在protected mode下调用它的第一个参数，以便能够在函数运行过程中捕获到出现的错误。如果函数运行正常，没有错误产生，*pcall* 返回**true** \+ 函数的返回值；如果出现错误，*pcall* 返回**false** \+ err\_msg。

err\_msg不一定非得是string，任何传递给error 的值都会被pcall 返回，例如下面的示例：

local status, err = pcall(function () error({code=121}) end)
    print(status, err.code, type(err))

运行结果如下：

![1366298797_8532.PNG][]

# 5. 错误信息和堆栈 #

像上面说的，任何类型的值都可以作为err\_msg，但是，通常err\_msg还是string类型的，说明发生了什么错误。当遇到了内部错误（例如试图索引一个非table值），Lua负责产生err\_msg；否则，err\_msg就是传递给error 函数的值。另外，Lua总是在错误发生的地方添加一些位置信息， 如下示例：

local status, err = pcall(function () a = "a"+1 end)
    print(err)

![1366300019_8265.PNG][]

local status, err = pcall(function () error("my error") end)
    print(err)

![1366300159_4716.PNG][]

位置信息指明了filename和line number。

*error* 函数有一个额外的参数level， 说明如何获取错误发生的位置。level默认为1，返回error 函数被调用的位置； level 为2， 返回调用*error* 函数的函数被调用的位置； level 为0，不获取位置信息。对比下下面三段代码的的区别和执行结果就明白了。

function foo(str)
        if type(str) ~= "string" then
            error("string expected", 0) --level 0
        end
        print("foo success")
    end
    
    local status, err = pcall(foo(3))
    print(err)

运行结果：

![1366301153_2368.PNG][]

function foo(str)
        if type(str) ~= "string" then
            error("string expected", 1) --level 1
        end
        print("foo success")
    end
    
    local status, err = pcall(foo(3))
    print(err)

运行结果：

![1366301194_4632.PNG][]

function foo(str)
        if type(str) ~= "string" then
            error("string expected", 2) --level 2
        end
        print("foo success")
    end
    
    local status, err = pcall(foo(3))
    print(err)

运行结果：

![1366301320_5887.PNG][]

err\_test03.lua, err\_test04.lua是我code文件的名字而已，可能每个人起名字都不同的。注意一下level 1 和level 2的错误行号是不同的。通过这3个例子，很明白了吧。

通常情况下，在程序出错的时候，可能仅仅知道错误发生的位置是不够的。至少，还需要函数的调用堆栈吧。但是当*pcall* 函数返回的时候，堆栈信息已被部分破坏了。因此，为了获取堆栈信息，必须在*pcall* 返回之前就建立它。Lua为我们提供了*xpcall* 函数， 它比*pcall* 函数多一个参数 *error handler function*。 一旦发生错误，Lua在堆栈被损坏之前调用这个*handler* 函数，在*handler* 中，我们可以用*debug* 库来收集尽可能的有关错误的信息。两个常用的*handler* 函数是*debug.debug* 和 *debug.traceback* ；具体用法，后续会详细讨论。

终于写完这篇了，关电脑睡觉去。

水平有限，如果有朋友发现错误，欢迎留言交流

[1366206267_9634.PNG]: https://img-my.csdn.net/uploads/201304/17/1366206267_9634.PNG
[1366206317_1906.PNG]: https://img-my.csdn.net/uploads/201304/17/1366206317_1906.PNG
[1366205266_8658.PNG]: https://img-my.csdn.net/uploads/201304/17/1366205266_8658.PNG
[1366206835_3719.PNG]: https://img-my.csdn.net/uploads/201304/17/1366206835_3719.PNG
[1366298797_8532.PNG]: https://img-my.csdn.net/uploads/201304/18/1366298797_8532.PNG
[1366300019_8265.PNG]: https://img-my.csdn.net/uploads/201304/18/1366300019_8265.PNG
[1366300159_4716.PNG]: https://img-my.csdn.net/uploads/201304/18/1366300159_4716.PNG
[1366301153_2368.PNG]: https://img-my.csdn.net/uploads/201304/19/1366301153_2368.PNG
[1366301194_4632.PNG]: https://img-my.csdn.net/uploads/201304/19/1366301194_4632.PNG
[1366301320_5887.PNG]: https://img-my.csdn.net/uploads/201304/19/1366301320_5887.PNG