Lua-Module und Pakete
Ein Modul ähnelt einer gekapselten Bibliothek. Seit Lua 5.1 hat Lua einen standardmäßigen Modulverwaltungsmechanismus hinzugefügt, der es ermöglicht, allgemeinen Code in einer Datei abzulegen und an anderer Stelle in Form einer API-Schnittstelle aufzurufen, was die Wiederverwendung von Code fördert und die Kopplung von Code verringert
Ein Lua-Modul ist eine Tabelle, die aus bekannten Elementen wie Variablen und Funktionen besteht. Daher ist das Erstellen eines Moduls sehr einfach: Erstellen Sie eine Tabelle, legen Sie die zu exportierenden Konstanten und Funktionen hinein und geben Sie schließlich diese Tabelle zurück. Im Folgenden wird ein benutzerdefiniertes Modul module.lua erstellt. Das Dateicode-Format ist wie folgt:
-- Definiere ein Modul namens module
module = {}
-- Definiere eine Konstante
module.constant = "Dies ist eine Konstante"
-- Definiere eine Funktion
function module.func1()
io.write("Dies ist eine öffentliche Funktion!"\n")
end
local function func2()
print("Dies ist eine private Funktion!")
end
function module.func3()
func2()
end
return module
Aus dem Obigen geht hervor, dass die Struktur eines Moduls die Struktur einer Tabelle ist, sodass Sie die Konstanten oder Funktionen im Modul genauso bearbeiten und aufrufen können wie Elemente in einer Tabelle.
Die oben stehende Funktion func2 ist als lokale Variable des Programmblocks deklariert, was bedeutet, dass sie eine private Funktion ist. Daher kann von außen nicht auf diese private Funktion im Modul zugegriffen werden und sie muss über die öffentliche Funktion im Modul aufgerufen werden.
require-Funktion
Lua stellt eine Funktion namens require bereit, um Module zu laden. Um ein Modul zu laden, müssen Sie es einfach aufrufen. Zum Beispiel:
require("<模块名>")
Oder
require "<模块名>"
Nach dem Ausführen von require wird eine Tabelle zurückgegeben, die aus Modulkonstanten oder Modulfunktionen besteht, und außerdem wird eine globale Variable definiert, die diese Tabelle enthält.
test_module.lua-Datei
-- Das Modul module ist die oben erwähnte module.lua
require("module")
print(module.constant)
module.func3()
Das Ausführungsergebnis des obigen Codes ist:
This is a constant This is a private function!
Oder definieren Sie eine Alias-Variable für das geladene Modul, um es einfach aufrufen zu können:
test_module2.lua-Datei
-- Das Modul module ist die oben erwähnte module.lua
-- Alias-Variable m
local m = require("module")
print(m.constant)
m.func3()
Das Ausführungsergebnis des obigen Codes ist:
This is a constant This is a private function!
Lademechanismus
Für benutzerdefinierte Module kann die Moduldatei nicht in einem beliebigen Verzeichnis abgelegt werden. Die Funktion require hat ihre eigene Ladestrategie für Dateipfade. Sie versucht, das Modul aus einer Lua-Datei oder einer C-Programmbibliothek zu laden.
Der Pfad, den require zum Suchen nach Lua-Dateien verwendet, ist in der globalen Variable package.path gespeichert. Wenn Lua startet, initialisiert es diese Umgebungsvariable mit dem Wert der Umgebungsvariable LUA_PATH. Wenn diese Umgebungsvariable nicht gefunden wird, wird ein zur Kompilierungszeit definierter Standardpfad zur Initialisierung verwendet.
Natürlich können Sie die Einstellungen auch selbst anpassen, wenn keine LUA_PATH-Umgebungsvariable vorhanden ist. Öffnen Sie die Datei .profile im Home-Verzeichnis des aktuellen Benutzers (erstellen Sie sie, falls sie nicht vorhanden ist, oder öffnen Sie die Datei .bashrc). Fügen Sie beispielsweise den Pfad "~/lua/" zur Umgebungsvariable LUA_PATH hinzu:
#LUA_PATH export LUA_PATH="~/lua/?.lua;;"
Dateipfade werden durch ";"-Semikolons getrennt. Die letzten 2 ";;" bedeuten, dass auf den neu hinzugefügten Pfad der ursprüngliche Standardpfad folgt.
Aktualisieren Sie dann die Umgebungsvariablenparameter, damit sie sofort wirksam werden.
source ~/.profile
Nehmen Sie zu diesem Zeitpunkt an, dass der Wert von package.path folgendermaßen lautet:
/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
Wenn Sie dann require("module") aufrufen, versucht es, die folgenden Dateiverzeichnisse zu öffnen, um nach dem Ziel zu suchen.
/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
Wenn die Zieldatei gefunden wird, wird package.loadfile aufgerufen, um das Modul zu laden. Andernfalls wird nach der C-Programmbibliothek gesucht.
Der Suchdateipfad wird aus der globalen Variable package.cpath abgerufen, und diese Variable wird über die Umgebungsvariable LUA_CPATH initialisiert.
Die Suchstrategie ist dieselbe wie oben, außer dass jetzt nach Dateien vom Typ so oder dll gesucht wird. Wenn sie gefunden werden, lädt require sie über package.loadlib.
C-Pakete
Lua und C lassen sich leicht kombinieren, indem man C verwendet, um Pakete für Lua zu schreiben.
Anders als beim Schreiben von Paketen in Lua müssen C-Pakete vor der Verwendung zuerst geladen und verbunden werden. In den meisten Systemen ist die einfachste Implementierungsmethode der Mechanismus der dynamischen Linkbibliothek.
Lua stellt alle Funktionen zum dynamischen Linken in einer Funktion namens loadlib bereit. Diese Funktion hat zwei Parameter: den absoluten Pfad der Bibliothek und die Initialisierungsfunktion. Ein typisches Aufrufbeispiel sieht also wie folgt aus:
local f = loadlib(path, "luaopen_socket")
Die Funktion loadlib lädt die angegebene Bibliothek und verbindet sie mit Lua. Sie öffnet die Bibliothek jedoch nicht (das heißt, sie ruft die Initialisierungsfunktion nicht auf). Stattdessen gibt sie die Initialisierungsfunktion als Lua-Funktion zurück, sodass wir sie direkt in Lua aufrufen können.
Wenn beim Laden der dynamischen Bibliothek oder beim Suchen der Initialisierungsfunktion ein Fehler auftritt, gibt loadlib nil und eine Fehlermeldung zurück. Wir können den vorherigen Code ändern, um den Fehler zu erkennen und dann die Initialisierungsfunktion aufzurufen:
-- Oder path = "C:\\windows\\luasocket.dll", dies ist auf der Windows-Plattform
local f = assert(loadlib(path, "luaopen_socket"))
f() -- Bibliothek tatsächlich öffnen
Im Allgemeinen erwarten wir, dass die Binär-Release-Bibliothek eine Stub-Datei ähnlich dem vorherigen Codeabschnitt enthält. Bei der Installation der Binärbibliothek kann sie in einem beliebigen Verzeichnis abgelegt werden, und es muss nur der tatsächliche Pfad der Binärbibliothek, die der Stub-Datei entspricht, geändert werden.
Fügen Sie das Verzeichnis, in dem sich die Stub-Datei befindet, zu LUA_PATH hinzu. Nach dieser Einstellung können Sie die require-Funktion verwenden, um die C-Bibliothek zu laden.
Andere Erweiterungen