Lua 模块与包

Les modules sont similaires à des bibliothèques encapsulées, en Lua 5.1 Début, Lua a intégré un mécanisme de gestion de modules standard, permettant de placer un certain code公用 dans un fichier, qui peut être appelé à l'extérieur sous forme d'API, ce qui est favorable à la réutilisation du code et à la réduction de la complexité des codes.

Lua a intégré un mécanisme de gestion de modules standard, permettant de placer un certain code公用 dans un fichier, qui peut être appelé à l'extérieur sous forme d'API, ce qui est favorable à la réutilisation du code et à la réduction de la complexité des codes.

--　Nom de fichier module.lua
--　Définir un module nommé module
module = {}
　
--　Définir une constante
module.constant = "C'est une constante"
　
--　Définir une fonction
function module.func1()
　　　　io.write("C'est une fonction publique !\n")
end
　
local function func2()
　　　　print("C'est une fonction privée !")
end
　
function module.func3()
　　　　func2()
end
　
return module

Comme mentionné précédemment, la structure du module est une structure de tableau, donc vous pouvez manipuler les constantes ou les fonctions du module de la même manière que vous manipulez les éléments d'un tableau.

La fonction func ci-dessus2 Les variables locales déclarées dans un bloc de programme représentent une fonction privée, donc elles ne peuvent pas être accédées depuis l'extérieur. Il faut appeler cette fonction privée à l'intérieur de la fonction publique du module.

fonction require

Lua fournit une fonction nommée require pour charger des modules. Pour charger un module, il suffit de l'appeler simplement. Par exemple :

require("<nom_de_module>")

ou

require "<nom_de_module>"

Après l'exécution de require, il retourne un tableau composé de constantes ou de fonctions du module, et définit également une variable globale contenant ce tableau.

Le résultat de l'exécution du code suivant est :

C'est une constante
C'est une fonction privée !

ou définissez un alias variable pour le module chargé pour faciliter l'appel :

Le résultat de l'exécution du code suivant est :

C'est une constante
C'est une fonction privée !

Mécanisme de chargement

Pour les modules personnalisés, le fichier du module ne peut pas être placé dans n'importe quel répertoire de fichiers. La fonction require a sa propre stratégie de chargement de chemins de fichiers, qui essaie de charger le module à partir de fichiers Lua ou de bibliothèques de programmes C.

require est utilisé pour rechercher les chemins de fichiers des fichiers Lua et est stocké dans la variable globale package.path. Lorsque Lua démarre, cette variable d'environnement est initialisée avec la valeur de l'environnement variable LUA_PATH. Si cette variable d'environnement n'est pas trouvée, une valeur par défaut définie à la compilation est utilisée pour l'initialiser.

Bien sûr, si l'environnement variable LUA_PATH n'existe pas, vous pouvez également le configurer manuellement. Ouvrez le fichier .profile dans le répertoire racine de l'utilisateur actuel (créez-le s'il n'existe pas, ou ouvrez le fichier .bashrc), par exemple, ajoutez "~/lua/" Ajoutez ce chemin à la variable d'environnement LUA_PATH :

#LUA_PATH
export LUA_PATH="~/lua/?.lua;;"

Les chemins de fichiers sont séparés par des ";", et le dernier 2 Un ";;" signifie que le chemin ajouté est suivi du chemin par défaut original.

Ensuite, mettez à jour les paramètres des variables d'environnement pour qu'ils prennent effet immédiatement.

source ~/.profile

À ce moment-là, supposons que la valeur de package.path soit la suivante :

/Users/dengjoe/lua/?.lua;/?.lua;/usr/local/share/lua/5.1/?.lua;/usr/local/share/lua/5.1/?/init.lua;/usr/local/lib/lua/5.1/?.lua;/usr/local/lib/lua/5.1/?/init.lua

Alors, lors de l'appel de require("module"), il essaiera d'ouvrir les répertoires de fichiers suivants pour rechercher le fichier cible.

/Users/dengjoe/lua/module.lua;
./module.lua
/usr/local/share/lua/5.1/module.lua
/usr/local/share/lua/5.1/module/init.lua
/usr/local/lib/lua/5.1/module.lua
/usr/local/lib/lua/5.1/module/init.lua

Si le fichier cible a été trouvé, package.loadfile est appelé pour charger le module. Sinon, la recherche se poursuit dans les bibliothèques de programmes C.

Le chemin d'accès aux fichiers de recherche est obtenu à partir de la variable globale package.cpath, qui est initialisée par l'environnement variable LUA_CPATH.

La stratégie de recherche est la même que celle précédente, mais maintenant, la recherche s'effectue sur des fichiers de type so ou dll. Si le fichier est trouvé, require chargera le fichier via package.loadlib.

C 包

Lua 和 C 很容易结合，使用 C 为 Lua 写包。

与 Lua 中写包不同，C 包在使用之前必须首先加载并连接，在大多数系统中最容易的实现方式是通过动态连接库机制。

Lua 在一个叫 loadlib 的函数内提供了所有的动态连接的功能。这个函数有两个参数：库的绝对路径和初始化函数。所以典型的调用实例如下：

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

loadlib 函数加载指定的库并且连接到 Lua，然而它并不打开库（也就是说没有调用初始化函数），反之它返回初始化函数作为 Lua 的一个函数，这样我们就可以直接在 Lua 中调用它。

如果加载动态库或者查找初始化函数时出错，loadlib 将返回 nil 和错误信息。我们可以修改前面一段代码，使其检测错误然后调用初始化函数：

local path = "/usr/local/lua/lib/libluasocket.so
--　或者 path = "C:\\windows\\luasocket.dll"，这是 Window 平台下
local f = assert(loadlib(path, "luaopen_socket"))
f()　　--　真正打开库

一般情况下我们期望二进制的发布库包含一个与前面代码段相似的 stub 文件，安装二进制库的时候可以随意放置在某个目录，只需要修改 stub 文件对应二进制库的实际路径即可。

将 stub 文件所在的目录添加到 LUA_PATH，这样设置后就可以使用 require 函数加载 C 库了。