Lua中的模块(module)和包(package)详解

前言

从lua5.1版本开始，就对模块和包添加了新的支持，可是使用require和module来定义和使用模块和包。require用于使用模块，module用于创建模块。简单的说，一个模块就是一个程序库，可以通过require来加载。然后便得到了一个全局变量，表示一个table。这个table就像是一个命名空间，其内容就是模块中导出的所有东西，比如函数和常量，一个符合规范的模块还应使require返回这个table。现在就来具体的总结一下require和module这两个函数。

require函数

lua提供了一个名为require的函数用来加载模块。要加载一个模块，只需要简单地调用require “<模块名>”就可以了。这个调用会返回一个由模块函数组成的table，并且还会定义一个包含该table的全局变量。但是，这些行为都是由模块完成的，而非require。所以，有些模块会选择返回其它值，或者具有其它的效果。那么require到底是如何加载模块的呢？

首先，要加载一个模块，就必须的知道这个模块在哪里。知道了这个模块在哪里以后，才能进行正确的加载。当我们写下require “mod”这样的代码以后，lua是如何找这个mod的呢？这里面就有说道了，我这里就详细的说一说。

在搜索一个文件时，在windows上，很多都是根据windows的环境变量path来搜索，而require所使用的路径与传统的路径不同，require采用的路径是一连串的模式，其中每项都是一种将模块名转换为文件名的方式。require会用模块名来替换每个“？”，然后根据替换的结果来检查是否存在这样一个文件，如果不存在，就会尝试下一项。路径中的每一项都是以分号隔开，比如路径为以下字符串：

?;?.lua;c:\windows\?;/usr/local/lua/?/?.lua

那么，当我们require “mod”时，就会尝试着打开以下文件：

mod
mod.lua
c:\windows\mod
/usr/local/lua/mod/mod.lua

可以看到，require函数只处理了分号和问好，其它的都是由路径自己定义的。在实际编程中，require用于搜索的lua文件的路径存放在变量package.path中，在我的电脑上，print(package.path)会输出以下内容：

;.\?.lua;d:\lua\5.1\lua\?.lua;d:\lua\5.1\lua\?\init.lua;d:\lua\5.1\?.lua;d:\lua\5.1\?\init.lua;d:\lua\5.1\lua\?.luac

如果require无法找到与模块名相符的lua文件，那lua就会开始找c程序库；这个的搜索地址为package.cpath对应的地址，在我的电脑上，print(package.cpath)会输出以下值：

.\?.dll;.\?51.dll;d:\lua\5.1\?.dll;d:\lua\5.1\?51.dll;d:\lua\5.1\clibs\?.dll;d:\lua\5.1\clibs\?51.dll;d:\lua\5.1\loadall.dll;d:\lua\5.1\clibs\loadall.dll

当找到了这个文件以后，如果这个文件是一个lua文件，它就通过loadfile来加载该文件；如果找到的是一个c程序库，就通过loadlib来加载。loadfile和loadlib都只是加载了代码，并没有运行它们，为了运行代码，require会以模块名作为参数来调用这些代码。如果lua文件和c程序库都找不到，怎么办？我们试一下，随便require一个东西，比如：

require "jellythink"
lua: test.lua:1: module 'jellythink' not found:
     no field package.preload['jellythink']
     no file '.\jellythink.lua'
     no file 'd:\lua\5.1\lua\jellythink.lua'
     no file 'd:\lua\5.1\lua\jellythink\init.lua'
     no file 'd:\lua\5.1\jellythink.lua'
     no file 'd:\lua\5.1\jellythink\init.lua'
     no file 'd:\lua\5.1\lua\jellythink.luac'
     no file '.\jellythink.dll'
     no file '.\jellythink51.dll'
     no file 'd:\lua\5.1\jellythink.dll'
     no file 'd:\lua\5.1\jellythink51.dll'
     no file 'd:\lua\5.1\clibs\jellythink.dll'
     no file 'd:\lua\5.1\clibs\jellythink51.dll'
     no file 'd:\lua\5.1\loadall.dll'
     no file 'd:\lua\5.1\clibs\loadall.dll'

是的，会报错的。以上就是require的一般工作流程。

奇淫技巧

可以看到，上面总结的都是通过模块的名称来使用它们。但有的时候需要将一个模块改名，以避免名称冲突。比如有这样的场景，在测试中需要加载同一模块的不同版本，而获得版本之间的性能区别。那么我们如何加载同一模块的不同版本呢？对于一个lua文件来说，我们可以很轻易的改掉它的名称，但是对于一个c程序库来说，我们是没有办法编辑其中的luaopen_*函数的名称的。为了这种重命名的需求，require用到了一个小的技巧：如果一个模块名中包含了连字符，require就会用连字符后的内容来创建luaopen_*函数名。比如：如果一个模块的名称为a-b，require就会认为它的open函数名为luaopen_b，并不是luaopen_a-b。现在好了，对于上面提出的不同版本进行测试的需求，就可以迎刃而解了。

写一个我们自己的模块

在lua中创建一个模块最简单的方法是：创建一个table，并将所有需要导出的函数放入其中，最后返回这个table就可以了。相当于将导出的函数作为table的一个字段，在lua中函数是第一类值，提供了天然的优势。来写一个我们自己的模块，代码如下：

complex = {}    -- 全局的变量，模块名称
 
function complex.new(r, i) return {r = r, i = i} end
 
-- 定义一个常量i
complex.i = complex.new(0, 1)
 
function complex.add(c1, c2)
    return complex.new(c1.r + c2.r, c1.i + c2.i)
end
 
function complex.sub(c1, c2)
    return complex.new(c1.r - c2.r, c1.i - c2.i)
end
 
return complex  -- 返回模块的table

上面就是一个最简单的模块。在编写代码的过程中，会发现必须显式地将模块名放到每个函数定义中；而且，一个函数在调用同一个模块中的另一个函数时，必须限定被调用函数的名称，然而我们可以稍作变通，在模块中定义一个局部的table类型的变量，通过这个局部的变量来定义和调用模块内的函数，然后将这个局部名称赋予模块的最终的名称，代码如下：

local m = {}    -- 局部的变量
complex = m     -- 将这个局部变量最终赋值给模块名
 
function m.new(r, i) return {r = r, i = i} end
 
-- 定义一个常量i
m.i = m.new(0, 1)
 
function m.add(c1, c2)
    return m.new(c1.r + c2.r, c1.i + c2.i)
end
 
function m.sub(c1, c2)
    return m.new(c1.r - c2.r, c1.i - c2.i)
end
 
return complex  -- 返回模块的table

这样，我们在模块内部其实使用的是一个局部的变量。这样看起来比较简单粗暴，但是每个函数仍需要一个前缀。实际上，我们可以完全避免写模块名，因为require会将模块名作为参数传给模块。让我们来做个试验：

local modulename = ...
 
-- 打印参数
for i = 1, select('#', ...) do
     print(select(i, ...))
end
 
local m = {}    -- 局部的变量
_g[modulename] = m     -- 将这个局部变量最终赋值给模块名
complex = m
 
function m.new(r, i) return {r = r, i = i} end
 
-- 定义一个常量i
m.i = m.new(0, 1)
 
function m.add(c1, c2)
    return m.new(c1.r + c2.r, c1.i + c2.i)
end
 
function m.sub(c1, c2)
    return m.new(c1.r - c2.r, c1.i - c2.i)
end
 
return complex  -- 返回模块的table

将上述代码保存为test1.lua。再写一个文件，代码如下：

require "test"
 
c1 = test.new(0, 1)
c2 = test.new(1, 2)
 
ret = test.add(c1, c2)
print(ret.r, ret.i)

将上述代码保存为test2.lua

将上述代码放在同一个文件夹下，运行test2.lua文件，打印结果如下：

test1
1     3

（ps：如果对代码中的三个点（…）不熟悉的同学，请参考：《lua中的函数》一文）经过这样的修改，我们就可以完全不用在模块中定义模块名称，如果需要重命名一个模块，只需要重命名定义它的文件就可以了。

细心的同学可能注意到了模块结尾处的return语句，这样的一个return语句，在定义模块时，是非常容易漏写的，怎么办？如果将所有与模块相关的设置任务都集中在模块开头，就会更好了。消除return语句的一种方法是，将模块table直接赋值给package.loaded，代码如下：

local modulename = ...
 
local m = {}    -- 局部的变量
_g[modulename] = m     -- 将这个局部变量最终赋值给模块名
 
package.loaded[modulename] = m
-- 后续代码省略

示例代码下载：点击这里下载

package.loaded是什么？

require会将返回值存储到table package.loaded中；如果加载器没有返回值，require就会返回table package.loaded中的值。可以看到，我们上面的代码中，模块没有返回值，而是直接将模块名赋值给table package.loaded了。这说明什么，package.loaded这个table中保存了已经加载的所有模块。现在我们就可以看看require到底是如何加载的呢？

1.先判断package.loaded这个table中有没有对应模块的信息；
2.如果有，就直接返回对应的模块，不再进行第二次加载；
3.如果没有，就加载，返回加载后的模块。

再说“环境”

大家可能注意到了，当我访问同一个模块中的其它函数时，都需要限定名称，就比如上面代码中的m。当我把模块内部的一个local函数由私有改变成公有以后，相应的调用local函数的地方都需要修改，加上限定名称。怎么办？总不能每次都修改代码吧。如何一次搞定？是否还记得《lua中的环境概念》这篇博文，里面讲到的环境概念在这里就能派上用场。

我们可以让模块的主程序块有一个独占的环境，这样不仅它的所有函数都可共享这个table，而且它的所有全局变量也都记录在这个table中，还可以将所有公有函数声明为全局变量，这样它们就都自动地记录在一个独立的table中。而模块所要做的就是将这个table赋予模块名和package.loaded。比如以下代码就可以完成：

local modulename = ...
 
local m = {}    -- 局部的变量
_g[modulename] = m     -- 将这个局部变量最终赋值给模块名
 
package.loaded[modulename] = m
setfenv(1, m)

这之后，当我们写下下面的代码：

function add(c1, c2)
    return new(c1.r + c2.r, c1.i + c2.i)
end

它其实是和下面的代码是等价的：

function m.add(c1, c2)
    return m.new(c1.r + c2.r, c1.i + c2.i)
end

当我调用同一个模块中的函数new时，也不用指定m了。这样就可以让我们在写自己的模块时，省去了前缀；还有其它好处，你可以自己想想。但是，当我们调用setfenv之后，将一个空table m作为环境后，就无法访问前一个环境中全局变量了。这该如何是好？现在提供几种方法。

方法一：

最简单的方法就是在《lua中的环境概念》一文中说的那样，使用元表，设置__index，模拟继承来实现。代码如下：

local modulename = ...
 
local m = {}    -- 局部的变量
_g[modulename] = m     -- 将这个局部变量最终赋值给模块名
 
package.loaded[modulename] = m
 
setmetatable(m, {__index = _g})
setfenv(1, m)

上述代码很简单，原理在之前的博文中都详细的讲过了，这里不再啰嗦了。由于需要设置元表，所有会有一定的开销，但是可以忽略的。

方法二：

local modulename = ...
 
local m = {}    -- 局部的变量
_g[modulename] = m     -- 将这个局部变量最终赋值给模块名
 
package.loaded[modulename] = m
 
local _g = _g -- 保存了全局的环境变量
setfenv(1, m)

这样在自己的模块中保存一个全局的环境变量，当我们访问前一个环境中的变量时，就需要添加前缀_g，貌似有点小麻烦。但是，由于没有涉及到元方法，这种方法会比方法一略快。

方法三：

这种方法是最正规的方法，就是将那些需要用到的函数或模块声明为局部变量，看以下代码：

local modulename = ...
 
local m = {}    -- 局部的变量
_g[modulename] = m     -- 将这个局部变量最终赋值给模块名
 
package.loaded[modulename] = m
 
local sqrt = math.sqrt -- 在我们自己的模块中需要用到math.sqrt这个函数，所以就先保存下来
local io = io -- 需要用到io库，也保存下来
setfenv(1, m) -- 设置完成以后，就不能再使用_g table中的内容了

方法三需要做的工作是最多的，而且也是最麻烦的，但是性能是最好的。怎么用，你自己看着办吧。

module函数

大家可能也注意到了，在定义一个模块时，前面的几句代码都是一样的，就分为以下几步：

1.从require传入的参数中获取模块名；
2.建立一个空table；
3.在全局环境_g中添加模块名对应的字段，将空table赋值给这个字段；
4.在已经加载table中设置该模块；
5.设置环境变量。

就是这几步，在每一个模块的定义之前都需要加上，是不是有点麻烦，在lua5.1中提供了一个新函数module，它包括了以上这些步骤完成的功能。在编写一个模块时，可以直接用以下代码来取代前面的设置代码：

module(...)

就上面这一小句代码，它会创建一个新的table，并将其赋予给模块名对应的全局字段和loaded table，最后还会将这个table设为主程序块的环境。默认的情况下，module不提供外部的访问的，也就是说，你无法访问前一个环境了，在再说“环境”一节，我专门说了三种解决方案。在使用module时是这样解决的：

module(..., package.seeall)

这句话的功能就好比之前的功能再加上了setmetatable(m, {__index = _g})。有了这一句代码，基本上就可以说万事不愁了。

子模块与包

lua支持具有层级性的模块名，可以用一个点来分隔名称中的层级。假设一个模块名为mod.sub，那么它就是mod的一个子模块。因此，可以认为模块mod.sub会将其所有值都定义在table mod.sub中，也就是一个存储在table mod中，且key为sub的table。就好比下述的定义：

local mod = {sub = {}}

当require一个模块mod.sub时，require会用原始的模块名“mod.sub”作为key来查询table package.loaded和package.preload，其中，模块名中的点在搜索时没有任何意义。但是，当搜索一个定义子模块的文件时，require会将点转换成另一个字符，通常就是系统的目录分隔符，转换之后require就像搜索其他名称一样来搜索这个名称。比如路径为以下字符串：

?;?.lua;c:\windows\?;/usr/local/lua/?/?.lua

那么，当我们require “mod.sub”时，就会尝试着打开以下文件：

mod\sub
mod\sub.lua
c:\windows\mod\sub
/usr/local/lua/mod/mod/sub.lua

通过这样的加载策略，就可以将一个包中的所有模块组织到一个目录中。像这些小的功能，都会组合成很多的奇淫技巧，虽然在实际项目中用的不会很多，但是玩起来还是很有意思的。

总结

这一篇文章主要总结了lua中的两个非常重要的函数require和module。希望对大家有用。对于今天的开发来说，什么都讲究模块开发，而这篇文章总结的就是进行模块开发时需要使用的两个重要函数。大家在日后构建自己的模块时，如果有哪里不懂，哪里不清楚，可以再回过头来阅读这篇文章，或者可以直接留言和我交流。我相信，分享与交流使我们更进步。