Quelltext der Seite Hilfe:Lua/Modul im Wiki

{{SeitenordnungWP.de
| PageID = 92032
| Obereinordnung1 = ∆MW-Programmierung
}} 
<noinclude>{{Wikipedia:Lua/Linkbox}}
Diese Hilfeseite stellt für Lua-Programmierer die Wirkung eines Lua-Moduls im Kontext von Wiki-Seiten dar.
</noinclude>
== Quelltext und Seiten ==
* Alle Seiten im Namensraum <code>Modul:</code> (828) sind grundsätzlich der Quellcode zu je einem Lua-Modul. Dies wird nicht als Wikitext interpretiert. Das [[Wikipedia:Technik/MediaWiki/Content Model|''Content Model'']] ist <code>Scribunto</code>.
* Nur Seiten, deren Name das Schema für Dokumentationen erfüllt, in der deutschsprachigen Wikipedia also auf <code>/Doku</code> endet, können Wikitext enthalten.
* Darüber hinaus gibt es die Möglichkeit, in bestimmten Unterseiten der Benutzer-Spielwiese im Rahmen der [[Hilfe:Vorlagenspielwiese|Vorlagenspielwiese]] Lua-Module wirksam werden zu lassen.
* Seiten anderer Namensräume können mit <code>#invoke</code> schon deshalb nicht genutzt werden, weil der Namensraum dieser Anweisung intern vorangestellt wird. Auch ein <code>[[#require()|require()]]</code> ist nur auf Seiten möglich, deren Inhalt als Lua-Quellcode gespeichert ist („Content Model“).
* Sonstige Unterseiten im Namensraum <code>Modul:</code> sollten praktisch nur nicht-selbstständigen Lua-Code enthalten:
** Keine Vorlage oder ein anderes Modul sollte unaufgefordert derartige Seiten verwenden; ausgenommen durch <code>[[#mw.loadData()|mw.loadData()]]</code> genutzte Datenmengen oder wenn eine solche Schnittstelle dokumentiert ist.
** In der Regel ist es aus dem selbstständigen Modul ausgegliederter Code, wofür es unterschiedliche gute Gründe geben kann.
** Es könnte auch ein unter dem Namen <code>/test</code> ausgegliederter ''[[Modultest|unit test]]'' sein (in Lua programmiert).
** Außerdem sind [[Hilfe:JSON|JSON]]-Unterseiten legitim.

== Kapselung ==
Die Module sind bewusst so gestaltet, dass keinerlei Zugriff von einer Einbindung mit <code>#invoke</code> auf eine andere oder den Inhalt der umgebenden Seite möglich ist. Einige trickreiche Versuche, dies zu unterlaufen, wurden nach kurzer Zeit unterbunden.<ref>[[Gerrit:58897]]</ref>

Ein Modul kann selbst keinerlei Veränderung an der Welt hervorrufen (sieht man davon ab, dass bei den „Links auf diese Seite“ durch Einbindung anderer Seiten ein Eintrag hinzukommen kann; oder dass es die [[:Kategorie:Wikipedia:Seite mit Skriptfehlern|Kategorie der Seiten mit Skriptfehlern]] bereichert). Es kann sich ausschließlich durch seinen [[#Rückgabewert|Rückgabewert]] äußern, der letztlich in irgendeiner Weise auf eine Vorlagen-Einbindung oder sonstigen Seitentext wirken müsste.

Das Modul kann die Parameter der Vorlagen-Einbindung (oder einer sonstigen Seite, in der das <code>#invoke</code> vorkommt) auslesen. Ihm ist außerdem bekannt, wie die Gesamt-Seite heißt, die dem Benutzer dargestellt wird. Mehr kann das Modul über seine Umgebung ([[#Elternumgebung|Elternumgebung]]) nicht herausfinden. Wie die Vorlage heißt, in der <code>#invoke</code> steht, lässt sich mit 
<code>frame:getParent():getTitle()</code> auch noch ermitteln (siehe unten). [[#frame:getTitle()|seinen eigenen Namen]] kann das Modul seit Anfang 2014 ermitteln.

=== {{Anker|G}} Die globale Variable _G ===
_G ist eine ''table'', die standardmäßig die nachstehend aufgelisteten Komponenten enthält:
: _G _VERSION assert debug error getmetatable ipairs math mw next os package pairs pcall rawequal rawget rawset require select setmetatable string table tonumber tostring trim type unpack xpcall

Im [[mw:Extension:Scribunto/Lua reference manual#require|Handbuch]] auf Mediawiki heißt es:
: ''Note that every required module is loaded in its own sandboxed environment, so it cannot export global variables as is sometimes done in Lua 5.1. Instead, everything that the module wishes to export should be included in the table returned by the module.''
Tatsächlich sind jedoch im Mai 2013 in <code>_G</code> aus allen mittels <code>[[#require()|require()]]</code> eingebundenen Modulen diejenigen Variablen versammelt, die dort nicht explizit als ''local'' deklariert wurden. Es ist aber davon auszugehen, dass dies nicht mehr lange der Fall sein wird; besser ist gemäß [[#Lua-Export|Export-''table'']] eine saubere Rückgabe.

== {{Anker|Rückgabewert}} Rückgabewert des Moduls ==
Die letzte Zeile eines Moduls muss eine <code>return</code>-Anweisung mit einem Rückgabewert sein. Fehlt dies, wäre der Wert immer <code>nil</code>.

Der Datentyp dieses Rückgabewerts ist im Prinzip beliebig. Verbreitet wäre ''table'', aber auch eine ''function'' wäre vorstellbar; letztlich auch eine zwangsläufig kaum variierbare Zeichenkette oder Zahl.

Der Rückgabewert ist in drei Fällen auszuwerten:
# Als Wert des Aufrufs von <code>[[#require()|require()]]</code>.
# Als Wert von <code>[[#mw.loadData()|mw.loadData()]]</code>.
# Wenn es eine ''table'' ist, macht sie für <code>#invoke</code> die verfügbaren Funktionen zugreifbar.

== {{Anker|ti}} Schnittstelle zur Vorlagenprogrammierung ==
In die einbindende Seite wird mittels der Parserfunktion <code>{&#123;#invoke:</code>''M''<code>|</code>''fun''<code>|</code>''params''<code>}}</code> eingebettet.

''fun'' ist der Name einer Funktion, die Komponente in dem als ''table'' deklarierten [[#Rückgabewert|Rückgabewert]] des Moduls&nbsp;''M'' ist. Sie erhält als Parameter das [[#frame|Objekt ''frame'']] des <code>#invoke</code>.

Die Parameterliste entspricht derjenigen bei Vorlagen. Verirrte Gleichheitszeichen im Wert eines unbenannten Parameters können Syntaxfehler auslösen. Bei von außen kommenden Werten sollte immer mittels vorangestellter laufender Nummer eine sichere Zuweisung erfolgen: <code>|1={&#123;{Text|}}}</code>

=== Auswertung in der Funktion ===
In der Funktion steht die Parameterliste im [[#Objekt frame|Objekt ''frame'']] als ''table'' <code>frame.args</code> zur Verfügung.

Im Unterschied zu Vorlagen ist auch die leere Zuweisung <code>|x=&nbsp;|</code> auswertbar; das heißt: Es lässt sich ohne besondere Konstrukte feststellen, dass ''x'' in der Parameterliste genannt wird, jedoch der leere Wert zugewiesen wurde.

Der Wert einer Komponente von <code>frame.args</code> ist ein ''string'', wenn der Parameter im <code>#invoke</code> vorkommt, und <code>nil</code> ansonsten.

Wie auch bei Vorlagen gilt: Benannte Parameter werden getrimmt (Leerzeichen und Zeilenumbruch vor und nach dem Wert werden entfernt); unbenannte Parameter nicht.

Als Beispiel siehe das [[Modul:Hello]].


Die Zuordnung lässt sich am besten aus folgendem Beispiel für ein Modul ''M'' mit Funktion ''f'' ablesen:
 &#123;{#invoke:M|f|1=ABC|FGH| LMN |benanntA=PQR|benanntB= TUV | HÖHE ÜBER NN= 32 | Leergut= }}
liefert
{| class="wikitable"
|-
| <code>frame.args[ 1 ]</code>
| »<code>ABC</code>«
|-
| <code>frame.args[ 2 ]</code>
| »<code>FGH</code>«
|-
| <code>frame.args[ 3 ]</code>
| »<code>&nbsp;LMN&nbsp;</code>«
|-
| <code>frame.args.benanntA</code>
| »<code>PQR</code>«
|-
| <code>frame.args.benanntB</code>
| »<code>TUV</code>«
|-
| <code>frame.args[ "HÖHE ÜBER NN" ]</code>
| »<code>32</code>«
|-
| <code>frame.args.Leergut</code>
| »«
|-
| <code>frame.args.Unbekannt</code>
| <code>nil</code>
|-
|}

=== Rückgabewert einer Funktion für Vorlagen ===
Der Rückgabewert der in <code>#invoke</code> genannten Funktion ersetzt als Zeichenkette den Bereich <code>{&#123;#invoke:}}</code>.

Als Rückgabewert sollte man immer explizit eine Zeichenkette schaffen. Wenn der Rückgabewert von anderem Typ ist, wird dies durch Standard-Operationen in eine Zeichenkette umgewandelt. Dadurch kann in der Seite das Wort <code>false</code> oder <code>nil</code> lesbar sein oder die Programmierung zu falschen Schlüssen führen. Letzteres lässt sich vermeiden durch den [[Hilfe:Lua/Programmierung#or|Ausdruck]]:
<syntaxhighlight lang="lua">
return r or ""
</syntaxhighlight>
Wenn ''r'' „etwas“ ist, wird ''r'' zurückgegeben, sonst <code>""</code>.

Mehrere Rückgabewerte oder ein aggregierter Datentyp würden für <code>#invoke</code> automatisch durch Verwendung der Funktion <code>tostring()</code> in Strings umgewandelt und dann ohne Trennzeichen aneinandergefügt. Dies sollte vermieden werden und kontrolliert eine Zeichenkette gebildet werden, die sich dann auch im Artikel sehen lassen kann.

== {{Anker|frame}} Objekt ''frame'' ==
: → [[mw:Extension:Scribunto/Lua reference manual#Frame object|Scribunto-Dokumentation]] (englisch)
Das Objekt ''frame'' gibt die Umgebung wieder. Grundsätzlich gibt es zwei Instanzen:
# Aufruf des <code>#invoke</code> (Normalfall; standardmäßig immer mit <code>frame</code> bezeichnet)
# Aufruf der einbindenden Seite (meist Vorlage).
#* Erhältlich mittels <code>[[#frame:getParent()|frame:getParent()]]</code>
#* Einziger nutzbarer Unterschied sind die Argumente <code>frame.args</code> der Vorlageneinbindung; alle Funktionen führen zum gleichen Ergebnis; erneutes <code>frame:getParent()</code> hilft nicht.

Wenn über <code>#invoke</code> eine Funktion für die Vorlage genutzt wird, ist der Funktion gemäß [[#ti|Schnittstelle zur Vorlagenprogrammierung]] auch das Objekt ''frame'' dazu bekannt. Falls dies (als Bibliotheksfunktion) nicht übergeben wurde oder in tieferen Ebenen nicht durchgereicht wurde, kann es überall gebildet werden mit:
<syntaxhighlight lang="lua" id="mw.getCurrentFrame()">
frame = mw.getCurrentFrame()
</syntaxhighlight>

=== Komponenten ===
Unmittelbar nutzbar sind:
; frame.args {{Anker|frame.args}}
: Angegebene Parameter als ''table''.
:* In der Regel Parameter des <code>#invoke</code> – nach [[#frame:getParent()|frame:getParent()]] Vorlagenparameter der einbindenden Seite.
: Aus Performance-Gründen wird das ''frame''-Objekt als ''metatable'' organisiert. Das bedeutet, dass insbesondere die <code>frame.args</code> nicht manipuliert werden können und auch die Anzahl nicht per ''length''-Operator <code>#</code> festgestellt werden kann.
: Der Datentyp des Bezeichners ist:
:* <code>number</code> bei einem unbenannnten Vorlagenparameter; bzw. numerischer Angabe
:* <code>string</code> sonst
; frame&#58;callParserFunction() {{Anker|frame:callParserFunction()}}
: Ausführung einer Parser-Funktion.
: <code>r = frame:callParserFunction( name, args )</code>
: Verschiedene Formen sind für die Argumentenliste möglich.
: Die Argumente werden unverarbeitet an die Parser-Funktion übergeben.
: Der Doppelpunkt gehört nicht zum Funktionsnamen.
: Wo es möglich ist, sollten Lua-interne Funktionen bevorzugt werden.
; frame&#58;expandTemplate() {{Anker|frame:expandTemplate()}}
: Einbinden einer anderen Seite.
: <code>r = frame:expandTemplate{ title = s, args = args }</code>
: Es ist nur dieses Format mit benannten Parametern und geschweiften Klammern möglich.
: <code>title=</code> wird in der Regel eine Zeichenkette mit dem Vorlagentitel sein; inzwischen<!-- 1.24wmf1 --> ist aber auch ein Objekt <code>[[Hilfe:Lua/Links#mw.title|mw.title]]</code> möglich.
; frame&#58;extensionTag() {{Anker|frame:extensionTag()}}
: Analog zu [[#frame:callParserFunction()|frame:callParserFunction()]] mit dem von Tags umschlossenen Inhalt.
: <code>r = frame:extensionTag( name, content, args )</code>
: Verschiedene Formen sind für die Argumentenliste möglich.
; frame&#58;getParent() {{Anker|frame:getParent()}}
: Objekt ''frame'' für die einbindende Seite ([[#Elternumgebung|Elternumgebung]]).
: <code>frameT = frame:getParent()</code>
; frame&#58;getTitle() {{Anker|frame:getTitle()}}
: Gibt den Seitentitel zum frame-Objekt zurück.
: Für den mittels <code>#invoke</code> generierten ''frame'' ist das der Name des eingebundenen Moduls selbst (einschließlich <code>Modul:</code> zu Beginn).
: Das Modul kennt dadurch seinen eigenen Namen (Pfad).
: Das kann eingesetzt werden, um die Produktivversion von einer Testkopie im BNR zu unterscheiden.
: Maximal die einbindende Wikitext-Seite, in der Regel also die Vorlage mit dem <code>#invoke</code>, lässt sich so ermitteln: <code>frame:getParent():getTitle()</code>
: Von der einbindenden Wikitext-Seite (Vorlage) aus ist keine Steigerung mehr im Sinne eines Aufruf-Stack möglich; die übergeordneten Aufrufe liefern <code>nil</code> zurück.
; frame&#58;preprocess() {{Anker|frame:preprocess()}}
: Expandieren eines komplexen Wikitexts.
: Vorlagen, Parserfunktionen und Parameter wie <code>{&#123;{1}}}</code> werden ausgewertet.
: Eine einzelne Vorlage sollte statt dessen mit [[#frame:expandTemplate()|frame:expandTemplate()]] expandiert werden.
: <code>frame:preprocess( string )</code>

Nicht zwingend benötigt werden die nachstehenden drei Funktionen. Sie liefern jeweils ein ''object (table)'' zurück. Das ''object'' hat eine einzige Methode  ''object''<code>:expand()</code>&nbsp;– dies liefert den expandierten Wikitext in der jeweiligen Situation.
; frame&#58;getArgument( argument )
; frame&#58;getArgument{ name = argument }
: Lässt <code>argument</code> expandieren.
; frame&#58;newParserValue( text )
; frame&#58;newParserValue{ text = text }    
: Zugriff auf <code>frame:preprocess( text )</code>.
; frame&#58;newTemplateParserValue{ title = title, args = table }
: Benannte Argumente erforderlich.
: Zugriff auf <code>frame:expandTemplate()</code> mit den genannten Argumenten.

== {{Anker|mw.isSubsting()}} Substituierung ==
Mittels der Funktion <code>mw.isSubsting()</code> lässt sich herausfinden ''(boolean)'', ob die momentane Aktivität darauf hinauslaufen wird, dass das Ergebnis substituiert wird (mit <code>&#123;{subst:</code> eingebunden wurde).

Anfang 2014 wird jedoch nur erkannt, ob die Parserfunktion <code>#invoke</code> unmittelbar Gegenstand einer Substituierung <code><nowiki>{{subst:#invoke:m|f}}</nowiki></code> ist; nicht aber, ob etwa eine Vorlage, in der dieses <code>#invoke</code> vorkäme, gerade substituiert wird.

Dadurch lassen sich Wartungskategorien in das Ergebnis einfügen, die bei einer unerwünschten Substituierung protestieren; oder umgekehrt bei fehlender Substituierung eine Einbindung bemängeln.

Ein [[#frame|<code>frame</code>-Objekt]] wird bei der Substituierung von <code>#invoke</code> nicht übergeben; über [[#mw.getCurrentFrame()|mw.getCurrentFrame()]] lässt es sich aber jederzeit beschaffen.

== Mehrere Module ==
=== Einbindung ===
{{Anker|require()}}
Die Funktion <code>require()</code> bindet ein anderes Modul ein.
* Parameter ist eine Zeichenkette mit dem Namen des Moduls.
** Der Namensraum <code>Modul:</code> ist voranzustellen.<!-- :en: -->
** Die Zeichenkette <code>"strict"</code> löst eine besondere Funktion aus.
*** Es wird kein Modul eingebunden.
*** Vielmehr wird von nun an die Verwendung von Variablen kontrolliert. Alle müssen als <code>local</code> deklariert werden; sie dürfen keine globale Hinterlegung oder Abfrage nicht bekannter Variablen bewirken. Ansonsten wird ein ''Skriptfehler'' ausgelöst.
*** Es gibt keinen Rückgabewert.
* Es ergeben sich folgende Werte:
*# ''table'' oder ''string'', wenn dies [[#Rückgabewert|Rückgabewert]] war.
*# <code>true</code> wenn der Seitenname sonst existiert und als Lua-Quellcode verwaltet wird.
*# ''Skriptfehler'' und Abbruch, wenn der Seitenname nicht existiert oder der Inhalt nicht als Lua-Quellcode gilt oder ein globaler Syntaxfehler in der Seite vorliegt (kein gültiger content).
''Beispiel für eine sichere Einbindung:''
<syntaxhighlight lang="lua">
local lucky, WillHaben = pcall( require, "Modul:WillHaben" )
if type( WillHaben ) == "table" then
    r = WillHaben.WillHaben()
else
    r = "<span class=\"error\">" .. WillHaben .. "</span>"
    --  auto: "package.lua:80: module 'Modul:WillHaben' not found"
    --  "Fehler * Modul:WillHaben nicht gefunden"
end
</syntaxhighlight>
<code>[[Hilfe:Lua/Programmierung#pcall()|pcall()]]</code> ist absturzsicher; der zweite Rückgabewert ist im Erfolgsfall der Rückgabewert des Moduls, sonst die Fehlermeldung von <code>[[#require()|require()]]</code>.

''Hinweis:'' Die Parserfunktion <code>[[Hilfe:Parserfunktionen/Kontrollstrukturen#iferror|#iferror:]]</code> greift nicht, wenn der Klassenname in Apostroph <code>'</code> statt <code>"</code> eingeschlossen ist.

==== {{Anker|redirect}} Weiterleitung ====
Ein Modul kann aus einer einzigen Zeile bestehen
<syntaxhighlight lang="lua">
return require( "Modul:NeuerName" )
</syntaxhighlight>
und wirkt dann wie eine Weiterleitung; etwa nach einer Umbenennung.

=== {{Anker|Lua-mw.loadData()}} mw.loadData() ===
Diese Funktion entspricht grundsätzlich dem <code>[[#require()|require()]]</code> mit einigen Besonderheiten:
* Die Elemente des [[#Rückgabewert|Rückgabewerts]] können nur Basis-Datentypen enthalten (vor allem Zeichenketten und Zahlen); nicht aber Funktionen.
* Die erfolgte Einbindung wird vorgemerkt, so dass mehrfache <code>#invoke</code> innerhalb einer Gesamt-Seite beschleunigt werden. Die Generierung des Rückgabewerts erfolgt in jeder Seite nur ein einziges Mal.
* Der Rückgabewert ist üblicherweise, aber nicht zwingend, eine ''table''.
* Die Inhalte eines ''table''-Rückgabewerts sind durch das einbindende Modul nicht veränderbar.
Vorgesehen ist dies für große Datenmengen, die dann auch separat von den Funktionen im Modul gepflegt werden können.

=== {{Anker|Lua-Export}} Export für andere Module ===
Die Standard-Aufgabe ist es, eine Vorlage mittels <code>#invoke</code> zu unterstützen. Konzeptionell gibt es die Möglichkeit, zusätzlich oder ausschließlich andere Lua-Module durch <code>require()</code> zu unterstützen. Dabei gibt es zwei Fälle:
# Sowohl Vorlagen als auch Module werden durch jeweils angepasste Funktionen gleicher Zielsetzung unterstützt.
#* Es bietet sich an, die Funktionen mit gleichem Namen in beiden Zugriffsarten anzubieten.
#** Die generische Funktion ist dann die Version für Lua-Aufruf.
#** Die Variante für die Vorlagenprogrammierung setzt nur noch die Eingabeparameter um, ruft die generische Funktion auf und stellt das für Vorlagen geeignete Resultat sicher.
#** Bei der Vorlagenprogrammierung sind ausschließlich Zeichenketten als Parameter möglich, während die generische Funktion auch andere Typen wie numerische Werte oder ''table'' zulässt. Die beim <code>#invoke</code> beigegebenen Parameterwerte sind dann entsprechend zu interpretieren (parsen).
#* ''Beispiel:'' [[#VorlagenLua|siehe unten]]
# Es werden ausschließlich Funktionen für Lua-Module angeboten; die Aufgabenstellung passt nicht zu Vorlagen.
#* ''Beispiele:''
#** [[#NurLua|siehe unten]]
#** [[Wikipedia:Lua/Modul/LuaWiki]]
Exportierte Funktionen werden mitsamt der ''table'' ihres definierenden Moduls angewendet. Diese heißt immer so wie das Modul selbst. Da die Namen der Module im Namensraum eindeutig sind, kann es nicht zu Namenskonflikten kommen. Damit ist auch sofort klar, woher eine Funktion stammt und wo die Dokumentation zu finden ist, wenn plötzlich im Quelltext ein unbekannter Funktionsaufruf angetroffen wird.

== Einfaches Modul für Vorlagen ==
Das [[Modul:Hello]] gibt einen ersten Einstieg:
{{#tag:syntaxhighlight |{{Modul:Hello}}| lang=lua | line=1}}
Der Aufruf würde erfolgen mittels
* <code><nowiki>{{</nowiki>#invoke:Hello|hello}}</code> (ergibt <code style="white-space: nowrap">Hallo, Welt! Dies ist Lua!</code>)
oder
* <code><nowiki>{{</nowiki>#invoke:Hello|hello|hier bin ich}}</code> (ergibt <code style="white-space: nowrap">Hallo, hier bin ich! Dies ist Lua!</code>)

== Strukturierung eines komplexeren Moduls ==
Ein Modul mit zwei oder drei Funktionen nur für Vorlagen ist eher trivial.

Bei komplexeren Aufgaben ist etwas Strukturierung und Übersicht erforderlich.
* An Beginn sollte auch ein Datum vermerkt sein.
** Weil Versionen des Quellcodes nicht ausschließlich über die produktive Seite generiert werden, ist die normale Versionsgeschichte einer Seite nicht hinreichend für die Verfolgung der Varianten. Vielmehr werden Versionen auch aus einem Testwiki oder von einer gesonderten Erprobungsseite oder aus einem fremden Wiki-Projekt mit der Mutterversion einkopiert; und wieder dorthin zurück.
* Es empfiehlt sich eine Ultrakurzbeschreibung der Funktionalität.
* Am Schluss stehen die Funktionen, die für den Export bestimmt sind.
* <code>p</code> ist der Rückgabewert des gesamten Moduls. Dieser Name hat sich eingebürgert, und er stellt eine ''table'' dar.

=== Funktionen nur für Vorlagen, sowie innere Hilfsfunktionen ===
<syntaxhighlight lang="lua">
--[=[ DiesesBeispiel 2013-05-07
Dieser und jener Zweck
* service
]=]

-- Module globals
local messagePrefix = "lua-module-DiesesBeispiel-"
-- ...
-- ...

local function x( a )
    -- ...
    return r
end -- x()

-- ...
-- ...


-- Provide template access
local p = {}

p.service( frame )
    -- ...
    return x( u ) or ""
end -- .service()

return p
</syntaxhighlight>
Die Funktion <code>service</code> wird zur Nutzung in einer Vorlage exportiert.

=== {{Anker|VorlagenLua}} Funktionen für Vorlagen und zusätzlich Lua-Zugriff ===
<syntaxhighlight lang="lua">
--[=[ DiesesBeispiel 2013-05-07
Dieser und jener Zweck
* service
* DiesesBeispiel()
]=]

-- Module globals
local messagePrefix = "lua-module-DiesesBeispiel-"
local DiesesBeispiel = { }
-- ...
-- ...

local function x( a )
    -- ...
    return r
end -- x()


DiesesBeispiel.service = function ( a )
    -- ...
    return x( u )
end -- DiesesBeispiel.service()


-- ...
-- ...

-- Provide external access
local p = {}

p.service( frame )
    -- ...
    return DiesesBeispiel.service( u ) or ""
end -- .service()

function p.DiesesBeispiel()
    -- Retrieve function access for modules
    -- Postcondition:
    --     Return table with functions
    return DiesesBeispiel
end -- .DiesesBeispiel()

return p
</syntaxhighlight>
Wie vor, aber es wird zusätzlich die ''table'' <code>DiesesBeispiel</code> exportiert über die Funktion <code>DiesesBeispiel()</code>.
* Die Funktion <code>DiesesBeispiel.service()</code> steht danach auch anderen Modulen zur Verfügung.
* Die eigentliche Implementierung der Funktionalität erfolgt in <code>DiesesBeispiel.service()</code> und die Funktion <code>service</code> für Vorlagen ruft diese Implementierung auf. Dabei sind die Parameter der Vorlageneinbindung (Zeichenketten in <code>frame.args</code>) geeignet zu interpretieren und ihr Typ ggf. geeignet zu konvertieren. Während der Rückgabewert von <code>DiesesBeispiel.service()</code> auch <code>false</code> oder <code>nil</code> sein mag, wird durch <code>or&nbsp;""</code> die für Vorlagen geeignetere leere Zeichenkette zurückgegeben.

=== {{Anker|NurLua}} Funktionen ausschließlich für Lua-Zugriff, nicht für Vorlagen ===
<syntaxhighlight lang="lua">
--[=[ DiesesBeispiel 2013-05-07
Dieser und jener Zweck
* DiesesBeispiel.service()
]=]

-- Module globals
local messagePrefix = "lua-module-DiesesBeispiel-"
local DiesesBeispiel = { }
-- ...
-- ...

local function x( a )
    -- ...
    return r
end -- x()


DiesesBeispiel.service = function ( a )
    -- ...
    return x( u )
end -- DiesesBeispiel.service()


-- ...
-- ...

-- Provide external access

return DiesesBeispiel
</syntaxhighlight>
Der Export von <code>p</code> mit der Tabelle für Vorlagen entfällt; es wird nur die ''table'' <code>DiesesBeispiel</code> direkt exportiert.

Diese Situation tritt beispielsweise bei ausgelagerten Unter-Modulen sowie Datentabellen bei [[#mw.loadData()|mw.loadData()]] auf.

== Elternumgebung ==
Versuche, die programmtechnisch im Prinzip vorhandene Elternumgebung zu ergründen, werden von Scribunto mit dem Ziel der [[#Kapselung|Kapselung]] systematisch unterbunden. Darin unterscheidet sich „Lua im Wiki“ von allgemeinen Lua-Anwendungen.

Der einzig sinnvoll mögliche Zugriff ist auf die Parameter der unmittelbar einbindenden Seite möglich:<br /><code>[[#frame:getParent()|frame:getParent()]].args</code>

Innerhalb der unmittelbar umgebenden Seite (Vorlage) erfolgen die einzelnen Aufrufe von <code>#invoke</code> sequentiell und unter Verwendung der gleichen Umgebung.
* Verschiedene Einbindungen der Vorlage selbst (z.&nbsp;B. in einem Artikel) werden dagegen parallel abgearbeitet und teilen auch keine Elternumgebung.

=== math.random() ===
Vor dem ersten Aufruf der Funktion [[mw:Extension:Scribunto/Lua reference manual#math.random|math.random()]] ist der Zufallszahlengenerator stets mit dem Wert 0 initialisiert (zur Initialisierung siehe [[mw:Extension:Scribunto/Lua reference manual#math.randomseed|math.randomseed()]]). Ohne eigene Initialisierung wird also stets die gleiche Folge von Zufallszahlen generiert. Bei sequentieller Verarbeitung der Aufrufe von <code>#invoke</code> innerhalb der gleichen Vorlage wird der Zufallszahlengenerator allerdings zwischendurch nicht zurückgesetzt, so dass die Folge dort kontinuierlich fortgesetzt wird.
<noinclude>
== Anmerkungen ==
<references />

[[Kategorie:Hilfe:Lua|Modul im Wiki]]
</noinclude>