Lua模块与包

Un módulo es similar a una biblioteca encapsulada, desde Lua 5.1 Comenzando, Lua ha añadido un mecanismo de gestión de módulos estándar, que permite poner algunos códigos comunes en un archivo y llamarlos en otras partes como una interfaz de API, lo que facilita el reuso del código y reduce la耦合 del código.

Lua ha añadido un mecanismo de gestión de módulos estándar, que permite poner algunos códigos comunes en un archivo y llamarlos en otras partes como una interfaz de API, lo que facilita el reuso del código y reduce la耦合 del código.

--　El nombre del archivo es module.lua
--　Definir un módulo llamado module
module = {}
　
--　Definir una constante
module.constant = "¡Esta es una constante"
　
--　Definir una función
function module.func1()
　　　　io.write("¡Esta es una función pública!\n")
end
　
local function func2()
　　　　print("¡Esta es una función privada!")
end
　
function module.func3()
　　　　func2()
end
　
return module

Como se puede ver, la estructura del módulo es una estructura de tabla, por lo que se puede operar con las constantes o funciones del módulo de la misma manera que se operan con los elementos de la tabla.

La func2 Las variables locales declaradas en un bloque de programa representan una función privada, por lo que no se puede acceder a esta función privada del módulo desde el exterior; debe llamarse a través de las funciones públicas del módulo.

función require

Lua proporciona una función llamada require para cargar módulos. Para cargar un módulo, simplemente hay que llamarlo. Por ejemplo:

require("<nombre_módulo>")

o

require "<nombre_módulo>"

Después de ejecutar require, se devuelve una tabla que contiene constantes o funciones del módulo, y también se define una variable global que contiene esta tabla.

El resultado de la ejecución del código anterior es:

Esta es una constante
¡Esta es una función privada!

o defina un alias de variable para el módulo cargado para facilitar la llamada:

El resultado de la ejecución del código anterior es:

Esta es una constante
¡Esta es una función privada!

Mecanismo de carga

Para los módulos personalizados, los archivos de módulo no pueden estar en cualquier directorio de archivos, la función require tiene su propia estrategia de carga de rutas de archivos, que intentará cargar el módulo desde archivos Lua o bibliotecas de programas C.

La variable global package.path almacena las rutas de búsqueda para los archivos Lua que require utiliza para buscar archivos. Cuando Lua se inicia, inicializa esta variable de entorno con el valor de la variable de entorno LUA_PATH. Si no se encuentra esta variable de entorno, se inicializa con una ruta por defecto definida en la compilación.

Por supuesto, si no hay la variable de entorno LUA_PATH, también se puede configurar de manera personalizada, abra el archivo .profile en el directorio raíz del usuario actual (si no existe, créalo, también puede abrir el archivo .bashrc), por ejemplo, agregue "~/lua/" Añada la ruta a la variable de entorno LUA_PATH:

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

Las rutas de archivos se separan por el símbolo ";", y la última 2 Un ";;" significa que se agrega la ruta nueva después de la ruta por defecto.

Luego, actualice los parámetros de la variable de entorno para que surtan efecto inmediatamente.

source ~/.profile

En este momento, supongamos que el valor de package.path es:

/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

Entonces, al llamar require("module"), se intentará abrir el siguiente directorio de archivos para buscar el objetivo.

/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 se ha buscado el archivo de destino, se llamará a package.loadfile para cargar el módulo. De lo contrario, se buscará en la biblioteca de programas C.

La ruta del archivo de búsqueda se obtiene de la variable global package.cpath, y esta variable se inicializa a través de la variable de entorno LUA_CPATH.

La estrategia de búsqueda es la misma que la anterior, solo que ahora se cambia por archivos de tipo so o dll. Si se encuentra, require lo cargará a través de 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库了。