首页 > 代码库 > LUA的编译、环境等

LUA的编译、环境等

Lua命令行

lua命令行选项:

-i:进入交互式

-e:执行lua代码

-l:加载库文件

 

例如使用下面的命令启动lua解释器,可以重新定义lua提示符。

 


lua -i -e "_PROMPT=‘ try>‘"

 

 

在交互模式下,如果要打印任何表达式的值,可以用等号开头,并跟随一个表达式,例如:

> a="hello" .. "world"
> =a
helloworld
> =math.sin(180)
-0.80115263573383
> 

 

 

lua解释器执行其参数前,会先查找一个名为LUA_INIT的环境变量:

如果找到这个变量,并且其内容为“@filename”,那么解释器会先执行这个文件; 如果LUA_INIT不是以@开头,则作为Lua代码执行。

如下面的示例,将LUA_INIT定义为"@a.lua",然后启动lua解释器,自动加载了a.lua文件。

 

技术分享
root@chenqi-PC:/home/chenqi/studio/test# cat a.lua 
#!/usr/bin/lua

print("hello world")

root@chenqi-PC:/home/chenqi/studio/test# export LUA_INIT="@a.lua"
root@chenqi-PC:/home/chenqi/studio/test# lua
hello world
Lua 5.2.2  Copyright (C) 1994-2013 Lua.org, PUC-Rio
> 
技术分享

 

 

解释器在运行脚本前,会用所有的命令行参数创建一个名为arg的table,例如test.lua源文件内容如下,

for i,v in pairs(arg) do
    print(string.format("arg[%d]=%s", i,v))
end

执行后,打印出所有的参数:

技术分享
root@chenqi-PC:/home/chenqi/studio/test# lua -e "sin=math.sin" test.lua a b
arg[1]=a
arg[2]=b
arg[-1]=sin=math.sin
arg[-3]=lua
arg[-2]=-e
arg[0]=test.lua
技术分享

 


 

环境 

Lua执行的每段代码,例如一个源文件,或在交互模式中输入的一行代码,都称为一个chunk。

一个chunk可以简单到只包含一条语句,也可以由若干条不同的语句及函数定义构成。

 

Lua中定义的变量默认都是全局变量,要删除一个全局变量,只需将其赋值为nil。

a=10
print(a)        --> 10
a=nil
print(a)        --> nil

可以使用关键字local声明局部变量,局部变量的作用域仅限于声明它们的那个block,

一个block可以是一个控制结构的执行体,或者是一个函数的执行体,或者是一个chunk。

一个例子:

技术分享
local x=0 

for i=1,4 do
    local x=i+1
    print(x)    --> 2,3,4,5
end

print(i)  --> nil
print(x)  --> 0
技术分享

刚才提到,在交互模式下,每一行代码都是一个chunk,例如:

技术分享
> a=3
> =a
3
> local b=3
> =b
nil
> 
技术分享

上面的例子中,局部变量b在下一行代码(一个新的chunk)中就消失了。

注意:local同样也可以用来修饰函数,从而定义一个局部函数。

 

lua中应该尽可能使用局部变量,可以避免将一些无用的名称引入全局环境(global environment);

此外,访问局部变量比访问全局变量更快,Lua的全局变量是放在一个table中的,即_G,例如:

chenqi = 12
local cq = 21

print(_G[‘chenqi‘]) -- 12
print(_G[‘cq‘])     -- nil

最后,一个局部变量通常会随着作用域的结束而消失,这样垃圾收集器可以及时释放内存。

 

在lua中,有一种习惯的写法是:

local foo=foo

这句代码的意义是创建局部变量foo,并用全局变量foo的值对它初始化,如果后续其它函数改变了全局foo的值,那么这里可以先将它的值保存起来。

这种写法的另一个作用就是加速在当前作用域中对foo的访问。

 

全局变量

访问具有动态名字的全局变量:

技术分享
_G[‘company‘] = {name=‘sina‘ }

function getfield(f)
    local v = _G
    for w in string.gmatch(f, "[%w_]+") do
        v = v[w]
    end
    return v
end 

print(_G[‘company.name‘])           -- nil
print(getfield(‘company.name‘))     -- sina 
技术分享

 

 

 


 

编译

loadfile

local func = loadfile("mode_name")

func()

loadfile 函数会将代码编译成中间码,并且将编译后的chunk作为一个函数返回,而不执行代码。

另外,loadfile不会抛出错误信息,而是返回错误码。

 

loadstring

loadstring 函数与loadfile类似,不过它不是从文件里读入chunk,而是从一个字符串中读入,例如:

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

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

Lua把每一个chunk都作为一个匿名函数处理,并且该匿名函数还具有可变长实参。例如:

loadstring("a=1")返回的结果等价于表达式:function(...) a=1 end

 

loadfile和loadstring都是编译代码,然后将编译结果作为一个函数返回。
loadfile和loadstring都不会引发错误,只是返回nil和错误消息:

print(loadstring("i i "))
-- nil     [string "i i "]:1: ‘=‘ expected near ‘i‘

 

 loadstring总是在全局环境中编译它的字符串,如下面的例子中,函数g操作了局部的i,函数f操作的却是全局的i。

技术分享
i = 32
local i = 0

f = loadstring("i=i+1; print(i)")
g = function() i=i+1; print(i) end

f()     -- 33
g()     -- 1
技术分享

 

loadstring常用于执行外部代码,例如:

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

 

dofile

dofile("model_name.lua")

dofile 函数读入文件、编译,然后执行,它实际上是对loadfile的封装:

技术分享
function dofile(filename)

    local f = assert(loadfile(filename))

    return f()

end
技术分享

  

 

动态链接

Lua支持加载动态链接库,如下

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

如果在加载库时发生错误,loadlib返回nil及一条错误消息。

loadlib是一个非常底层的函数,必须提供库的完整路径及正确的函数名。通常使用require来加载C程序块,这个函数库会搜索指定的库,然后用loadlib来加载库,并返回初始化函数,这个初始化函数应将库中提供的函数注册到Lua中。

require

require("model_name")

require 函数载入model_name.lua文件,载入的同时直接执行该文件,注意:只有第一次载入的时候会去执行。

与dofile不同的是,require提供了2个功能:

1、搜索目录加载文件;

2、判断文件是否已加载,避免重复加载。

 

 

指定搜索lua模块的路径:

package.path = ‘/usr/local/share/lua/5.1/?.lua;/home/resty/?.lua;‘ 

 

指定搜索so模块的路径:

package.cpath = ‘/usr/local/lib/lua/5.1/?.so;‘

 

 

 


 

 错误与异常处理

Lua所遇到的任何未预期条件都会引发一个错误。例如,当试图将两个非数字的值相加、索引一个不是table的值,等。
Lua也可以通过调用error函数显式地引发一个错误,例如:

local n = ‘a‘
if not n then error("invalid n") end

n = nil
assert(n, "invalid n")

assert函数的作用是判断第一个参数是否true,如果不是则自动调用error函数引发错误。

error用来抛出异常,而捕获异常需要使用pcall函数。

pcall函数以一种“保护模式”来调用它的第一个参数,因此pcall可以捕获函数执行中的任何错误。
如果没有发生错误,pcall会返回true及函数调用的返回值;否则,返回false及错误消息。

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

local status, ret = pcall(function() return ‘ok‘ end)
print(status, ret)     -- true ok

注意:这里error函数的参数可以是任意类型,而不仅仅是字符串。

 

error函数的第一个参数用于表达错误消息,事实上,它还有第二个参数,用于指出应由调用层级中的哪个层(level)来报告当前的错误,也就是说明谁应该为错误负责。

技术分享
function foo(str)
    if type ~= "string" then 
        error("string expected", 2)
    end 

    print(str)
end

foo(12)
技术分享

输出错误信息:

/usr/local/bin/lua: ./test.lua:13: string expected
stack traceback:
        [C]: in function ‘error‘
        ./test.lua:7: in function ‘foo‘
        ./test.lua:13: in main chunk
        [C]: ?

 

LUA的编译、环境等