前言
从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会用模块名来替换每个“？”，然后根据替换的结果来检查是否存在这样一个文件，如果不存在，就会尝试下一项。路径中的每一项都是以分号隔开，比如路径为以下字符串：
|
1
|
?;?.lua;c:windows?;/usr/local/lua/?/?.lua |
那么，当我们require “mod”时，就会尝试着打开以下文件：
|
1
2
3
4
|
mod mod.lua c:windowsmod /usr/local/lua/mod/mod.lua |
可以看到，require函数只处理了分号和问好，其它的都是由路径自己定义的。在实际编程中，require用于搜索的Lua文件的路径存放在变量package.path中，在我的电脑上，print(package.path)会输出以下内容：
|
1
|
;.?.lua;D:Lua5.1lua?.lua;D:Lua5.1lua?init.lua;D:Lua5.1?.lua;D:Lua5.1?init.lua;D:Lua5.1lua?.luac |
如果require无法找到与模块名相符的Lua文件，那Lua就会开始找C程序库；这个的搜索地址为package.cpath对应的地址，在我的电脑上，print(package.cpath)会输出以下值：
|
1
|
.?.dll;.?51.dll;D:Lua5.1?.dll;D:Lua5.1?51.dll;D:Lua5.1clibs?.dll;D:Lua5.1clibs?51.dll;D:Lua5.1loadall.dll;D:Lua5.1clibsloadall.dll |
当找到了这个文件以后，如果这个文件是一个Lua文件，它就通过loadfile来加载该文件；如果找到的是一个C程序库，就通过loadlib来加载。loadfile和loadlib都只是加载了代码，并没有运行它们，为了运行代码，require会以模块名作为参数来调用这些代码。如果lua文件和C程序库都找不到，怎么办？我们试一下，随便require一个东西，比如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
require "jellythink"lua: test.lua:1: module 'jellythink' not found: no field package.preload['jellythink'] no file '.jellythink.lua' no file 'D:Lua5.1luajellythink.lua' no file 'D:Lua5.1luajellythinkinit.lua' no file 'D:Lua5.1jellythink.lua' no file 'D:Lua5.1jellythinkinit.lua' no file 'D:Lua5.1luajellythink.luac' no file '.jellythink.dll' no file '.jellythink51.dll' no file 'D:Lua5.1jellythink.dll' no file 'D:Lua5.1jellythink51.dll' no file 'D:Lua5.1clibsjellythink.dll' no file 'D:Lua5.1clibsjellythink51.dll' no file 'D:Lua5.1loadall.dll' no file 'D:Lua5.1clibsloadall.dll' |
是的，会报错的。以上就是require的一般工作流程。
技巧
可以看到，上面总结的都是通过模块的名称来使用它们。但有的时候需要将一个模块改名，以避免名称冲突。比如有这样的场景，在测试中需要加载同一模块的不同版本，而获得版本之间的性能区别。那么我们如何加载同一模块的不同版本呢？对于一个Lua文件来说，我们可以很轻易的改掉它的名称，但是对于一个C程序库来说，我们是没有办法编辑其中的luaopen_*函数的名称的。为了这种重命名的需求，require用到了一个小的技巧：如果一个模块名中包含了连字符，require就会用连字符后的内容来创建luaopen_*函数名。比如：如果一个模块的名称为a-b，require就会认为它的open函数名为luaopen_b，并不是luaopen_a-b。现在好了，对于上面提出的不同版本进行测试的需求，就可以迎刃而解了。
写一个我们自己的模块
在Lua中创建一个模块最简单的方法是：创建一个table，并将所有需要导出的函数放入其中，最后返回这个table就可以了。相当于将导出的函数作为table的一个字段，在Lua中函数是第一类值，提供了天然的优势。来写一个我们自己的模块，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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类型的变量，通过这个局部的变量来定义和调用模块内的函数，然后将这个局部名称赋予模块的最终的名称，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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会将模块名作为参数传给模块。让我们来做个试验：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
local moduleName = ... -- 打印参数 for i = 1, select('#', ...) do print(select(i, ...)) end local M = {} -- 局部的变量 _G[moduleName] = 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。再写一个文件，代码如下：
|
1
2
3
4
5
6
7
|
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文件，打印结果如下：
|
1
2
|
test1 1 3 |
（PS：如果对代码中的三个点（…）不熟悉的同学，请参考：《Lua中的函数》）
经过这样的修改，我们就可以完全不用在模块中定义模块名称，如果需要重命名一个模块，只需要重命名定义它的文件就可以了。
细心的同学可能注意到了模块结尾处的return语句，这样的一个return语句，在定义模块时，是非常容易漏写的，怎么办？如果将所有与模块相关的设置任务都集中在模块开头，就会更好了。消除return语句的一种方法是，将模块table直接赋值给package.loaded，代码如下：
|
1
2
3
4
5
6
7
|
local moduleName = ... local M = {} -- 局部的变量 _G[moduleName] = M -- 将这个局部变量最终赋值给模块名 package.loaded[moduleName] = M -- 后续代码省略 |
示例代码下载：
Demo.zip
package.loaded是什么？
require会将返回值存储到table package.loaded中；如果加载器没有返回值，require就会返回table package.loaded中的值。可以看到，我们上面的代码中，模块没有返回值，而是直接将模块名赋值给table package.loaded了。这说明什么，package.loaded这个table中保存了已经加载的所有模块。现在我们就可以看看require到底是如何加载的呢？
-
先判断package.loaded这个table中有没有对应模块的信息；
-
如果有，就直接返回对应的模块，不再进行第二次加载；
-
如果没有，就加载，返回加载后的模块。
再说“环境”
大家可能注意到了，当我访问同一个模块中的其它函数时，都需要限定名称，就比如上面代码中的M。当我把模块内部的一个local函数由私有改变成公有以后，相应的调用local函数的地方都需要修改，加上限定名称。怎么办？总不能每次都修改代码吧。如何一次搞定？《Lua中的环境概念》里面讲到的环境概念在这里就能派上用场。
我们可以让模块的主程序块有一个独占的环境，这样不仅它的所有函数都可共享这个table，而且它的所有全局变量也都记录在这个table中，还可以将所有公有函数声明为全局变量，这样它们就都自动地记录在一个独立的table中。而模块所要做的就是将这个table赋予模块名和package.loaded。比如以下代码就可以完成：
|
1
2
3
4
5
6
7
|
local moduleName = ... local M = {} -- 局部的变量 _G[moduleName] = M -- 将这个局部变量最终赋值给模块名 package.loaded[moduleName] = M setfenv(1, M) |
这之后，当我们写下下面的代码：
|
1
2
3
|
function add(c1, c2) return new(c1.r + c2.r, c1.i + c2.i) end |
它其实是和下面的代码是等价的：
|
1
2
3
|
function M.add(c1, c2) return M.new(c1.r + c2.r, c1.i + c2.i) end |
当我调用同一个模块中的函数new时，也不用指定M了。这样就可以让我们在写自己的模块时，省去了前缀；还有其它好处，你可以自己想想。但是，当我们调用setfenv之后，将一个空table M作为环境后，就无法访问前一个环境中全局变量了。这该如何是好？现在提供几种方法。
方法一：
最简单的方法就是在《Lua中的环境概念》一文中说的那样，使用元表，设置__index，模拟继承来实现。代码如下：
|
1
2
3
4
5
6
7
8
9
|
local moduleName = ... local M = {} -- 局部的变量 _G[moduleName] = M -- 将这个局部变量最终赋值给模块名 package.loaded[moduleName] = M setmetatable(M, {__index = _G}) setfenv(1, M) |
上述代码很简单，原理在之前的博文中都详细的讲过了，这里不再啰嗦了。由于需要设置元表，所有会有一定的开销，但是可以忽略的。
方法二：
这样在自己的模块中保存一个全局的环境变量，当我们访问前一个环境中的变量时，就需要添加前缀_G，貌似有点小麻烦。但是，由于没有涉及到元方法，这种方法会比方法一略快。
|
1
2
3
4
5
6
7
8
9
|
local moduleName = ... local M = {} -- 局部的变量 _G[moduleName] = M -- 将这个局部变量最终赋值给模块名 package.loaded[moduleName] = M local _G = _G -- 保存了全局的环境变量 setfenv(1, M) |
方法三：
这种方法是最正规的方法，就是将那些需要用到的函数或模块声明为局部变量，看以下代码：
|
1
2
3
4
5
6
7
8
9
10
|
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函数
大家可能也注意到了，在定义一个模块时，前面的几句代码都是一样的，就分为以下几步：
-
从require传入的参数中获取模块名；
-
建立一个空table；
-
在全局环境_G中添加模块名对应的字段，将空table赋值给这个字段；
-
在已经加载table中设置该模块；
-
设置环境变量。
就是这几步，在每一个模块的定义之前都需要加上，是不是有点麻烦，在Lua5.1中提供了一个新函数module，它包括了以上这些步骤完成的功能。在编写一个模块时，可以直接用以下代码来取代前面的设置代码：
|
1
|
module(...) |
就上面这一小句代码，它会创建一个新的table，并将其赋予给模块名对应的全局字段和loaded table，最后还会将这个table设为主程序块的环境。默认的情况下，module不提供外部的访问的，也就是说，你无法访问前一个环境了，在再说“环境”一节，我专门说了三种解决方案。在使用module时是这样解决的：
|
1
|
module(..., package.seeall) |
这句话的功能就好比之前的功能再加上了setmetatable(M, {__index = _G})。有了这一句代码，基本上就可以说万事不愁了。
子模块与包
Lua支持具有层级性的模块名，可以用一个点来分隔名称中的层级。假设一个模块名为mod.sub，那么它就是mod的一个子模块。因此，可以认为模块mod.sub会将其所有值都定义在table mod.sub中，也就是一个存储在table mod中，且key为sub的table。就好比下述的定义：
|
1
|
local mod = {sub = {}} |
当require一个模块mod.sub时，require会用原始的模块名“mod.sub”作为key来查询table package.loaded和package.preload，其中，模块名中的点在搜索时没有任何意义。但是，当搜索一个定义子模块的文件时，require会将点转换成另一个字符，通常就是系统的目录分隔符，转换之后require就像搜索其他名称一样来搜索这个名称。比如路径为以下字符串：
|
1
|
?;?.lua;c:windows?;/usr/local/lua/?/?.lua |
那么，当我们require “mod.sub”时，就会尝试着打开以下文件：
|
1
2
3
4
|
modsub modsub.lua c:windowsmodsub /usr/local/lua/mod/mod/sub.lua |
通过这样的加载策略，就可以将一个包中的所有模块组织到一个目录中。像这些小的功能，都会组合成很多的技巧，虽然在实际项目中用的不会很多，但是玩起来还是很有意思的。
总结
这一篇文章主要总结了Lua中的两个非常重要的函数require和module。希望对大家有用。对于今天的开发来说，什么都讲究模块开发，而这篇文章总结的就是进行模块开发时需要使用的两个重要函数。大家在日后构建自己的模块时，如果有哪里不懂，哪里不清楚，可以再回过头来阅读这篇文章，或者可以直接留言和我交流。我相信，分享与交流使我们更进步。