Módulos e Pacotes do Lua

Um módulo é semelhante a uma biblioteca encapsulada, desde Lua 5.1 Inicialmente, Lua adicionou um mecanismo de gestão de módulos padrão, permitindo que alguns códigos comuns sejam colocados em um arquivo, que podem ser chamados como uma interface de API em outros lugares, facilitando a reutilização do código e reduzindo a complexidade do código.

Lua adicionou um mecanismo de gestão de módulos padrão, permitindo que alguns códigos comuns sejam colocados em um arquivo, que podem ser chamados como uma interface de API em outros lugares, o que facilita a reutilização do código e reduz a complexidade do código.

--　O nome do arquivo é module.lua
--　Definir um módulo chamado module
module = {}
　
--　Definir uma constante
module.constant = "Esta é uma constante"
　
--　Definir uma função
function module.func1()
　　　　io.write("Esta é uma função pública!\n")
end
　
local function func2()
　　　　print("Esta é uma função privada!")
end
　
function module.func3()
　　　　func2()
end
　
return module

Como podemos ver, a estrutura do módulo é uma tabela, portanto, podemos operar chamadas de constantes ou funções do módulo da mesma forma que operamos chamadas de elementos da tabela.

A função func acima2 Variáveis locais declaradas em bloco de programa, o que indica uma função privada, portanto, não pode ser acessada externamente. Para acessar essa função privada dentro do módulo, é necessário chamá-la através de uma função pública do módulo.

função require

Lua oferece uma função chamada require para carregar módulos. Para carregar um módulo, é necessário simplesmente chamá-lo. Por exemplo:

require("<nome_do_módulo>")

ou

require "<nome_do_módulo>"

Após a execução de require, será retornado uma tabela contendo constantes ou funções do módulo, além de uma variável global que contém essa tabela.

O resultado da execução do código acima é:

Esta é uma constante
Esta é uma função privada!

Ou defina um alias para o módulo carregado para facilitar a chamada:

O resultado da execução do código acima é:

Esta é uma constante
Esta é uma função privada!

Mecanismo de carga

Para módulos personalizados, os arquivos de módulo não podem ser colocados em qualquer diretório de arquivo, o função require tem sua própria estratégia de carregamento de caminhos de arquivos, ele tentará carregar o módulo a partir de arquivos Lua ou bibliotecas de programas C.

O require é usado para procurar os caminhos dos arquivos Lua e é armazenado na variável global package.path. Quando o Lua é iniciado, ele inicializa essa variável de ambiente com o valor do variável de ambiente LUA_PATH. Se não encontrar essa variável de ambiente, usará um caminho padrão definido no tempo de compilação para inicializar.

Claro, se não houver o variável de ambiente LUA_PATH, também pode ser configurado manualmente, abrindo o arquivo .profile no diretório raiz do usuário atual (se não existir, pode criar e abrir o arquivo .bashrc), por exemplo, adicionar "~/lua/" Adicione o caminho ao variável de ambiente LUA_PATH:

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

Os caminhos dos arquivos são separados por ";", e o último 2 Os ";;" representam o caminho adicionado mais o caminho padrão original.

Em seguida, atualize os parâmetros das variáveis de ambiente para que sejam eficazes imediatamente.

source ~/.profile

Neste momento, suponha que o valor de package.path seja:

/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

Portanto, ao chamar require("module"), tentará abrir os seguintes diretórios de arquivos para procurar o 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

Se já tiverem pesquisado o arquivo de destino, chamarão package.loadfile para carregar o módulo. Caso contrário, procurarão a biblioteca de programas C.

O caminho do arquivo de busca é obtido da variável global package.cpath, que é inicializada pelo variável de ambiente LUA_CPATH.

A estratégia de busca é a mesma que a anterior, mas agora a busca é por arquivos do tipo so ou dll. Se encontrar, o require carregará usando package.loadlib.

Pacote C

Lua e C são fáceis de combinar, escrevendo pacotes para Lua usando C.

Diferente de escrever pacotes no Lua, os pacotes C devem ser carregados e conectados antes de serem usados, e a maneira mais fácil de fazer isso em muitos sistemas é através do mecanismo de ligação dinâmica.

O Lua fornece todas as funcionalidades de conexão dinâmica dentro da função loadlib. Esta função tem dois parâmetros: o caminho absoluto da biblioteca e a função de inicialização. Assim, um exemplo típico de chamada é o seguinte:

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

A função loadlib carrega a biblioteca especificada e conecta ao Lua, mas não abre a biblioteca (isto é, não chama a função de inicialização), ao invés disso, ela retorna a função de inicialização como uma função do Lua, assim podemos chamá-la diretamente no Lua.

Se houver um erro ao carregar a biblioteca dinâmica ou ao encontrar a função de inicialização, loadlib retornará nil e uma mensagem de erro. Podemos modificar o código anterior para detectar erros e chamar a função de inicialização:

local path = ""/usr/local/lua/lib/libluasocket.so
--　ou path = "C:\\windows\\luasocket.dll", isso é para a plataforma Windows
local f = assert(loadlib(path, "luaopen_socket"))
f()　　--　Abrir realmente a biblioteca

Geralmente, esperamos que as bibliotecas de publicação binárias contenham um arquivo stub semelhante ao código anterior, quando instalar a biblioteca binária, você pode colocá-la em qualquer diretório, bastando modificar o caminho real do arquivo stub da biblioteca binária.

Adicione o diretório onde o arquivo stub está localizado ao LUA_PATH, dessa forma, após a configuração, você pode usar a função require para carregar bibliotecas C.