Export translations

Settings

Group

Language

Format

Export for off-line translation

Export in native format

Export in CSV format

{{DISPLAYTITLE:Erweiterung:Scribunto/Lua-Referenzhandbuch}}<languages />
 
{{Shortcut|Lua manual|LUAREF}}
Dieses Handbuch dokumentiert {{ll|Lua}}, wie es in MediaWiki mit der Erweiterung {{ll|Extension:Scribunto|Scribunto}} verwendet wird.
Einige Teile stammen aus dem [https://www.lua.org/manual/5.1/index.html Lua-5.1-Referenzhandbuch], das unter der [[#License|MIT-Lizenz]] verfügbar ist.

{{mbox
| type = notice
| text = Diese Seite dokumentiert die neueste Version der Scribunto-Erweiterung. Einige Funktionen können noch nicht eingesetzt werden.
}}
{{TOCright}}

<span id="Introduction"></span>
== Einleitung ==

<span id="Getting_started"></span>
=== Erste Schritte ===
In einem MediaWiki-Wiki mit aktiviertem Scribunto, wird [[Special:MyLanguage/Help:Starting a new page|eine Seite erstellt]] mit einem Titel, der mit "<code>Module:</code>" beginnt, wie beispielsweise "[[Module:Bananas]]".
In diese neue Seite kann folgender Text kopiert werden:

<syntaxhighlight lang="lua">
local p = {} --local p = {} -- p steht für Paket (engl. package)

function p.hello( frame )
    return "Hello, world!"
end

return p
</syntaxhighlight>

<div class="mw-translate-fuzzy">
Die Modul-Seite kann abgespeichert werden. Auf einer anderen (nicht modulierten) Seite kann folgender Quelltext eingegeben werden:
</div>
<pre>
{{#invoke:Bananas|hello}}
</pre>
„Bananas“ muss aber durch die Bezeichnung des benannten Moduls ersetzt werden. In diesem Modul wird dann die ausgelagerte „Hallo“-Funktion aufgerufen. <code><nowiki>{{#invoke:Bananas|hello}}</nowiki></code> wird durch den Text ersetzt, den die Funktion zurückgegeben hat. In diesem Fall „Hello, world!“

Im Allgemeinen ist es sinnvoll, Lua-Code im Zusammenhang einer Vorlage aufzurufen.
Dies bedeutet, dass die Syntax aus Sicht einer aufrufenden Seite unabhängig davon ist, ob die Vorlagenlogik in Lua oder in Wikitext implementiert ist.
Dadurch wird auch die Einführung zusätzlicher komplexer Syntax im betreffenden Namensraum eines Wikis vermieden.

<span id="Module_structure"></span>
=== Modulaufbau ===
Das Modul selbst muss eine Lua-Tabelle (englisch ''{{lang|en|Lua table}}'') zurückgeben, der die Funktionen enthält, die von <code><nowiki>{{#invoke:}}</nowiki></code> aufgerufen werden können.
Im Allgemeinen wird, wie oben gezeigt, eine lokale Variable deklariert, die eine Tabelle enthält, Funktionen werden zu dieser Tabelle hinzugefügt und die Tabelle wird am Ende des Modulcodes zurückgegeben.

Auf alle Funktionen, die weder lokal noch global zu diesem Ausdruck hinzugefügt wurden, können von <code><nowiki>{{#invoke:}}</nowiki></code> nicht aufgerufen werden. Globale Ausdrücke sind jedoch möglicherweise von anderen Modulen aus zugänglich und können mit <code>[[#require|require()]]</code> geladen werden.
Grundsätzlich ist es sinnvoll, wenn in einem Modul alle Funktionen und Variablen als lokal deklariert werden.

<span id="Accessing_parameters_from_wikitext"></span>
=== Zugriff auf Parameter aus dem Wikitext ===

Funktionen, die von <code><nowiki>{{#invoke:}}</nowiki></code> aufgerufen werden, wird ein einzelner Parameter übergeben, bei dem es sich um ein [[#frame-object|Frame-Objekt <small>(eng. Rahmen)</small>]] handelt. Um auf die an <code><nowiki>{{#invoke:}}</nowiki></code> übergebenen Parameter zuzugreifen, wird normalerweise der <code>[[#frame.args|args]]</code> verwendet. Es ist auch möglich, auf die Parameter zuzugreifen, die an die Vorlage übergeben wurden. Diese werden in <code><nowiki>{{#invoke:}}</nowiki></code> angegeben und mittels <code>[[#frame:getParent|frame:getParent()]]</code> eingeladen. Damit kann dann auf die <code>args</code> dieses Frames zugegriffen werden.

Dieses Frame-Objekt wird auch verwendet, um auf kontextspezifische Funktionen des Wikitext-Parsers zuzugreifen, z. B. [[#frame:callParserFunction|Aufruf von Parser-Funktionen]], [[#frame:expandTemplate|Expandierung von Vorlagen]] und [[#frame:preprocess|expandieren beliebiger Wikitext-Zeichenfolgen]].

<span id="Returning_text"></span>
=== Rückgabetext ===

<div class="mw-translate-fuzzy">
Die Modulfunktion sollte normalerweise eine einzelne Zeichenfolge zurückgeben. Alle zurückgegebenen Werte werden durch [[#tostring|tostring()]] geleitet und dann ohne Trennzeichen verkettet. Diese Zeichenfolge wird als Ergebnis des <code><nowiki>{{#invoke:}}</nowiki></code> in den Wikitext eingefügt.
</div>

<div class="mw-translate-fuzzy">
An diesem Punkt der Seitenanalyse wurden Vorlagen bereits erweitert, Parserfunktionen und Erweiterungs-Tags wurden bereits verarbeitet, und Vor-Speichern-Transformationen (z. B. Erweiterung der Signatur-Tilden und des [[$help|senkrechten Strichs]]) wurden bereits durchgeführt. Daher kann das Modul diese Funktionen nicht in seinem Ausgabetext verwenden. Wenn ein Modul beispielsweise <code><nowiki>„Hallo [[World|Welt]]! {{Willkommen}}“</nowiki></code> zurückgibt, wird auf der Seite "Hallo [[World|Welt]]! <nowiki>{{Willkommen}}</nowiki>“ angezeigt.
</div>

Auf der anderen Seite wird die [[Special:MyLanguage/Help:Substitution|Substitution]] zu einem früheren Zeitpunkt der Verarbeitung abgearbeitet, sodass mit <code><nowiki> {{subst:#invoke:}}</nowiki></code> nur die andere Ersetzung bearbeitet wird. Da die fehlgeschlagene Ersetzung im Wikitext verbleibt, werden sie bei der ''nächsten'' Bearbeitung verarbeitet. Dies sollte generell vermieden werden.

<span id="Module_documentation"></span>
=== Modul-Dokumentation ===

<div class="mw-translate-fuzzy">
Mit Scribunto können Module dokumentiert werden, indem das Modul automatisch mit einer Wikitext-Dokumentationsseite verknüpft wird. Standardmäßig wird dazu die Unterseite „/doc“ des Moduls verwendet, die oberhalb des Quellcodes des Moduls auf der Modulseite angezeigt wird. Die Dokumentation für das „Module:Bananas“ befindet sich beispielsweise unter „Module:Bananas/doc“.
</div>

<div class="mw-translate-fuzzy">
Diese Unterseiten können mithilfe der folgenden [[$help|MediaWiki-Namensraum-Nachrichten]] konfiguriert werden:
</div>

* <code>scribunto-doc-page-name</code> — Legt den Namen der für die Dokumentation verwendeten Seite fest. Der Name des Moduls (ohne das Modul: Präfix) wird als <code>$1</code> übergeben. Wenn im Modul-Namensraum die hier angegebenen Seiten als Wikitext und nicht als Lua-Quelle interpretiert werden, können sie nicht mit <code><nowiki>{{#invoke:}}</nowiki></code> verwendet werden. Der Standardwert ist „Module:$1/doc“, d. H. die „/doc“-Unterseite des Moduls. Zu beachten ist, dass Parser-Funktionen und andere Klammererweiterungen in dieser Nachricht möglicherweise nicht verwendet werden.
* <code>scribunto-doc-page-does-not-exist</code> — Meldung, wenn die Dokumentenseite nicht vorhanden ist. <span lang="en" dir="ltr" class="mw-content-ltr">The name of the page is passed as <code>$1</code>.</span> <span lang="en" dir="ltr" class="mw-content-ltr">The default is empty.</span>
* <code>scribunto-doc-page-show</code> — <span lang="en" dir="ltr" class="mw-content-ltr">Message displayed when the doc page does exist.</span> <span lang="en" dir="ltr" class="mw-content-ltr">The name of the page is passed as <code>$1</code>.</span> <span lang="en" dir="ltr" class="mw-content-ltr">The default is to transclude the documentation page.</span>
* <code>scribunto-doc-page-header</code> — <span lang="en" dir="ltr" class="mw-content-ltr">Header displayed when viewing the documentation page itself.</span> <span lang="en" dir="ltr" class="mw-content-ltr">The name of the module (with Module: prefix) being documented is passed as <code>$1</code>.</span> <span lang="en" dir="ltr" class="mw-content-ltr">The default simply displays a short explanation in italics.</span>

<span class="mw-translate-fuzzy">Zu beachten ist, dass Module nicht direkt kategorisiert und Interwiki-Links nicht direkt hinzugefügt werden können.</span>
Diese können auf der Dokumentationsseite innerhalb der Tags {{tag|includeonly}} eingebunden werden, wo sie auf das Modul angewendet werden, wenn die Dokumentationsseite in die Modulseite übertragen wird.

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Renaming or moving modules ===
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
To rename or move a module, use the <u>Move Page</u> link in the Tools sidebar. You will want to move both the module itself, as well as the subpage containing its documentation.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Redirects ===
</div>
{{MW version|version=1.42|gerrit change=574086}}
<div lang="en" dir="ltr" class="mw-content-ltr">
Since release 1.42, Scribunto recognizes one particular syntax for redirects (so they’re highlighted on special pages, appear on Special:WhatLinksHere, and so on), and also produces redirects when renaming/moving a module, similarly to how renaming of wikitext pages works (before that, module renames left no redirects behind, now extra rights are needed to suppress the redirect).
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
To manually create a module redirect, use the following syntax (which is valid Lua code, and worked like a redirect even before 1.42, but without MediaWiki recognizing it as such):
</div>
<syntaxhighlight lang="lua">
return require [[Module:Foo]]
</syntaxhighlight>
<div lang="en" dir="ltr" class="mw-content-ltr">
Replace <code>Foo</code> with the name of the module you'd like to redirect to.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Please note that other similarly valid Lua syntax variations (e.g. using quotation marks instead of square brackets, using parentheses around the <code>require</code> parameter, or even whitespace variations) are still not recognized by MediaWiki as redirects.
</div>

<span id="Lua_language"></span>
== Lua-Sprache ==

<span id="Tokens"></span>
=== Token ===

{{Anchor|name}}
''Namen'' (auch ''Bezeichner'' genannt) können in Lua beliebige Buchstaben, Ziffern und Unterstriche sein, die nicht mit einer Ziffer beginnen. Namen unterscheiden zwischen Groß- und Kleinschreibung. "foo", "Foo" und "FOO" sind unterschiedliche Namen.

Folgende Schlüsselwörter sind reserviert und können nicht als Namen verwendet werden:

<div style="margin:0.3em 1.6em; column-width: 10em;">
* <code>and</code>
* <code>break</code>
* <code>do</code>
* <code>else</code>
* <code>elseif</code>
* <code>end</code>
* <code>false</code>
* <code>for</code>
* <code>function</code>
* <code>if</code>
* <code>in</code>
* <code>local</code>
* <code>nil</code>
* <code>not</code>
* <code>or</code>
* <code>repeat</code>
* <code>return</code>
* <code>then</code>
* <code>true</code>
* <code>until</code>
* <code>while</code>
</div>

Namen, die mit einem Unterstrich gefolgt von Großbuchstaben beginnen, sind für interne globale Lua-Variablen reserviert.

Andere Token sind:

<span id="Comments"></span>
=== Kommentare ===

Ein Kommentar beginnt mit einem doppelten Strich <code>--</code> außerhalb einer Zeichenfolge. Wenn dem <code>--</code> unmittelbar eine [[#long brackets|öffnende eckige Klammer]] folgt, so gilt ein Kommentar bis zur entsprechenden schließenden eckigen Klammer. Andernfalls wird der Kommentar bis zum Ende der aktuellen Zeile geführt.

<syntaxhighlight lang="lua">
-- Ein Kommentar beginnt in Lua mit Doppelstrichen end endet am Ende der Zeile.
--[[ Mehrzeilige Zeichenfolgen und Kommentare
     werden von doppelten eckigen Klammern geschmückt. ]]
--[=[ In diesen Kommentaren können andere --[[Kommentare]] verschachtelt sein. ]=]
--[==[ bei Kommentaren wie diese können andere Kommentare enthalten sein
      --[===[ lange --[=[Kommentar]=] --Verschachtelungen
        ]===] mehrmals, auch wenn sie alle
      --[[ nicht durch passende eckige Klammern abgegrenzt sind! ]===]
  ]==]
</syntaxhighlight>

<span id="Data_types"></span>
=== Datentypen ===

Lua ist eine dynamisch-typisierte Sprache, d.h. Variablen und Funktionsargumente haben keinen Typ, sondern nur die ihnen zugewiesenen Werte. Alle Werte tragen einen Typ.

Lua hat acht grundlegende Datentypen, von denen jedoch nur sechs für die Scribunto-Erweiterung relevant sind. Die Funktion <code>[[#type|type()]]</code> gibt den Typ eines Werts zurück.

Die <code>[[#tostring|tostring()]]</code>-Funktion wandelt einen Wert in eine Zeichenfolge, die <code>[[#tonumber|tonumber()]]</code>-Funktion je nach Möglichkeit in eine Zahl um oder gibt andernfalls den Wert „nil“ (nichts) zurück. Es gibt keine ausdrücklichen Funktionen zum Konvertieren eines Werts in andere Datentypen.

Zahlen werden automatisch in Zeichenfolgen umgewandelt, wenn eine Zeichenfolge erwartet wird, z.B. bei Verwendung mit dem Verkettungsoperator. Zeichenfolgen, die von <code>[[#tonumber|tonumber()]]</code> erkannt werden (z.B. 0–9), werden bei Verwendung mit Rechenoperatoren automatisch in Zahlen umgewandelt. Wenn ein boolescher Wert erwartet wird, werden alle Werte außer „nil“ (nichts) und „false“ (unwahr) als „true“ (wahr) betrachtet.

==== nil ====

<div class="mw-translate-fuzzy">
<syntaxhighlight lang="lua" inline>"nil"</syntaxhighlight> (nichts) ist der Datentyp von {{luai|nil}}, der vorhanden ist, um das Nichtvorhandensein eines Werts darzustellen.
</div>

„nil“ darf nicht als Schlüssel in einer Tabelle verwendet werden, und es besteht kein Unterschied zwischen einem nicht zugewiesenen Key und einem Key, dem der Wert „nil“ zugewiesen wurde.

<div class="mw-translate-fuzzy">
Bei Umwandlung in eine Zeichenfolge lautet das Ergebnis <syntaxhighlight lang="lua" inline>"nil"</syntaxhighlight>; bei Umwandlung in einen Booleschen Wert wird „nil“ als „false“ (falsch) gewertet.
</div>

<span lang="en" dir="ltr" class="mw-content-ltr">Note: Lua does make a distinction between {{luai|nil}} and nothing at all in some limited situations.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">For example, {{luai|tostring(nil)}} returns {{luai|"nil"}}, but {{luai|tostring()}} throws an error, as the first parameter is required.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">This distinction is particularly relevant to the [[#select|select()]] function.</span>

==== boolean ====

<div class="mw-translate-fuzzy">
Boolesche Werte werden in {{phpi|true}} (wahr) und {{phpi|false}} (unwahr) unterschieden.
</div>

<div class="mw-translate-fuzzy">
Bei Umwandlung in eine Zeichenfolge ist das Ergebnis {{phpi|true}} oder {{phpi|false}}.
</div>

<div class="mw-translate-fuzzy">
Im Gegensatz zu einigen anderen Programmiersprachen können Boolesche Werte nicht direkt in Zahlen umgewandelt werden. Und im Gegensatz zu einigen anderen Programmiersprachen werden bei der Booleschen Konvertierung nur {{phpi|false}} und „nil“ als falsch betrachtet. Die Zahl „0“ und eine leere Zeichenfolge „“ gelten beide als „true“ (wahr).
</div>

==== string ====

Lua-Zeichenfolgen werden als eine Aneinanderreihung von 8-Bit-Bytes betrachtet. Es liegt an der Anwendung, sie in einer bestimmten Codierung zu interpretieren.

Zeichenketten können durch einfache oder doppelte Anführungszeichen (<code>'</code> oder <code>"</code>) begrenzt werden. Wie bei [[w:de:JavaScript|JavaScript]] und anders als bei [[w:de:PHP|PHP]] gibt es keinen Unterschied zwischen den beiden. Die folgenden [[w:de:Escape-Sequenz|Escape-Sequenzen]] sind verfügbar:

<div style="column-width:20em;">
* <code>\a</code> ([[w:de:Bell (Steuerzeichen)|akustisches Signal]], von englisch {{lang|en|alert}}, Byte 7)
* <code>\b</code> ([[w:de:Backspace|Rückschritt]], von englisch {{lang|en|backspace}}, Byte 8)
* <code>\t</code> (Horizontal-[[w:de:Tabulatorzeichen|Tabulatorzeichen]], von englisch {{lang|en|horizontal tabulator}}, Byte 9)
* <code>\n</code> ([[w:de:Zeilenvorschub|Zeilenvorschub]], von englisch {{lang|en|newline}}, Byte 10)
* <code>\v</code> (Vertikal-Tabulatorzeichen, von englisch {{lang|en|vertical tabulator}}, Byte 11)
* <code>\f</code> (Seitenvorschub, von englisch {{lang|en|form feed}}, Byte 12)
* <code>\r</code> ([[w:de:Wagenrücklauf|Wagenrücklauf]], von englisch {{lang|en|carriage return}}, Byte 13)
* <code>\"</code> (doppeltes [[w:de:Anführungszeichen|Anführungszeichen]], Byte 34)
* <code>\'</code> (einfaches Anführungszeichen, Byte 39)
* <code>\\</code> ([[w:de:Backslash|Backslash]], Byte 92)
</div>

Ein Zeilenumbruch kann auch in eine Zeichenfolge eingefügt werden, indem ein Backslash vorangestellt wird. Bytes können auch mit einer Escape-Sequenz '\''ddd''<nowiki/>' angegeben werden, wobei ''ddd'' der Dezimalwert des Bytes im Bereich von 0 bis 255 ist. Um Unicode-Zeichen mithilfe von Escape-Sequenzen einzubinden, müssen die einzelnen Bytes für die [[:de:UTF-8|UTF-8]] kodiert angegeben werden. Im Allgemeinen ist es einfacher, die Unicode-Zeichen direkt einzugeben.

{{Anchor|long brackets}}
Zeichenketten können auch in eckigen Klammern definiert werden.
Eine öffnende eckige Klammer besteht aus einer öffnenden eckigen Klammer, gefolgt von keinem oder mehreren Gleichheitszeichen, gefolgt von einer anderen öffnenden eckigen Klammer, <code><nowiki>[[</nowiki></code>, <code>[=[</code>, oder <code>[=====[</code>.
Die öffnende eckige Klammer muss mit der entsprechenden schließenden eckigen Klammer übereinstimmen, z. B. <code><nowiki>]]</nowiki></code>, <code>]=]</code>, or <code>]=====]</code>..
Wenn auf eine öffnende lange Klammer unmittelbar eine neue Zeile folgt, wird die neue Zeile nicht in die Zeichenfolge aufgenommen, sondern eine neue Zeile unmittelbar vor der schließenden eckigen Klammer.
Durch eckige Klammern begrenzte Zeichenfolgen interpretieren Escape-Sequenzen nicht.

<syntaxhighlight lang="lua">
-- Diese lange Zeichenfolge
foo = [[
bar\tbaz
]]

-- entspricht dieser durch Anführungszeichen getrennten Zeichenfolge
foo = 'bar\\tbaz\n'
</syntaxhighlight>

Hinweis: Es werden alle Zeichenfolgen als wahr angenommen, wenn sie in einen Booleschen Wert umgewandelt werden. Dies ist anders als in den meisten anderen Programmiersprachen, in denen eine leere Zeichenfolge normalerweise als falsch betrachtet wird.

==== number ====

<div class="mw-translate-fuzzy">
Lua hat nur einen numerischen Typ, der typischerweise als [[:de:Doppelte Genauigkeit|Wert doppelter Genauigkeit]] dargestellt wird. In diesem Format können Ganzzahlen zwischen <code>-9007199254740991</code> (-2<sup>53</sup> + 1) und <code>9007199254740991</code> (2<sup>53</sup> - 1) exakt dargestellt werden, während größere Zahlen und Zahlen mit Gleitkomma-Anteil an Rundungsfehlern leiden können.
</div>

<span class="mw-translate-fuzzy">Zahlenkonstanten werden mit einem Punkt (<code>.</code>) als Dezimaltrennzeichen und ohne Gruppierungstrennzeichen, wie z. B. <code>123456.78</code>, angegeben. Zahlen können auch mittels [[:de:Gleitkommazahl#Exponentialschreibweise|E-Notation]] ohne Leerzeichen dargestellt werden, wie z. B. $1e-10, $1e20, or $1e5. Ganzzahlen können auch in hexadezimaler Schreibweise mittels eines Präfixes $0x, wie z. B. $0x3A, angegeben werden.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">Numbers may also be represented using [[w:E notation|E notation]] without spaces, e.g. <code>1.23e-10</code>, <code>123.45e20</code>, or <code>1.23E+5</code>.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">Integers may also be specified in hexadecimal notation using a <code>0x</code> prefix, e.g. <code>0x3A</code>.</span>

<div class="mw-translate-fuzzy">
[[:de:NaN|NaN]] und positive und negative Unendlichkeit werden jedoch korrekt gespeichert und behandelt, deren entsprechende Literale Lua nicht unterstützt. Die Konstante <code>math.huge</code> ist positive Unendlichkeit genau wie eine Division wie <code>1/0</code>, und eine Division wie <code>0/0</code> kann verwendet werden, um schnell ein NaN zu erzeugen.
</div>

<div class="mw-translate-fuzzy">
Hinweis: Es werden alle Zahlen als wahr angenommen, wenn sie in einen Booleschen Wert umgewandelt werden. Dies ist anders als in den meisten anderen Programmiersprachen, in denen die Zahl 0 normalerweise als falsch betrachtet wird. Bei der Umwandlung in einen String werden endliche Zahlen dezimal dargestellt, möglicherweise in E-Notation; NaN ist <syntaxhighlight lang="lua" inline>"nan"</syntaxhighlight> oder <syntaxhighlight lang="lua" inline>"-nan"</syntaxhighlight>; und Unendlichkeit ist <syntaxhighlight lang="lua" inline>"inf"</syntaxhighlight> oder <syntaxhighlight lang="lua" inline>"-inf"</syntaxhighlight>.
</div>

<span lang="en" dir="ltr" class="mw-content-ltr">{{red|Known bug}}: the Lua interpreter will treat all instances of <code>0</code> '''and''' <code>-0</code> as whichever of the two is encountered first when the script is compiled, which means that the return values of {{luai|tostring(0)}}, {{luai|1/-0}} (and so on) are affected by where they occur in the code.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">This can cause unexpected results, particularly if all instances of <code>0</code> are converted to {{luai|"-0"}} on return.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">If necessary, this can be circumvented by generating zero values using {{luai|tonumber("0")}} and {{luai|tonumber("-0")}}, which doesn't seem to cause or be affected by the issue. See [https://lua-l.lua.narkive.com/k4kbwgKi/tostring-and-0].</span>

==== table ====

Lua-Tabellen sind assoziative Arrays, ähnlich wie PHP-Arrays und JavaScript-Objekte.

Tabellen werden mittels geschweifter Klammern erstellt. Die leere Tabelle ist <code>{}</code>. Um Felder bei der Erstellung auszufüllen, kann eine durch Kommas und/oder Strichpunkten getrennte Liste von Feldbezeichnern in den geschweiften Klammern angegeben werden. Diese können verschiedene Formen annehmen:

* <span class="mw-translate-fuzzy">*<code style="white-space:nowrap">[''[[$anchor1|Ausdruck1]]''] = ''[[$anchor2|Ausdruck2]]''</code> nutzt den (ersten) Wert von ''Ausdruck1'' als Schlüssel und den (ersten) Wert von ''Ausdruck2'' als Wert.
* <code style="white-space:nowrap">''[[$anchor3|Name]]'' = ''[[$anchor4|Ausdruck]]''</code> ist gleichwertig zu <code style="white-space:nowrap">["''Name''"] = ''Ausdruck''</code>
* <code>''[[$anchor5|Ausdruck]]''</code> ist grob gleichwertig zu <code style="white-space:nowrap">[''i''] = ''Ausdruck''</code>, wobei ''i'' eine Ganzzahl ist, die bei 1 beginnt und mit jeder Feldbezeichnung dieser Form erhöht wird. Wenn dies der letzte Feldbezeichner ist und der Ausdruck mehrere Werte enthält, werden alle Werte genutzt; ansonsten wird nur der erste behalten.</span>
* <span lang="en" dir="ltr" class="mw-content-ltr"><code style="white-space:nowrap">''[[#name|name]]'' = ''[[#Expressions|expression]]''</code> is equivalent to <code style="white-space:nowrap">["''name''"] = ''expression''</code></span>
* <span lang="en" dir="ltr" class="mw-content-ltr"><code>''[[#Expressions|expression]]''</code> is roughly equivalent to <code style="white-space:nowrap">[''i''] = ''expression''</code>, where ''i'' is an integer starting at 1 and incrementing with each field specification of this form. If this is the last field specifier and the expression has multiple values, all values are used; otherwise only the first is kept.</span>

Auf die Felder in einer Tabelle wird unter Verwendung der Klammernotation zugegriffen, z. B. <code>table[key]</code>. Auf Zeichenkettenschlüssel, die auch gültige [[#name|Namen]] sind, kann auch mittels der Punktnotation zugegriffen werden, z. B. <code>table.key</code> entspricht <code>table['key']</code>. Das Aufrufen einer Funktion, die ein Wert in der Tabelle ist, kann die Doppelpunktnotation verwenden; zum Beispiel: <code style="white-space:nowrap">table:func( ... )</code>, was gleichwertig ist zu <code style="white-space:nowrap">table['func']( table, ... )</code> oder <code style="white-space:nowrap">table.func( table, ... )</code>.

{{Anchor|sequence}}
<div class="mw-translate-fuzzy">
Eine „Sequenz“ ist eine Tabelle mit nicht-nil-Werten für alle positiven Ganzzahlen von 1 bis N und keinem Wert (nil) für alle positiven Ganzzahlen größer als N. Viele Lua-Funktionen arbeiten nur mit Sequenzen und ignorieren nicht-positiv-ganzzahlige Schlüssel.
</div>

Im Gegensatz zu vielen anderen Sprachen wie PHP oder JavaScript kann jeder Wert außer nil und NaN als Schlüssel genutzt werden, und es wird keine Typumwandlung durchgeführt. Diese sind alle gültig und unterschiedlich:

<syntaxhighlight lang="lua">
-- Tabelle erstellen
t = {}
t["foo"] = "foo"
t.bar = "bar"
t[1] = "eins"
t[2] = "zwei"
t[3] = "drei"
t[12] = "Die Nummer zwölf"
t["12"] = "Die Zeichenfolge zwölf"
t[true] = "true"
t[tonumber] = "yes, even functions may be table keys"
t[t] = "yes, a table may be a table key too. Even in itself."

-- Dies erstellt eine Tabelle grob gleichwertig zur obigen
t2 = {
    foo = "foo",
    bar = "bar",
    "eins",
    "zwei",
    [12] = "Die Nummer zwölf"
    ["12"] = "Die Zeichenfolge zwölf"
    "drei"
    [true] = "true",
    [tonumber] = "yes, even functions may be table keys",
}
t2[t2] = "yes, a table may be a table key too. Even in itself."
</syntaxhighlight>

Ähnlich kann jeder Wert außer nil als Wert in einer Tabelle gespeichert werden. Das Speichern von nil ist gleichwertig zum Löschen des Schlüssels aus der Tabelle, und das Zugreifen auf einen nicht gesetzten Schlüssel führt zu einem nil-Wert.

Hinweis: Tabellen werden in Lua niemals implizit kopiert. Wenn eine Tabelle als Argument an die Funktion übergeben wird und die Funktion die Schlüssel oder Werte in der Tabelle manipuliert, werden diese Änderungen im Aufrufer sichtbar.

Bei der Umwandlung in einen String ist das gewöhnliche Ergebnis „table“, kann aber mittels der <code>__tostring</code>-[[#Metatables|Metamethode]] überschrieben werden. Lediglich die leere Tabelle wird als Boolescher Wert betrachtet.

==== function ====

Funktionen in Lua sind First-Class-Werte: Sie können anonym erstellt, als Argumente übergeben, Variablen zugewiesen usw. werden.

<div class="mw-translate-fuzzy">
Funktionen werden mittels des Schlüsselwortes <code>function</code> erstellt und mittels Klammern aufgerufen. [[:de:Syntaktischer Zucker|Syntaktischer Zucker]] ist für benannte Funktionen, lokale Funktionen und Funktionen, die wie Methoden für eine Tabelle fungieren, verfügbar. Für Einzelheiten siehe unten: [[#Function declarations|Funktionsdeklarationen]] und [[#Function calls|Funktionsaufrufe]].
</div>

<div class="mw-translate-fuzzy">
Lua-Funktionen sind [[:de:Closure (Funktion)|Closures]], das heißt, dass sie einen Verweis auf den Gültigkeitsbereich, in dem sie deklariert sind, enthalten und in diesem Gültigkeitsbereich auf Variablen zugreifen und sie bearbeiten können.
</div>

Wenn eine Funktion wie Tabellen einer anderen Variablen zugewiesen oder als Argument an eine andere Funktion übergeben wird, wird immer noch dasselbe zugrunde liegende „Funktionsobjekt“ aufgerufen.

Bei Umwandlung in eine Zeichenfolge ist das Ergebnis „function“.

<span id="Unsupported_types"></span>
==== Nichtunterstützte Typen ====

{{Anchor|userdata}}
Der „userdata“-Typ wird genutzt, um verschleierte Werte für Erweiterungen von Lua zu speichern, die in anderen Sprachen geschrieben wurden; zum Beispielsweise kann ein „userdata“-Objekt genutzt werden, um einen C-Zeiger oder eine C-Struktur aufzunehmen. Um die Nutzung von Scribunto in Hostumgebungen zu erlauben, wo benutzerdefinierter Code nicht erlaubt ist, werden keine solchen Erweiterungen genutzt.

{{Anchor|thread}}
Der „thread“-Typ repräsentiert die Handles für Coroutinen, die in der Sandbox von Scribunto nicht verfügbar sind.

<span id="Upvalues"></span>
return p

<div lang="en" dir="ltr" class="mw-content-ltr">
There is a strict limit of max 60 unique upvalues acessed inside a function. An upvalue is a value declared outside of a function and used inside it. As upvalues do count:
* variables (a table with many elements counts as one upvalue)
* functions (only those directly called from function in question, not their dependencies)
A violation of the limit can be triggered by a use of such a variable or function, not by its mere presence or availability. Repeated access to same upvalue does not exhaust the limit further.
</div>

<span id="Metatables"></span>
=== Metatabellen ===

Jede Tabelle kann eine zugeordnete Tabelle haben, die als „Metatabelle“ bezeichnet wird. Die Felder in der Metatabelle werden von einigen Operatoren und Funktionen genutzt, um ein anderes oder ein Fallback-Verhalten für die Tabelle anzugeben. Auf die Metatabelle für eine Tabelle kann mittels der Funktion [[#getmetatable|getmetatable()]] zugegriffen und mittels der Funktion [[#setmetatable|setmetatable()]] kann sie festgelegt werden.

Beim Zugriff auf ihre Metafunktionen wird auf Metatabellenfelder wie mit [[#rawget|rawget()]] zugegriffen.

Metatabellenfelder, die die Tabelle selbst betreffen, sind:
; __index
: Dies wird genutzt, wenn ein Tabellenzugriff <code>t[key]</code> nil zurückgeben würde. <span class="mw-translate-fuzzy">Wenn der Wert dieses Feldes eine Tabelle ist, wird der Zugriff in dieser Tabelle wiederholt, d. h. <code>__index[key]</code> (was __index der Metatabelle der Tabelle aufgerufen kann).</span> Wenn der Wert dieses Feldes eine Funktion ist, wird die Funktion als <code style="white-space:nowrap">__index( t, key )</code> aufgerufen. Die Funktion [[#rawget|rawget()]] umgeht diese Metamethode.
; __newindex
: Dies wird genutzt, wenn ein Schlüssel einer Tabelle <code style="white-space:nowrap">t[key] = value</code> zugewiesen wird, wobei <code style="white-space:nowrap">[[#rawget|rawget]]( t, key )</code> nil zurückgeben würde. <span class="mw-translate-fuzzy">Wenn der Wert dieses Feldes eine Tabelle ist, wird der Zugriff in dieser Tabelle wiederholt, d. h. <code>__newindex[key] = value</code> (was __newindex der Metatabelle der Tabelle aufgerufen kann).</span> Wenn der Wert dieses Feldes eine Funktion ist, wird die Funktion als <code style="white-space:nowrap">__newindex( t, key, value )</code> aufgerufen. Die Funktion [[#rawset|rawset()]] umgeht diese Metamethode.
; __call
: Dies wird genutzt, wenn Funktionsaufrufsyntax für eine Tabelle <code style="white-space:nowrap">t( ··· )</code> genutzt wird. <span class="mw-translate-fuzzy">Der Wert muss eine Funktion sein, die wie <code style="white-space:nowrap">__call( t, ··· )</code> aufgerufen wird.</span>
; {{Anchor|weak tables}}__mode
: Dies wird genutzt, um Tabellen zu erstellen, die schwache Referenzen enthalten. Der Wert muss eine Zeichenfolge sein. Standardmäßig wird kein Wert, der als Schlüssel oder als Wert in einer Tabelle verwendet wird, automatisch speicherbereinigt. <span class="mw-translate-fuzzy">Wenn dieses Metafeld jedoch den Buchstaben „k“ enthält, können Schlüssel automatisch speicherbereinigt werden, wenn es keine nichtschwachen Referenzen gibt und wenn es „v“ -Werte enthält; in beiden Fällen werden sowohl der entsprechende Schlüssel als auch der entsprechende Wert aus der Tabelle entfernt.</span> Hinweis: Das Verhalten ist nicht definiert, wenn dieses Feld geändert wird, nachdem die Tabelle als Metatabelle genutzt wurde.

Andere Metatabellenfelder umfassen:

<div style="font-size:smaller">
<div id="binop-note" style="padding:0 1em;text-indent: -1em;"><sup>†</sup> Bei binären Operatoren betrachtet Lua zuerst die Metatabelle des linken Arguments (falls vorhanden) und dann die des rechten Arguments, wenn nach einer zu nutzenden Metamethode gesucht wird.</div>
<div id="relop-note" style="padding:0 1em;text-indent: -1em;"><sup>‡</sup> Bei relationalen Operatoren wird die Metamethode nur genutzt, wenn dieselbe Funktion in den Metatabellen beider Argumente angegeben ist. Unterschiedliche anonyme Funktionen, auch bei identischem Rumpf und Einschluss, können nicht gleich betrachtet werden.</div>
<div id="metatable-note" style="padding:0 1em;text-indent: -1em;"><sup>*</sup> 
<span class="mw-translate-fuzzy">__metatable betrifft sowohl [[$anchor1|getmetatable()]] als auch [[$anchor2|setmetatable()]]</span></div>
</div>

<div class="mw-translate-fuzzy">
Hinweis: In Lua teilen sich alle Zeichenfolgen eine einzige Metatabelle, in der sich <code>__index</code> auf die Tabelle <code>[[#String library|string]]</code> bezieht. Diese Metatabelle ist weder in Scribunto noch die referenzierte Tabelle <code>string</code> zugänglich; die für Module verfügbare Zeichenfolgentabelle ist eine Kopie.
</div>

<span id="Variables"></span>
=== Variablen ===

Variablen sind Stellen, die Werte speichern. Es gibt drei Arten von Variablen in Lua: globale Variablen, lokale Variablen und Tabellenfelder.

<div class="mw-translate-fuzzy">
Ein [[#name|Name]] repräsentiert eine globale oder lokale Variable (oder ein Funktionsargument, das nur eine Art lokale Variable ist). Variablen werden vermutet, global zu sein, außer dass sie ausdrücklich mittels des Schlüsselwortes <code>local</code> als lokal deklariert wurden. Jede Variable, der kein Wert zugewiesen wurde, hat den Wert nil.
</div>

<div class="mw-translate-fuzzy">
Globale Variablen werden in einer Standard-Lua-Tabelle gespeichert, die als „Umgebung“ bezeichnet wird; diese Tabelle ist oft als globale Variable <code>_G</code> verfügbar. Es ist möglich, eine Metatabelle für diese globale Variablentabelle festzulegen; die Metamethoden __index und __newindex werden für Zugriffe auf und Zuweisungen zu globalen Variablen aufgerufen, eben wie sie es für Zugriffe auf und Zuweisungen zu Feldern in anderen Tabellen würden.
</div>

<div class="mw-translate-fuzzy">
Die Umgebung für eine Funktion kann mittels der Funktion [[$anchor1|getfenv()]] Zugriff erfahren und mittels der Funktion [[$anchor2|setfenv()]] geändert werden. In Scribunto sind diese Funktionen stark eingeschränkt, wenn sie überhaupt verfügbar sind.
</div>

Lokale Variablen haben einen lexikalischen Gültigkeitsbereich; siehe [[#Local variable declarations|Lokale Variablendeklarationen]] für Einzelheiten.

<span id="Expressions"></span>
=== Ausdrücke ===

<div lang="en" dir="ltr" class="mw-content-ltr">
An ''expression'' is something that has values: literals (numbers, strings, true, false, nil), anonymous function declarations, table constructors, variable references, function calls, the [[#varargs|vararg expression]], expressions wrapped in parentheses, unary operators applied to expressions, and expressions combined with binary operators.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Most expressions have one value; function calls and the vararg expression can have any number. Note that wrapping a function call or vararg expression in parentheses will lose all except the first value.
</div>

{{Anchor|expression-list|exp-list}}
<div lang="en" dir="ltr" class="mw-content-ltr">
Expression lists are comma-separated lists of expressions. All except the last expression are forced to one value (dropping additional values, or using nil if the expression has no values); all values from the last expression are included in the values of the expression list.
</div>

<span id="Arithmetic_operators"></span>
==== Arithmetische Operatoren ====

Lua unterstützt die üblichen arithmetischen Operatoren: Addition, Subtraktion, Multiplikation, Division, Modulo, Potenzierung und Negation.

<div lang="en" dir="ltr" class="mw-content-ltr">
When all operands are numbers or strings for which [[#tonumber|tonumber()]] returns non-nil, the operations have their usual meaning.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If either operand is a table with an appropriate [[#Metatables|metamethod]], the metamethod will be called.
</div>

{| class="wikitable" style="text-align:center"
|-
! Operator !! Funktion !! Beispiel !! <span lang="en" dir="ltr" class="mw-content-ltr">Metamethod</span> !! Anmerkungen
|-
| + || Addition || a + b || __add ||
|-
| - || Subtraktion || a - b || __sub ||
|-
| * || Multiplikation || a * b || __mul ||
|-
| / || Division || a / b || __div || Geteilt durch null ist kein Fehler; NaN oder infinity wird ausgegeben
|-
| % || Modulo || a % b || __mod || definiert als <code style="white-space:nowrap">a % b == a - math.floor( a / b ) * b</code>
|-
| ^ || Potenzierung || a ^ b || __pow || Nicht-Ganzzahl-Potenzen sind erlaubt
|-
| - || Negation || -a || __unm ||
|}

<div lang="en" dir="ltr" class="mw-content-ltr">
==== Relational operators ====
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The relational operators in Lua are <code>==</code>, <code>~=</code>, <code><</code>, <code>></code>, <code><=</code>, and <code>>=</code>. The result of a relational operator is always a boolean.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Equality (<code>==</code>) first compares the types of its operands; if they are different, the result is false. Then it compares the values: nil, boolean, number, and string are compared in the expected manner. Functions are equal if they refer to the exact same function object; <code style="white-space:nowrap">function() end == function() end</code> will return false, as it is comparing two different anonymous functions. Tables are by default compared in the same manner, but this may be changed using the __eq [[#Metatables|metamethod]].
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Inequality (<code>~=</code>) is the exact negation of equality.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
For the ordering operators, if both are numbers or both are strings, they are compared directly. Next, metamethods are checked:
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* <code style="white-space:nowrap">a < b</code> uses <code>__lt</code>
* <code style="white-space:nowrap">a <= b</code> uses <code>__le</code> if available, or if <code>__lt</code> is available then it is considered equivalent to <code style="white-space:nowrap">not ( b < a )</code>
* <code style="white-space:nowrap">a > b</code> is considered equivalent to <code style="white-space:nowrap">b < a</code>
* <code style="white-space:nowrap">a >= b</code> is considered equivalent to <code style="white-space:nowrap">b <= a</code>
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If the necessary metamethods are not available, an error is raised.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
==== Logical operators ====
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The logical operators are <code>and</code>, <code>or</code>, and <code>not</code>. All use the standard interpretation where nil and false are considered false and anything else is considered true.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
For <code>and</code>, if the left operand is considered false then it is returned and the second operand is not evaluated; otherwise the second operand is returned.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
For <code>or</code>, if the left operand is considered true then it is returned and the second operand is not evaluated; otherwise the second operand is returned.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
For <code>not</code>, the result is always true or false.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that <code>and</code> and <code>or</code> short circuit. For example, <code style="white-space:nowrap">foo() or bar()</code> will only call <code>bar()</code> if <code>foo()</code> returns false or nil as its first value.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
==== Concatenation operator ====
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The concatenation operator is two dots, used as <code style="white-space:nowrap">a .. b</code>. If both operands are numbers or strings, they are converted to strings and concatenated. Otherwise if a __concat [[#Metatables|metamethod]] is available, it is used. Otherwise, an error is raised.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that Lua strings are immutable and Lua does not provide any sort of "string builder", so a loop that repeatedly does <code style="white-space:nowrap">a = a .. b</code> will have to create a new string for each iteration and eventually garbage-collect the old strings. If many strings need concatenating, it may be faster to use [[#string.format|string.format()]] or to insert all the strings into a [[#sequence|sequence]] and use [[#table.concat|table.concat()]] at the end.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
==== Length operator ====
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The length operator is <code>#</code>, used as <code>#a</code>. If <code>a</code> is a string, it returns the length in bytes. If <code>a</code> is a [[#sequence|sequence]] table, it returns the length of the sequence.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If <code>a</code> is a table that is ''not'' a sequence, the <code>#a</code> may return 0 or any value N such that <code>a[N]</code> is not nil and <code>a[N+1]</code> is nil, even if there are non-nil values at higher indexes. For example,
</div>

<syntaxhighlight lang="lua">
-- This is not a sequence, because a[3] is nil and a[4] is not.
a = { 1, 2, nil, 4 }

-- This may output either 2 or 4.
-- And this may change even if the table is not modified.
mw.log( #a )
</syntaxhighlight>
<div lang="en" dir="ltr" class="mw-content-ltr">
==== Operator precedence ====
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Lua's operator precedence or [[w:order of operations|order of operations]], from highest to lowest:
</div>

# <code>^</code>
# <code>not</code> <code>#</code> <code>-</code> <span lang="en" dir="ltr" class="mw-content-ltr">(negation)</span>
# <code>*</code> <code>/</code> <code>%</code>
# <code>+</code> <code>-</code> (Subtraktion)
# <code>..</code>
# <code><</code> <code>></code> <code><=</code> <code>>=</code> <code>~=</code> <code>==</code>
# <code>and</code>
# <code>or</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Within a precedence level, most binary operators are left-associative, i.e. <code style="white-space:nowrap">a / b / c</code> is interpreted as <code style="white-space:nowrap">(a / b) / c</code>. Exponentiation and concatenation are right-associative, i.e. <code style="white-space:nowrap">a ^ b ^ c</code> is interpreted as <code style="white-space:nowrap">a ^ (b ^ c)</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
==== Function calls ====
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Lua function calls look like those in most other languages: a name followed by a list of arguments in parentheses:
</div>

<span lang="en" dir="ltr" class="mw-content-ltr">func</span>( [[#expression-list|''<span lang="en" dir="ltr" class="mw-content-ltr">expression-list</span>'']] )

<div lang="en" dir="ltr" class="mw-content-ltr">
As is usual with expression lists in Lua, the last expression in the list may supply multiple argument values.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If the function is called with fewer values in the expression list than there are arguments in the function definition, the extra arguments will have a nil value. If the expression list contains more values than there are arguments, the excess values are discarded. It is also possible for a function to take a variable number of arguments; see [[#Function declarations|Function declarations]] for details.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Lua also allows direct calling of a function return value, i.e. <code>func()()</code>. If an expression more complex than a variable access is needed to determine the function to be called, a parenthesized expression may be used in place of the variable access.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Lua has syntactic sugar for two common cases. The first is when a table is being used as an object, and the function is to be called as a method on the object. The syntax
</div>

<span lang="en" dir="ltr" class="mw-content-ltr">table:name</span>( [[#expression-list|''<span lang="en" dir="ltr" class="mw-content-ltr">expression-list</span>'']] )

<div lang="en" dir="ltr" class="mw-content-ltr">
is exactly equivalent to
</div>

<span lang="en" dir="ltr" class="mw-content-ltr">table.name</span>( <span lang="en" dir="ltr" class="mw-content-ltr">table</span>, [[#expression-list|''<span lang="en" dir="ltr" class="mw-content-ltr">expression-list</span>'']] )

{{Anchor|named arguments}}
<div lang="en" dir="ltr" class="mw-content-ltr">
The second common case is Lua's method of implementing ''named arguments'' by passing a table containing the name-to-value mappings as the only positional argument to the function. In this case, the parentheses around the argument list may be omitted. This also works if the function is to be passed a single literal string. For example, the calls
</div>

{{pre|1=
func{ arg1 = ''exp'', arg2 = ''exp'' }
func"string"
}}

<div lang="en" dir="ltr" class="mw-content-ltr">
are equivalent to
</div>

{{pre|1=
func( { arg1 = ''exp'', arg2 = ''exp'' } )
func( "string" )
}}

<div lang="en" dir="ltr" class="mw-content-ltr">
These may be combined; the following calls are equivalent:
</div>

{{pre|1=
table:name{ arg1 = ''exp'', arg2 = ''exp'' }
table.name( table, { arg1 = ''exp'', arg2 = ''exp'' } )
}}

<div lang="en" dir="ltr" class="mw-content-ltr">
==== Function declarations ====
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The syntax for function declaration looks like this:
</div>

<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr">
 <span class="kr">function</span> <span class="nf">''name''<sub>optional</sub></span> <span class="p">(</span> <span class="nf">''var-list''<sub>optional</sub></span> <span class="p">)</span>
     [[#block|<span class="nf">''<span lang="en" dir="ltr" class="mw-content-ltr">block</span>''</span>]]
 <span class="kr">end</span>
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
All variables in ''var-list'' are local to the function, with values assigned from the expression list in the [[#Function calls|function call]]. Additional local variables may be declared inside the block.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
When the function is called, the statements in ''block'' are executed after local variables corresponding to ''var-list'' are created and assigned values. If a [[#return|return statement]] is reached, the block is exited and the values of the function call expression are those given by the return statement. If execution reaches the end of the function's block without encountering a return statement, the result of the function call expression has zero values.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Lua functions are [[w:Closure (computer science)|lexical closures]]. A common idiom is to declare "private static" variables as locals in the scope where the function is declared. For example,
</div>

<syntaxhighlight lang="lua">
-- This returns a function that adds a number to its argument
function makeAdder( n )
    return function( x )
        -- The variable n from the outer scope is available here to be added to x
        return x + n
    end
end

local add5 = makeAdder( 5 )
mw.log( add5( 6 ) )
-- prints 11
</syntaxhighlight>

{{Anchor|varargs}}
<div lang="en" dir="ltr" class="mw-content-ltr">
A function may be declared to accept a variable number of arguments, by specifying <code>...</code> as the final item in the ''var-list'':
</div>

<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr">
 <span class="kr">function</span> <span class="nf">''name''<sub>optional</sub></span> <span class="p">(</span> <span class="nf">''var-list''</span><span class="p">,</span> <span class="p">...</span> <span class="p">)</span>
     [[#block|<span class="nf">''<span lang="en" dir="ltr" class="mw-content-ltr">block</span>''</span>]]
 <span class="kr">end</span>
 <span class="c1">-- or</span>
 <span class="kr">function</span> <span class="nf">''name''<sub>optional</sub></span> <span class="p">(</span> <span class="p">...</span> <span class="p">)</span>
     [[#block|<span class="nf">''<span lang="en" dir="ltr" class="mw-content-ltr">block</span>''</span>]]
 <span class="kr">end</span>
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Within the block, the varargs expression <code>...</code> may be used, with the result being all the extra values in the function call. For example,
</div>

<syntaxhighlight lang="lua">
local join = function ( separator, ... )
    -- get the extra arguments as a new table
    local args = { ... }
    -- get the count of extra arguments, correctly
    local n = select( '#', ... )
    return table.concat( args, separator, 1, n )
end

join( ', ', 'foo', 'bar', 'baz' )
-- returns the string "foo, bar, baz"
</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
The [[#select|select()]] function is designed to work with the varargs expression; in particular, <code style="white-space:nowrap">select( '#', ... )</code> should be used instead of <code style="white-space:nowrap">#{ ... }</code> to count the number of values in the varargs expression, because <code style="white-space:nowrap">{ ... }</code> may not be a [[#sequence|sequence]].
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Lua provides syntactic sugar to combine function declaration and assignment to a variable; see [[#Function declaration statements|Function declaration statements]] for details.
</div>

<div class="mw-highlight mw-highlight-lang-lua mw-content-ltr" dir="ltr">
 <span class="kr">local</span> <span class="nf">factorial</span> <span class="o">=</span> <span class="kr">function</span> <span class="p">(</span> <span class="n">n</span> <span class="p">)</span>
     <span class="kr">if</span> <span class="n">n</span> <span class="o">&lt;=</span> <span class="mi">2</span> <span class="kr">then</span>
         <span class="kr">return</span> <span class="n">n</span>
     <span class="kr">else</span>
         <span class="kr">return</span> <span class="n">n</span> <span class="o">*</span> <span class="nf"><s>factorial</s></span><span class="p">(</span> <span class="n">n</span> <span class="o">-</span> <span class="mi">1</span> <span class="p">)</span>
     <span class="kr">end</span>
 <span class="kr">end</span>
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Since the function declaration is processed before the local variable assignment statement is complete, "factorial" inside the function body refers to the (probably undefined) variable of that name in an outer scope. This problem may be avoided by declaring the local variable first and then assigning it in a subsequent statement, or by using the [[#Function declaration statements|function declaration statement]] syntax.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Statements ===
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
A ''statement'' is the basic unit of execution: one assignment, control structure, function call, variable declaration, etc.
</div>

{{Anchor|chunk}}
<div lang="en" dir="ltr" class="mw-content-ltr">
A ''chunk'' is a sequence of statements, optionally separated by semicolons. A chunk is basically considered the body of an anonymous function, so it can declare local variables, receive arguments, and return values.
</div>

{{Anchor|block}}
<div lang="en" dir="ltr" class="mw-content-ltr">
A ''block'' is also a sequence of statements, just like a chunk. A block can be delimited to create a single statement: {{tmpl|0=<code style="white-space:nowrap">do ''$1'' end</code>|block}}. These may be used to limit the scope of local variables, or to add a <code>return</code> or <code>break</code> in the middle of another block.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
==== Assignments ====
</div>
<code style="white-space:nowrap">''<span lang="en" dir="ltr" class="mw-content-ltr">variable-list</span>'' = [[#expression-list|''<span lang="en" dir="ltr" class="mw-content-ltr">expression-list</span>'']]</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
The ''variable-list'' is a comma-separated list of variables; the ''expression-list'' is a comma-separated list of one or more expressions. All expressions are evaluated before any assignments are performed, so <code style="white-space:nowrap">a, b = b, a</code> will swap the values of <var>a</var> and <var>b</var>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
==== Local variable declarations ====
</div>
<code style="white-space:nowrap">local ''<span lang="en" dir="ltr" class="mw-content-ltr">variable-list</span>''</code>

<code style="white-space:nowrap">local ''<span lang="en" dir="ltr" class="mw-content-ltr">variable-list</span>'' = [[#expression-list|''<span lang="en" dir="ltr" class="mw-content-ltr">expression-list</span>'']]</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Local variables may be declared anywhere within a [[#block|block]] or [[#block|chunk]]. The first form, without an expression list, declares the variables but does not assign a value so all variables have nil as a value. The second form assigns values to the local variables, as described in [[#Assignments|Assignments]] above.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that visibility of the local variable begins with the statement after the local variable declaration. So a declaration like <code style="white-space:nowrap">local x = x</code> declares a local variable x and assigns it the value of x from the outer scope. The local variable remains in scope until the end of the innermost block containing the local variable declaration.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
==== Control structures ====
</div>
{{Anchor|while}}
<code style="white-space:nowrap">while ''<span lang="en" dir="ltr" class="mw-content-ltr">exp</span>'' do ''[[#block|<span lang="en" dir="ltr" class="mw-content-ltr">block</span>]]'' end</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
The while statement repeats a block as long as an expression evaluates to a true value.
</div>

{{Anchor|repeat}}
<code style="white-space:nowrap">repeat ''[[#block|<span lang="en" dir="ltr" class="mw-content-ltr">block</span>]]'' until ''<span lang="en" dir="ltr" class="mw-content-ltr">exp</span>''</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
The repeat statement repeats a block until an expression evaluates to a true value. Local variables declared inside the block may be accessed in the expression.
</div>

{{Anchor|for}}
<code style="white-space:nowrap">for <span lang="en" dir="ltr" class="mw-content-ltr">''name'' = ''exp1'', ''exp2'', ''exp3''</span> do ''[[#block|<span lang="en" dir="ltr" class="mw-content-ltr">block</span>]]'' end</code><br/>
<code style="white-space:nowrap">for <span lang="en" dir="ltr" class="mw-content-ltr">''name'' = ''exp1'', ''exp2''</span> do ''[[#block|<span lang="en" dir="ltr" class="mw-content-ltr">block</span>]]'' end</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
This first form of the for loop will declare a local variable, and repeat the block for values from ''exp1'' to ''exp2'' adding ''exp3'' on each iteration. Note that ''exp3'' may be omitted entirely, in which case 1 is used, but non-numeric values such as <code>nil</code> and <code>false</code> are an error. All expressions are evaluated once before the loop is started.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
This form of the for loop is roughly equivalent to
</div>
<syntaxhighlight lang="lua">
do
    local var, limit, step = tonumber( exp1 ), tonumber( exp2 ), tonumber( exp3 )
    if not ( var and limit and step ) then
        error()
    end
    while ( step > 0 and var <= limit ) or ( step <= 0 and var >= limit ) do
        local name = var
        block
        var = var + step
    end
end
</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
except that the variables var, limit, and step are not accessible anywhere else. Note that the variable ''name'' is local to the block; to use the value after the loop, it must be copied to a variable declared outside the loop.
</div>

{{Anchor|iterators}}
<code style="white-space:nowrap">for ''<span lang="en" dir="ltr" class="mw-content-ltr">var-list</span>'' in [[#expression-list|''<span lang="en" dir="ltr" class="mw-content-ltr">expression-list</span>'']] do ''[[#block|<span lang="en" dir="ltr" class="mw-content-ltr">block</span>]]'' end</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
The second form of the for loop works with ''iterator'' functions. As in the first form, the ''expression-list'' is evaluated only once before beginning the loop.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
This form of the for loop is roughly equivalent to
</div>
<syntaxhighlight lang="lua">
do
    local func, static, var = expression-list
    while true do
        local var-list = func( static, var )
        var = var1  -- ''var1'' is the first variable in ''var-list''
        if var == nil then
            break
        end
        block
    end
end
</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
except that again the variables func, static, and var are not accessible anywhere else. Note that the variables in ''var-list'' are local to the block; to use them after the loop, they must be copied to variables declared outside the loop.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Often the ''expression-list'' is a single function call that returns the three values. If the iterator function can be written so it only depends on the parameters passed into it, that would be the most efficient. If not, [https://www.lua.org/pil/7.4.html Programming in Lua] suggests that a closure be preferred to returning a table as the static variable and updating its members on each iteration.
</div>

{{Anchor|if}}
<code style="white-space:nowrap">if ''<span lang="en" dir="ltr" class="mw-content-ltr">exp1</span>'' then ''[[#block|<span lang="en" dir="ltr" class="mw-content-ltr">block1</span>]]'' elseif ''<span lang="en" dir="ltr" class="mw-content-ltr">exp2</span>'' then ''[[#block|<span lang="en" dir="ltr" class="mw-content-ltr">block2</span>]]'' else ''[[#block|<span lang="en" dir="ltr" class="mw-content-ltr">block3</span>]]'' end</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Executes ''block1'' if ''exp1'' returns true, otherwise executes ''block2'' if ''exp2'' returns true, and ''block3'' otherwise. The <code style="white-space:nowrap">else ''block3''</code> portion may be omitted, and the <code style="white-space:nowrap">elseif ''exp2'' then ''block2''</code> portion may be repeated or omitted as necessary.
</div>

{{Anchor|return}}
<code style="white-space:nowrap">return [[#expression-list|''<span lang="en" dir="ltr" class="mw-content-ltr">expression-list</span>'']]</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
The return statement is used to return values from a function or a [[#chunk|chunk]] (which is just a function). The ''expression-list'' is a comma-separated list of zero or more expressions.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Lua implements [[w:tail call|tail calls]]: if ''expression-list'' consists of exactly one expression which is a function call, the current stack frame will be reused for the call to that function. This has implication for functions that deal with the call stack, such as <code>[[#getfenv|getfenv()]]</code> and <code>[[#debug.traceback|debug.traceback()]]</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The return statement must be the last statement in its [[#block|block]]. If for some reason a return is needed in the middle of a block, an explicit block <code style="white-space:nowrap">do return end</code> may be used.
</div>

{{Anchor|break}}
<code>break</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
The break statement is used to terminate the execution of a while, repeat, or for loop, skipping to the next statement after the loop.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The break statement must be the last statement in its [[#block|block]]. If for some reason a break is needed in the middle of a block, an explicit block <code style="white-space:nowrap">do break end</code> may be used.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Unlike some other languages, Lua does not have a "continue" statement for loops (i.e. a statement to move onto the next iteration without breaking the loop altogether).
</div>
<span lang="en" dir="ltr" class="mw-content-ltr">It is straightforward to achieve the same effect by nesting a <code style="white-space:nowrap">repeat ... until true</code> block immediately inside the main loop, which will only ever iterate once for each iteration of the main loop (as its condition is always true).</span>
<span lang="en" dir="ltr" class="mw-content-ltr">Using <code style="white-space:nowrap">break</code> will only end the inner loop, which has the practical effect of causing the main loop to continue onto the next iteration.</span>
<div lang="en" dir="ltr" class="mw-content-ltr">
If it is necessary to use <code style="white-space:nowrap">break</code> on the main loop, simply declare a variable which is checked each time the inner loop completes, and set it when necessary.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
==== Function calls as statements ====
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
A function call may be used as a statement; in this case, the function is being called only for any side effects it may have (e.g. [[#mw.log|mw.log()]] logs values) and any return values are discarded.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
==== Function declaration statements ====
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Lua provides syntactic sugar to make declaring a function and assigning it to a variable more natural. The following pairs of declarations are equivalent
</div>

-- <span lang="en" dir="ltr" class="mw-content-ltr">Basic declaration</span>
 function func( ''var-list'' ) <span lang="en" dir="ltr" class="mw-content-ltr">''[[#block|block]]''</span> end
 func = function ( ''var-list'' ) <span lang="en" dir="ltr" class="mw-content-ltr">''[[#block|block]]''</span> end

-- <span lang="en" dir="ltr" class="mw-content-ltr">Local function</span>
 local function func( ''var-list'' ) <span lang="en" dir="ltr" class="mw-content-ltr">''[[#block|block]]''</span> end
 local func; func = function ( ''var-list'' ) <span lang="en" dir="ltr" class="mw-content-ltr">''[[#block|block]]''</span> end

-- <span lang="en" dir="ltr" class="mw-content-ltr">Function as a field in a table</span>
 function table.func( ''var-list'' ) <span lang="en" dir="ltr" class="mw-content-ltr">''[[#block|block]]''</span> end
 table.func = function ( ''var-list'' ) <span lang="en" dir="ltr" class="mw-content-ltr">''[[#block|block]]''</span> end

-- <span lang="en" dir="ltr" class="mw-content-ltr">Function as a method in a table</span>
 function table:func( ''var-list'' ) <span lang="en" dir="ltr" class="mw-content-ltr">''[[#block|block]]''</span> end
 table.func = function ( self, ''var-list'' ) <span lang="en" dir="ltr" class="mw-content-ltr">''[[#block|block]]''</span> end

<div lang="en" dir="ltr" class="mw-content-ltr">
Note the colon notation here parallels the colon notation for [[#Function calls|function calls]], adding an implicit argument named <code>self</code> at the beginning of the arguments list.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Error handling ===
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Errors may be "thrown" using the [[#error|error()]] and [[#assert|assert()]] functions. To "catch" errors, use [[#pcall|pcall()]] or [[#xpcall|xpcall()]]. Note that certain internal Scribunto errors cannot be caught in Lua code.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Garbage collection ===
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Lua performs automatic memory management. This means that you have to worry neither about allocating memory for new objects nor about freeing it when the objects are no longer needed. Lua manages memory automatically by running a ''garbage collector'' from time to time to collect all dead objects (that is, objects that are no longer accessible from Lua) and objects that are only reachable via [[#weak tables|weak references]]. All memory used by Lua is subject to automatic management: tables, functions, strings, etc.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Garbage collection happens automatically, and cannot be configured from within Scribunto.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
== Standard libraries ==
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The standard Lua libraries provide essential services and performance-critical functions to Lua. Only those portions of the standard libraries that are available in Scribunto are documented here.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Basic functions ===
</div>

==== _G ====
<span id="_G"></span>

<div lang="en" dir="ltr" class="mw-content-ltr">
This variable holds a reference to the current global variable table; the global variable <code>foo</code> may also be accessed as <code>_G.foo</code>. Note, however, that there is nothing special about _G itself; it may be reassigned in the same manner as any other variable:
</div>

<syntaxhighlight lang="lua">
foo = 1
mw.log( foo ) -- logs "1"
_G.foo = 2
mw.log( foo ) -- logs "2"
_G = {}       -- _G no longer points to the global variable table
_G.foo = 3
mw.log( foo ) -- still logs "2"
</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
The global variable table may be used just like any other table. For example,
</div>

<syntaxhighlight lang="lua">
-- Call a function whose name is stored in a variable
_G[var]()

-- Log the names and stringified values of all global variables
for k, v in pairs( _G ) do
   mw.log( k, v )
end

-- Log the creation of new global variables
setmetatable( _G, {
    __newindex = function ( t, k, v )
         mw.log( "Creation of new global variable '" .. k .. "'" )
         rawset( t, k, v )
    end
} )
</syntaxhighlight>

==== _VERSION ====
<span id="_VERSION"></span>

<div lang="en" dir="ltr" class="mw-content-ltr">
A string containing the running version of Lua, e.g. "Lua 5.1".
</div>

==== assert ====
<code style="white-space:nowrap">assert( v, message, ... )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
If <code>v</code> is nil or false, issues an error. In this case, <code>message</code> is used as the text of the error: if nil (or unspecified), the text is "assertion failed!"; if a string or number, the text is that value; otherwise assert itself will raise an error.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If <code>v</code> is any other value, assert returns all arguments including <code>v</code> and <code>message</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
A somewhat common idiom in Lua is for a function to return a "true" value in normal operation, and on failure return nil or false as the first value and an error message as the second value. Easy error checking can then be implemented by wrapping the call in a call to <code>assert</code>:
</div>

<syntaxhighlight lang="lua">
-- This doesn't check for errors
local result1, result2, etc = func( ... )

-- This works the same, but does check for errors
local result1, result2, etc = assert( func( ... ) )
</syntaxhighlight>

==== error ====
<code style="white-space:nowrap">error( message, level )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Issues an error, with text <code>message</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
<code>error</code> normally adds some information about the location of the error. If <code>level</code> is 1 or omitted, that information is the location of the call to <code>error</code> itself; 2 uses the location of the call of the function that called error; and so on. Passing 0 omits inclusion of the location information.
</div>

==== getfenv ====
<code style="white-space:nowrap">getfenv( f )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note this function may not be available, depending on <code>allowEnvFuncs</code> in the engine configuration.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns an ''environment'' (global variable table), as specified by <code>f</code>:
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* If 1, nil, or omitted, returns the environment of the function calling <code>getfenv</code>. Often this will be the same as [[#_G|_G]].
* Integers 2–10 return the environment of functions higher in the call stack. For example, 2 returns the environment for the function that called the current function, 3 returns the environment for the function calling that function, and so on. An error will be raised if the value is higher than the number of function calls in the stack, or if the targeted stack level returned with a tail call.
* Passing a function returns the environment that will be used when that function is called.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The environments used by all standard library functions and Scribunto library functions are protected. Attempting to access these environments using <code>getfenv</code> will return nil instead.
</div>

==== getmetatable ====
<code style="white-space:nowrap">getmetatable( table )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the [[#Metatables|metatable]] of a [[#table|table]]. Any other type will return nil.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If the metatable has a <code>__metatable</code> field, that value will be returned instead of the actual metatable.
</div>

==== ipairs ====
<code style="white-space:nowrap">ipairs( t )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns three values: an iterator function, the table <code>t</code>, and 0. This is intended for use in the [[#iterators|iterator form of <code>for</code>]]:
</div>

<syntaxhighlight lang="lua">
for i, v in ipairs( t ) do
    -- process each index-value pair
end
</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
This will iterate over the pairs ( 1, t[1] ), ( 2, t[2] ), and so on, stopping when t[i] would be nil.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The standard behavior may be overridden by providing an <code>__ipairs</code> [[#Metatables|metamethod]]. If that metamethod exists, the call to ipairs will return the three values returned by <code style="white-space:nowrap">__ipairs( t )</code> instead.
</div>

==== next ====
<code style="white-space:nowrap">next( table, key )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
This allows for iterating over the keys in a table. If <code>key</code> is nil or unspecified, returns the "first" key in the table and its value; otherwise, it returns the "next" key and its value. When no more keys are available, returns nil. It is possible to check whether a table is empty using the expression <code style="white-space:nowrap">next( t ) == nil</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that the order in which the keys are returned is not specified, even for tables with numeric indexes. To traverse a table in numerical order, use a [[#for|numerical for]] or [[#ipairs|ipairs]].
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Behavior is undefined if, when using next for traversal, any non-existing key is assigned a value. Assigning a new value (including nil) to an existing field is allowed.
</div>

==== pairs ====
<code style="white-space:nowrap">pairs( t )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns three values: an iterator function ([[#next|next]] or a work-alike), the table <code>t</code>, and nil. This is intended for use in the [[#iterators|iterator form of <code>for</code>]]:
</div>

<syntaxhighlight lang="lua">
for k, v in pairs( t ) do
    -- process each key-value pair
end
</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
This will iterate over the key-value pairs in <code>t</code> just as [[#next|next]] would; see the documentation for [[#next|next]] for restrictions on modifying the table during traversal.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The standard behavior may be overridden by providing a __pairs [[#Metatables|metamethod]]. If that metamethod exists, the call to pairs will return the three values returned by <code style="white-space:nowrap">__pairs( t )</code> instead.
</div>

==== pcall ====
<code style="white-space:nowrap">pcall( f, ... )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Calls the function <code>f</code> with the given arguments in ''protected mode''. This means that if an error is raised during the call to <code>f</code>, pcall will return false and the error message raised. If no error occurs, pcall will return true and all values returned by the call.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
In [[w:pseudocode|pseudocode]], <code>pcall</code> might be defined something like this:
</div>

<syntaxhighlight lang="lua">
function pcall( f, ... )
    try
        return true, f( ... )
    catch ( message )
        return false, message
    end
end
</syntaxhighlight>

==== rawequal ====
<code style="white-space:nowrap">rawequal( a, b )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
This is equivalent to <code style="white-space:nowrap">a == b</code> except that it ignores any __eq [[#Metatables|metamethod]].
</div>

==== rawget ====
<code style="white-space:nowrap">rawget( table, k )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
This is equivalent to <code>table[k]</code> except that it ignores any __index [[#Metatables|metamethod]].
</div>

==== rawset ====
<code style="white-space:nowrap">rawset( table, k, v )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
This is equivalent to <code style="white-space:nowrap">table[k] = v</code> except that it ignores any __newindex [[#Metatables|metamethod]].
</div>

==== select ====
<code style="white-space:nowrap">select( index, ... )</code>

<span lang="en" dir="ltr" class="mw-content-ltr">If <code>index</code> is a number, returns all arguments in <code>...</code> from that index onwards.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">If <code>index</code> is the string {{luai|"#"}}, returns the number of arguments in <code>...</code>.</span>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note: unlike tables, lists of arguments (including the [[#varargs|vararg expression]] <code>...</code>) treat {{luai|nil}} as a distinct value (see documentation for [[#Length operator|#]] and [[#unpack|unpack]] for the problem with {{luai|nil}} in tables). For example:
* {{luai|select(2, "foo", "bar")}} returns {{luai|"bar"}}.
* {{luai|select(2, "foo", nil, "bar", nil)}} returns {{luai|nil, "bar", nil}}.
* {{luai|select("#", "foo", "bar")}} returns {{luai|2}}.
* {{luai|select("#", "foo", "bar", nil)}} returns {{luai|3}}.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
In other words, <code>select</code> is roughly like the following (except that it also handles any {{luai|nil}} arguments after the final non-nil argument):
</div>

<syntaxhighlight lang="lua">
function select( index, ... )
    local t = { ... }
    local maxindex = table.maxn( t )
    if index == "#" then
        return maxindex
    else
        return unpack( t, index, maxindex )
    end
end
</syntaxhighlight>

==== setmetatable ====
<code style="white-space:nowrap">setmetatable( table, metatable )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Sets the [[#Metatables|metatable]] of a [[#table|table]]. <code>metatable</code> may be nil, but must be explicitly provided.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If the current metatable has a __metatable field, <code>setmetatable</code> will throw an error.
</div>

==== tonumber ====
<code style="white-space:nowrap">tonumber( value, base )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Tries to convert <code>value</code> to a number. If it is already a number or a string convertible to a number, then <code>tonumber</code> returns this number; otherwise, it returns nil.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The optional <code>base</code> (default 10) specifies the base to interpret the numeral. The base may be any integer between 2 and 36, inclusive. In bases above 10, the letter 'A' (in either upper or lower case) represents 10, 'B' represents 11, and so forth, with 'Z' representing 35.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
In base 10, the value may have a decimal part, be expressed in [[w:E notation|E notation]], and may have a leading "0x" to indicate base 16. In other bases, only unsigned integers are accepted.
</div>

==== tostring ====
<code style="white-space:nowrap">tostring( value )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Converts <code>value</code> to a string. See [[#Data types|Data types]] above for details on how each type is converted.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The standard behavior for tables may be overridden by providing a __tostring [[#Metatables|metamethod]]. If that metamethod exists, the call to tostring will return the single value returned by <code style="white-space:nowrap">__tostring( value )</code> instead.
</div>

==== type ====
<code style="white-space:nowrap">type( value )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the type of <code>value</code> as a string: <code>"[[#nil|nil]]"</code>, <code>"[[#number|number]]"</code>, <code>"[[#string|string]]"</code>, <code>"[[#boolean|boolean]]"</code>, <code>"[[#table|table]]"</code>, or <code>"[[#function|function]]"</code>.
</div>

==== unpack ====
<code style="white-space:nowrap">unpack( table, i, j )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns values from the given table, something like <code style="white-space:nowrap">table[i], table[i+1], ···, table[j]</code> would do if written out manually. If nil or not given, <code>i</code> defaults to 1 and <code>j</code> defaults to <code style="white-space:nowrap">[[#Length operator|#]]table</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If the table does not have a value for a particular key, unpack will return nil for that value. For example, {{luai|1=unpack({"foo", [3] = "bar"}, 1, 4)}} returns {{luai|"foo", nil, "bar", nil}}.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that results are not deterministic if <code>table</code> is not a [[#sequence|sequence]] and <code>j</code> is nil or unspecified; see [[#Length operator|Length operator]] for details.
</div>

==== xpcall ====
<code style="white-space:nowrap">xpcall( f, errhandler )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
This is much like <code>[[#pcall|pcall]]</code>, except that the error message is passed to the function <code>errhandler</code> before being returned.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
In [[w:pseudocode|pseudocode]], <code>xpcall</code> might be defined something like this:
</div>

<syntaxhighlight lang="lua">
function xpcall( f, errhandler )
    try
        return true, f()
    catch ( message )
        message = errhandler( message )
        return false, message
    end
end
</syntaxhighlight>
<div lang="en" dir="ltr" class="mw-content-ltr">
=== Debug library ===
</div>

==== debug.traceback ====
<code style="white-space:nowrap"><span lang="en" dir="ltr" class="mw-content-ltr">debug.traceback( message, level )</span></code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a string with a traceback of the call stack. An optional message string is appended at the beginning of the traceback. An optional level number tells at which stack level to start the traceback.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Math library ===
</div>

==== math.abs ====
<code style="white-space:nowrap">math.abs( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the absolute value of <code>x</code>.
</div>

==== math.acos ====
<code style="white-space:nowrap">math.acos( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the arc cosine of <code>x</code> (given in radians).
</div>

==== math.asin ====
<code style="white-space:nowrap">math.asin( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the arc sine of <code>x</code> (given in radians).
</div>

==== math.atan ====
<code style="white-space:nowrap">math.atan( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the arc tangent of <code>x</code> (given in radians).
</div>

==== math.atan2 ====
<code style="white-space:nowrap">math.atan2( y, x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the arc tangent of <code>y/x</code> (given in radians), using the signs of both parameters to find the quadrant of the result.
</div>

==== math.ceil ====
<code style="white-space:nowrap">math.ceil( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the smallest integer larger than or equal to <code>x</code>.
</div>

==== math.cos ====
<code style="white-space:nowrap">math.cos( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the cosine of <code>x</code> (given in radians).
</div>

==== math.cosh ====
<code style="white-space:nowrap">math.cosh( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the hyperbolic cosine of <code>x</code>.
</div>

==== math.deg ====
<code style="white-space:nowrap">math.deg( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the angle <code>x</code> (given in radians) in degrees.
</div>

==== math.exp ====
<code style="white-space:nowrap">math.exp( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the value <math>e^x</math>.
</div>

==== math.floor ====
<code style="white-space:nowrap">math.floor( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the largest integer smaller than or equal to <code>x</code>.
</div>

==== math.fmod ====
<code style="white-space:nowrap">math.fmod( x, y )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the remainder of the division of <code>x</code> by <code>y</code> that rounds the quotient towards zero. For example, <code>math.fmod( 10, 3 )</code> yields <code>1</code>.
</div>

==== math.frexp ====
<code style="white-space:nowrap">math.frexp( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns two values <code>m</code> and <code>e</code> such that:
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* If <code>x</code> is finite and non-zero: <math>x = m \times 2^e</math>, <code>e</code> is an integer, and the absolute value of <code>m</code> is in the range <math>[0.5, 1)</math>
* If <code>x</code> is zero: <code>m</code> and <code>e</code> are 0
* If <code>x</code> is NaN or infinite: <code>m</code> is <code>x</code> and <code>e</code> is not specified
</div>
==== math.huge ====
<div lang="en" dir="ltr" class="mw-content-ltr">
The value representing positive infinity; larger than or equal to any other numerical value.
</div>

==== math.ldexp ====
<code style="white-space:nowrap">math.ldexp( m, e )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns <math>m \times 2^e</math> (<code>e</code> should be an integer).
</div>

==== math.log ====
<code style="white-space:nowrap">math.log( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the natural logarithm of <code>x</code>.
</div>

==== math.log10 ====
<code style="white-space:nowrap">math.log10( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the base-10 logarithm of <code>x</code>.
</div>

==== math.max ====
<code style="white-space:nowrap">math.max( x, ... )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the maximum value among its arguments.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Behavior with NaNs is not specified. With the current implementation, NaN will be returned if <code>x</code> is NaN, but any other NaNs will be ignored.
</div>

==== math.min ====
<code style="white-space:nowrap">math.min( x, ... )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the minimum value among its arguments.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Behavior with NaNs is not specified. With the current implementation, NaN will be returned if <code>x</code> is NaN, but any other NaNs will be ignored.
</div>

==== math.modf ====
<code style="white-space:nowrap">math.modf( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns two numbers, the integral part of <code>x</code> and the fractional part of <code>x</code>. For example, <code>math.modf( 1.25 )</code> yields <code>1, 0.25</code>.
</div>

==== math.pi ====
<div lang="en" dir="ltr" class="mw-content-ltr">
The value of <math>\pi</math>.
</div>

==== math.pow ====
<code style="white-space:nowrap">math.pow( x, y )</code>

Äquivalent zu <code>x^y</code>.

==== math.rad ====
<code style="white-space:nowrap">math.rad( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the angle <code>x</code> (given in degrees) in radians.
</div>

==== math.random ====
<code style="white-space:nowrap">math.random( m, n )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a pseudo-random number.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The arguments <code>m</code> and <code>n</code> may be omitted, but if specified must be convertible to integers.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* With no arguments, returns a real number in the range <math>[0,1)</math>
* With one argument, returns an integer in the range <math>[1,m]</math>
* With two arguments, returns an integer in the range <math>[m,n]</math>
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that incorrect output may be produced if <code>m</code> or <code>n</code> are less than −2147483648 or greater than 2147483647, or if <code>n - m</code> is greater than 2147483646.
</div>

==== math.randomseed ====
<code style="white-space:nowrap">math.randomseed( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Sets <code>x</code> as the [[w:Random seed|seed]] for the pseudo-random generator.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that using the same seed will cause <code>math.random</code> to output the same sequence of numbers.
</div>

<syntaxhighlight lang="lua">
math.randomseed( tonumber( mw.getContentLanguage():formatDate( "U" ) ) * 10000 + os.clock() * 10000 )
</syntaxhighlight>

==== math.sin ====
<code style="white-space:nowrap">math.sin( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the sine of <code>x</code> (given in radians).
</div>

==== math.sinh ====
<code style="white-space:nowrap">math.sinh( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the hyperbolic sine of <code>x</code>.
</div>

==== math.sqrt ====
<code style="white-space:nowrap">math.sqrt( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the square root of <code>x</code>. Equivalent to <code>x^0.5</code>.
</div>

==== math.tan ====
<code style="white-space:nowrap">math.tan( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the tangent of <code>x</code> (given in radians).
</div>

==== math.tanh ====
<code style="white-space:nowrap">math.tanh( x )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the hyperbolic tangent of <code>x</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Operating system library ===
</div>

==== os.clock ====
<code>os.clock()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns an approximation of the amount in seconds of CPU time used by the program.
</div>

==== os.date ====
<code style="white-space:nowrap">os.date( format, time )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
: ''[[#mw.language:formatDate|Language library's formatDate]] may be used for more comprehensive date formatting''
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a string or a table containing date and time, formatted according to <code>format</code>. If the format is omitted or nil, "%c" is used.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If <code>time</code> is given, it is the time to be formatted (see <code>[[#os.time|os.time()]]</code>). Otherwise the current time is used.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If <code>format</code> starts with '!', then the date is formatted in UTC rather than the server's local time. After this optional character, if format is the string "*t", then date returns a table with the following fields:
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* year (full)
* month (1–12)
* day (1–31)
* hour (0–23)
* min (0–59)
* sec (0–60, to allow for [[w:leap second|leap seconds]])
* wday (weekday, Sunday is 1)
* yday (day of the year)
* isdst (daylight saving flag, a boolean; may be absent if the information is not available)
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If format is not "*t", then date returns the date as a string, formatted according to the same rules as the C function [http://man7.org/linux/man-pages/man3/strftime.3.html strftime].
</div>

==== os.difftime ====
<code style="white-space:nowrap">os.difftime( t2, t1 )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the number of seconds from <code>t1</code> to <code>t2</code>.
</div>

==== os.time ====
<code style="white-space:nowrap">os.time( table )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a number representing the current [[w:Unix time|Unix time]].
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
When called without arguments, returns the current time. If passed a table, the time encoded in the table will be parsed. The table must have the fields "year", "month", and "day", and may also include "hour" (default 12), "min" (default 0), "sec" (default 0), and "isdst".
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Package library ===
</div>

==== require ====
<code style="white-space:nowrap">require( modulename )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Loads the specified module.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
First, it looks in <code>package.loaded[modulename]</code> to see if the module is already loaded. If so, returns <code>package.loaded[modulename]</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Otherwise, it calls each loader in the <code>package.loaders</code> sequence to attempt to find a loader for the module. If a loader is found, that loader is called. The value returned by the loader is stored into <code>package.loaded[modulename]</code> and is returned.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
See the documentation for <code>[[#package.loaders|package.loaders]]</code> for information on the loaders available.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
For example, if you have a module "Module:Giving" containing the following:
</div>

<syntaxhighlight lang="lua">
local p = {}

p.someDataValue = 'Hello!'

return p
</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
You can load this in another module with code such as this:
</div>

<syntaxhighlight lang="lua">
local giving = require( "Module:Giving" )

local value = giving.someDataValue -- value is now 'Hello!'
</syntaxhighlight>

==== package.loaded ====
<div lang="en" dir="ltr" class="mw-content-ltr">
This table holds the loaded modules. The keys are the module names, and the values are the values returned when the module was loaded.
</div>
==== package.loaders ====
<div lang="en" dir="ltr" class="mw-content-ltr">
This table holds the sequence of searcher functions to use when loading modules. Each searcher function is called with a single argument, the name of the module to load. If the module is found, the searcher must return a function that will actually load the module and return the value to be returned by [[#require|require]]. Otherwise, it must return nil.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Scribunto provides two searchers:
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
# Look in <code>package.preload[modulename]</code> for the loader function
# Look in the [[#Loadable libraries|modules provided with Scribunto]] for the module name, and if that fails look in the Module: namespace. The "Module:" prefix must be provided.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that the standard Lua loaders are '''not''' included.
</div>
==== package.preload ====
<div lang="en" dir="ltr" class="mw-content-ltr">
This table holds loader functions, used by the first searcher Scribunto includes in [[#package.loaders|package.loaders]].
</div>

==== package.seeall ====
<code style="white-space:nowrap">package.seeall( table )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Sets the __index [[#Metatables|metamethod]] for <code>table</code> to [[#_G|_G]].
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
=== String library ===
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
In all string functions, the first character is at position&nbsp;1, not position&nbsp;0 as in C, PHP, and JavaScript. Indexes may be negative, in which case they count from the end of the string: position&nbsp;-1 is the last character in the string, -2 is the second-last, and so on.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
{{red|Warning:}} The string library assumes one-byte character encodings. '''It cannot handle Unicode characters'''. To operate on Unicode strings, use the corresponding methods in the [[#Ustring library|Scribunto Ustring library]].
</div>

==== string.byte ====
<code style="white-space:nowrap">string.byte( s, i, j )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
If the string is considered as an array of bytes, returns the byte values for <code>s[i]</code>, <code>s[i+1]</code>, ···, <code>s[j]</code>.
The default value for <code>i</code> is&nbsp;1;
the default value for <code>j</code> is&nbsp;<code>i</code>.
Identical to [[#mw.ustring.byte|mw.ustring.byte()]].
</div>

==== string.char ====
<code style="white-space:nowrap">string.char( ... )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Receives zero or more integers. Returns a string with length equal to the number of arguments, in which each character has the byte value equal to its corresponding argument.
</div>

<syntaxhighlight lang="lua">
local value = string.char( 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21 ) --value is now 'Hello!'
</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
See [[#mw.ustring.char|mw.ustring.char()]] for a similar function that uses Unicode codepoints rather than byte values.
</div>

==== string.find ====
<code style="white-space:nowrap">string.find( s, pattern, init, plain )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Looks for the first match of <code>[[#Patterns|pattern]]</code> in the string <code>s</code>. If it finds a match, then <code>find</code> returns the offsets in&nbsp;<code>s</code> where this occurrence starts and ends; otherwise, it returns nil. If the pattern has captures, then in a successful match the captured values are also returned after the two indices.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
A third, optional numerical argument <code>init</code> specifies where to start the search; its default value is&nbsp;1 and can be negative. A value of true as a fourth, optional argument <code>plain</code> turns off the pattern matching facilities, so the function does a plain "find substring" operation, with no characters in <code>pattern</code> being considered "magic".
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that if <code>plain</code> is given, then <code>init</code> must be given as well.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
See [[#mw.ustring.find|mw.ustring.find()]] for a similar function extended as described in [[#Ustring patterns|Ustring patterns]] and where the <code>init</code> offset is in characters rather than bytes.
</div>

==== string.format ====
<code style="white-space:nowrap">string.format( formatstring, ... )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a formatted version of its variable number of arguments following the description given in its first argument (which must be a string).
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The format string uses a limited subset of the [http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html <code>printf</code> format specifiers]:
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* Recognized flags are <code>'-', '+', ' ', '#',</code> and <code>'0'</code>.
* Integer field widths up to 99 are supported. <code>'*'</code> is not supported.
* Integer precisions up to 99 are supported. <code>'*'</code> is not supported.
* Length modifiers are not supported.
* Recognized conversion specifiers are <code>'c', 'd', 'i', 'o', 'u', 'x', 'X', 'e', 'E', 'f', 'g', 'G', 's', '%',</code> and the non-standard <code>'q'</code>.
* Positional specifiers (e.g. "%2$s") are not supported.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The conversion specifier <code>q</code> is like  <code>s</code>, but formats the string in a form suitable to be safely read back by the Lua interpreter: the string is written between double quotes, and all double quotes, newlines, embedded zeros, and backslashes in the string are correctly escaped when written.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Conversion between strings and numbers is performed as specified in [[#Data types|Data types]]; other types are not automatically converted to strings. Strings containing NUL characters (byte value 0) are not properly handled.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Identical to [[#mw.ustring.format|mw.ustring.format()]].
</div>

==== string.gmatch ====
<code style="white-space:nowrap">string.gmatch( s, pattern )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns an iterator function that, each time it is called, returns the next captures from [[#Patterns|<code>pattern</code>]] over string <code>s</code>. If <code>pattern</code> specifies no captures, then the whole match is produced in each call.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
For this function, a '<code>^</code>' at the start of a pattern is not magic, as this would prevent the iteration. It is treated as a literal character.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
See [[#mw.ustring.gmatch>|mw.ustring.gmatch()]] for a similar function for which the pattern is extended as described in [[#Ustring patterns|Ustring patterns]].
</div>

==== string.gsub ====
<code style="white-space:nowrap">string.gsub( s, pattern, repl, n )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a copy of <code>s</code> in which all (or the first <code>n</code>, if given) occurrences of the [[#Patterns|<code>pattern</code>]] have been replaced by a replacement string specified by <code>repl</code>, which can be a string, a table, or a function. <code>gsub</code> also returns, as its second value, the total number of matches that occurred.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If <code>repl</code> is a string, then its value is used for replacement. The character&nbsp;<code>%</code> works as an escape character: any sequence in <code>repl</code> of the form <code>%''d''</code>,
with ''d'' between 1 and 9, stands for the value of the ''d''-th captured substring. The sequence <code>%0</code> stands for the whole match, and the sequence <code>%%</code> stands for a single&nbsp;<code>%</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If <code>repl</code> is a table, then the table is queried for every match, using the first capture as the key; if the pattern specifies no captures, then the whole match is used as the key.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If <code>repl</code> is a function, then this function is called every time a match occurs, with all captured substrings passed as arguments, in order; if the pattern specifies no captures, then the whole match is passed as a sole argument.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If the value returned by the table query or by the function call is a string or a number, then it is used as the replacement string; otherwise, if it is false or nil, then there is no replacement (that is, the original match is kept in the string).
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
See [[#mw.ustring.gsub|mw.ustring.gsub()]] for a similar function in which the pattern is extended as described in [[#Ustring patterns|Ustring patterns]].
</div>

==== string.len ====
<code style="white-space:nowrap">string.len( s )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the length of the string, in bytes. Is not confused by ASCII NUL characters. Equivalent to <code style="white-space:nowrap">[[#Length operator|#]]s</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
See [[#mw.ustring.len|mw.ustring.len()]] for a similar function using Unicode codepoints rather than bytes.
</div>

==== string.lower ====
<code style="white-space:nowrap">string.lower( s )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a copy of this string with all ASCII uppercase letters changed to lowercase. All other characters are left unchanged.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
See [[#mw.ustring.lower|mw.ustring.lower()]] for a similar function in which all characters with uppercase to lowercase definitions in Unicode are converted.
</div>

==== string.match ====
<code style="white-space:nowrap">string.match( s, pattern, init )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Looks for the first match of [[#Patterns|<code>pattern</code>]] in the string. If it finds one, then <code>match</code> returns the captures from the pattern; otherwise it returns nil. If <code>pattern</code> specifies no captures, then the whole match is returned.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
A third, optional numerical argument <code>init</code> specifies where to start the search; its default value is&nbsp;1 and can be negative.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
See [[#mw.ustring.match|mw.ustring.match()]] for a similar function in which the pattern is extended as described in [[#Ustring patterns|Ustring patterns]] and the <code>init</code> offset is in characters rather than bytes.
</div>

==== string.rep ====
<code style="white-space:nowrap">string.rep( s, n )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a string that is the concatenation of <code>n</code> copies of the string <code>s</code>. Identical to [[#mw.ustring.rep|mw.ustring.rep()]].
</div>

==== string.reverse ====
<code style="white-space:nowrap">string.reverse( s )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a string that is the string <code>s</code> reversed (bytewise).
</div>

==== string.sub ====
<code style="white-space:nowrap">string.sub( s, i, j )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the substring of <code>s</code> that starts at <code>i</code> and continues until <code>j</code>; <code>i</code> and <code>j</code> can be negative. If <code>j</code> is nil or omitted, it will continue until the end of the string.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
In particular, the call <code>string.sub(s,1,j)</code> returns a prefix of <code>s</code> with length <code>j</code>, and <code style="white-space:nowrap">string.sub(s, -i)</code> returns a suffix of <code>s</code> with length <code>i</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
See [[#mw.ustring.sub|mw.ustring.sub()]] for a similar function in which the offsets are characters rather than bytes.
</div>

==== string.ulower ====
<code style="white-space:nowrap">string.ulower( s )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
An alias for [[#mw.ustring.lower|mw.ustring.lower()]].
</div>

==== string.upper ====
<code style="white-space:nowrap">string.upper( s )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a copy of this string with all ASCII lowercase letters changed to uppercase. All other characters are left unchanged.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
See [[#mw.ustring.upper|mw.ustring.upper()]] for a similar function in which all characters with lowercase to uppercase definitions in Unicode are converted.
</div>

==== string.uupper ====
<code style="white-space:nowrap">string.uupper( s )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
An alias for [[#mw.ustring.upper|mw.ustring.upper()]].
</div>

<span id="Patterns"></span>
==== Suchmuster ====

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that Lua's patterns are similar to [[w:regular expression|regular expressions]], but are not identical. In particular, note the following differences from regular expressions and [[w:PCRE|PCRE]]:
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* The quoting character is percent (<code>%</code>), not backslash (<code>\</code>).
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* Dot (<code>.</code>) always matches all characters, including newlines.
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* No case-insensitive mode.
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* No alternation (the <code>|</code> operator).
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* Quantifiers (<code>*</code>, <code>+</code>, <code>?</code>, and <code>-</code>) may only be applied to individual characters or character classes, not to capture groups.
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* The only non-greedy quantifier is <code>-</code>, which is equivalent to PCRE's <code>*?</code> quantifier.
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* No generalized finite quantifier (e.g. the <code>{''n'',''m''}</code> quantifier in PCRE).
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* The only zero-width assertions are <code>^</code>, <code>$</code>, and the <code>%f[set]</code> "frontier" pattern; assertions such as PCRE's <code>\b</code> or <code>(?=···)</code> are not present.
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* Patterns themselves do not recognize character escapes such as <code>\''ddd''</code>. However, since patterns are [[#string|strings]] these sort of escapes may be used in the string literals used to create the pattern-string.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Also note that a pattern cannot contain embedded zero bytes (ASCII NUL, <code>"\0"</code>). Use <code>%z</code> instead.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Also see [[#Ustring patterns|Ustring patterns]] for a similar pattern-matching scheme using Unicode characters.
</div>

<span id="Character_class"></span>
===== Zeichenklassen =====

<div lang="en" dir="ltr" class="mw-content-ltr">
A ''character class'' is used to represent a set of characters. The following combinations are allowed in describing a character class:
</div>

{| class="wikitable"
! scope="row" | <code>{{var|x}}</code>
| <span lang="en" dir="ltr" class="mw-content-ltr">(where <code>{{var|x}}</code> is not one of the magic characters <code>^$()%.[]*+-?</code>) represents the character <code>{{var|x}}</code> itself.</span>
|-
! scope="row" | <code>.</code>
| <span lang="en" dir="ltr" class="mw-content-ltr">(a dot) Represents all characters.</span>
|-
! scope="row" | <code>%a</code>
| Repräsentiert alle ASCII-Buchstaben.
|-
! scope="row" | <code>%c</code>
| Repräsentiert alle ASCII-Kontrollzeichen.
|-
! scope="row" | <code>%d</code>
| Repräsentiert alle Ziffern.
|-
! scope="row" | <code>%l</code>
| Repräsentiert alle ASCII-Kleinbuchstaben.
|-
! scope="row" | <code>%p</code>
| Repräsentiert alle ASCII-Satzzeichen.
|-
! scope="row" | <code>%s</code>
| Repräsentiert alle ASCII-Leerzeichen.
|-
! scope="row" | <code>%u</code>
| Repräsentiert alle ASCII-Großbuchstaben.
|-
! scope="row" | <code>%w</code>
| <span class="mw-translate-fuzzy">Repräsentiert alle ASCII-Alphanumerische Zeichen.</span>
|-
! scope="row" | <code>%x</code>
| Repräsentiert alle hexadezimale Ziffern.
|-
! scope="row" | <code>%z</code>
| Repräsentiert ASCII NUL, der null-Byte.
|-
! scope="row" | <code>%A</code>
| Alle Zeichen, die nicht in <code>%a</code> sind.
|-
! scope="row" | <code>%C</code>
| Alle Zeichen, die nicht in <code>%c</code> sind.
|-
! scope="row" | <code>%D</code>
| Alle Zeichen, die nicht in <code>%d</code> sind.
|-
! scope="row" | <code>%L</code>
| Alle Zeichen, die nicht in <code>%l</code> sind.
|-
! scope="row" | <code>%P</code>
| Alle Zeichen, die nicht in <code>%p</code> sind.
|-
! scope="row" | <code>%S</code>
| Alle Zeichen, die nicht in <code>%s</code> sind.
|-
! scope="row" | <code>%U</code>
| Alle Zeichen, die nicht in <code>%u</code> sind.
|-
! scope="row" | <code>%W</code>
| Alle Zeichen, die nicht in <code>%w</code> sind.
|-
! scope="row" | <code>%X</code>
| Alle Zeichen, die nicht in <code>%x</code> sind.
|-
! scope="row" | <code>%Z</code>
| Alle Zeichen, die nicht in <code>%z</code> sind.
|-
! scope="row" | <code>%{{var|y}}</code>
| <span lang="en" dir="ltr" class="mw-content-ltr">(where <code>{{var|y}}</code> is any non-alphanumeric character) represents the character <code>{{var|y}}</code>. This is the standard way to escape the magic characters. Any punctuation character (even the non magic) can be preceded by a '<code>%</code>' when used to represent itself in a pattern.</span>
|-
! scope="row" | <code>[{{var|set}}]</code>
|
<span lang="en" dir="ltr" class="mw-content-ltr">Represents the class which is the union of all characters in {{var|set}}. A range of characters can be specified by separating the end characters of the range with a '<code>-</code>'. All classes <code>%{{var|y}}</code> described above can also be used as components in {{var|set}}. All other characters in {{var|set}} represent themselves.</span> <span lang="en" dir="ltr" class="mw-content-ltr">For example, <code>[%w_]</code> (or <code>[_%w]</code>) represents all alphanumeric characters plus the underscore, and <code style="white-space:nowrap">[0-7]</code> represents the octal digits. To include literal '<code>-</code>' in the set, use '<code>%-</code>', so <code style="white-space:nowrap">[0-7%l%-]</code> represents the octal digits plus the lowercase letters plus the '<code>-</code>' character.</span>

<div lang="en" dir="ltr" class="mw-content-ltr">
The interaction between ranges and classes is not defined. Therefore, patterns like <code>[%a-z]</code> or <code>[a-%%]</code> have no meaning.
</div>
|-
! scope="row" | <code>[^{{var|set}}]</code>
| <span lang="en" dir="ltr" class="mw-content-ltr">Represents the complement of {{var|set}}, where {{var|set}} is interpreted as above.</span>
|}

<span id="Pattern_items"></span>
===== Suchmuster-Elemente =====

<div lang="en" dir="ltr" class="mw-content-ltr">
A ''pattern item'' can be
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* a single character class, which matches any single character in the class;
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* a single character class followed by '<code>*</code>', which matches 0 or more repetitions of characters in the class. These repetition items will always match the longest possible sequence;
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* a single character class followed by '<code>+</code>', which matches 1 or more repetitions of characters in the class. These repetition items will always match the longest possible sequence;
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* a single character class followed by '<code>-</code>', which also matches 0 or more repetitions of characters in the class. Unlike '<code>*</code>', these repetition items will always match the ''shortest'' possible sequence;
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* a single character class followed by '<code>?</code>', which matches 0 or 1 occurrence of a character in the class;
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* <code>%''n''</code>, for ''n'' between 1 and 9; such item matches a substring equal to the ''n''-th captured string (see below);
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* <code>%b''xy''</code>, where ''x'' and ''y'' are two distinct characters; such item matches strings that start with&nbsp;''x'', end with&nbsp;''y'', and where the ''x'' and ''y'' are ''balanced''. This means that, if one reads the string from left to right, counting +1 for an ''x'' and -1 for a ''y'', the ending ''y'' is the first ''y'' where the count reaches 0. For instance, the item <code>%b()</code> matches expressions with balanced parentheses.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* <code>%f[''set'']</code>, a ''frontier pattern''; such item matches an empty string at any position such that the next character belongs to ''set'' and the previous character does not belong to ''set''. The set ''set'' is interpreted as previously described. The beginning and the end of the subject are handled as if they were the character&nbsp;'\0'.
</div><br/><small><span lang="en" dir="ltr" class="mw-content-ltr">Note that frontier patterns were present but undocumented in Lua&nbsp;5.1, and officially added to Lua in 5.2. The implementation in Lua&nbsp;5.2.1 is unchanged from that in 5.1.0.</span></small>
<span id="Pattern"></span>
===== Suchmuster =====

<div lang="en" dir="ltr" class="mw-content-ltr">
A ''pattern'' is a sequence of pattern items.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
A <code>^</code> at the beginning of a pattern anchors the match at the beginning of the subject string.
</div> <span lang="en" dir="ltr" class="mw-content-ltr">A <code>$</code> at the end of a pattern anchors the match at the end of the subject string. At other positions, <code>^</code> and <code>$</code> have no special meaning and represent themselves.</span>

<div lang="en" dir="ltr" class="mw-content-ltr">
===== Captures =====
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
A pattern can contain sub-patterns enclosed in parentheses; they describe ''captures''. When a match succeeds, the substrings of the subject string that match captures are stored ("captured") for future use. Captures are numbered according to their left parentheses. For instance, in the pattern <code>(a*(.)%w(%s*))</code>, the part of the string matching <code>a*(.)%w(%s*)</code> is stored as the first capture (and therefore has number&nbsp;1); the character matching <code>.</code> is captured with number&nbsp;2, and the part matching <code>%s*</code> has number&nbsp;3.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Capture references can appear in the pattern string itself, and refer back to text that was captured earlier in the match. For example, <code>([a-z])%1</code> will match any pair of identical lowercase letters, while <code>([a-z])([a-z])([a-z])[a-z]%3%2%1</code> will match any 7-letter [[w:Palindrome|palindrome]].
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
As a special case, the empty capture <code>()</code> captures the current string position (a number). For instance, if we apply the pattern <code>"()aa()"</code> on the string <code>"flaaap"</code>, there will be two captures: 3&nbsp;and&nbsp;5.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
{{red|Known limitations}}: Unlike [[#Ustring patterns|Ustring library patterns]], String library patterns may not contain more than 32 captures. If the pattern has more, then the String function will throw an error. Because the Ustring library has its own maximum of 10,000 bytes for patterns (unlike the String library), it is therefore impossible to use a pattern which exceeds both limits, as it will be incompatible with both libraries.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Table library ===
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Most functions in the table library assume that the table represents a [[#sequence|sequence]].
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The functions <code>table.foreach()</code>, <code>table.foreachi()</code>, and <code>table.getn()</code> may be available but are deprecated; use a for loop with <code>[[#pairs|pairs()]]</code>, a for loop with <code>[[#ipairs|ipairs()]]</code>, or the [[#Length operator</tvar>|length operator]] <code>#</code>, respectively. The function <code>table.setn()</code> is completely obsolete, however, and will throw an error if used.
</div>

==== table.concat ====
<code style="white-space:nowrap">table.concat( table, sep, i, j )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Given an array where all elements are strings or numbers, returns <code style="white-space:nowrap">table[i] .. sep .. table[i+1] ··· sep .. table[j]</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The default value for <code>sep</code> is an empty string, the default for <code>i</code> is 1, and the default for <code>j</code> is the length of the table. If <code>i</code> is greater than <code>j</code>, it returns an empty string.
</div>

==== table.insert ====
<code style="white-space:nowrap">table.insert( table, value )</code>
<br/>
<code style="white-space:nowrap">table.insert( table, pos, value )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Inserts element <code>value</code> at position <code>pos</code> in <code>table</code>, shifting up other elements to open space, if necessary. The default value for <code>pos</code> is the length of the table plus 1, so that a call <code style="white-space:nowrap">table.insert(t, x)</code> inserts <code>x</code> at the end of table <code>t</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Elements up to <code>#table</code> are shifted; see [[#Length operator|Length operator]] for caveats if the table is not a [[#sequence|sequence]].
</div>

<span lang="en" dir="ltr" class="mw-content-ltr">{{red|Note}}: when using the <code>pos</code> parameter, <code>value</code> should not be <code>nil</code>. Attempting to insert an explicit <code>nil</code> value into the middle of a table will result in undefined behaviour, which may delete elements in the table unpredictably.</span>

==== table.maxn ====
<code style="white-space:nowrap">table.maxn( table )</code>

Gibt die größte positive numerische Indexnummer des angegebenen Feldausdrucks (table) zurück oder den wert „0“, wenn der Feldausdruck keine positive numerische Indexnummer hat.

Dazu durchläuft es den gesamten Feldausdruck. Das entspricht ungefähr:

<syntaxhighlight lang="lua">
function table.maxn( table )
    local maxn, k = 0, nil
    repeat
        k = next( table, k )
        if type( k ) == 'number' and k > maxn then
            maxn = k
        end
    until not k
    return maxn
end
</syntaxhighlight>

==== table.remove ====
<code style="white-space:nowrap">table.remove( table, pos )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Removes from <code>table</code> the element at position <code>pos</code>, shifting down other elements to close the space, if necessary. Returns the value of the removed element. The default value for <code>pos</code> is the length of the table, so that a call <code style="white-space:nowrap">table.remove( t )</code> removes the last element of table <code>t</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Elements up to <code>#table</code> are shifted; see [[#Length operator|Length operator]] for caveats if the table is not a [[#sequence|sequence]].
</div>

==== table.sort ====
<code style="white-space:nowrap">table.sort( table, comp )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Sorts table elements in a given order, ''in-place'', from <code>table[1]</code> to <code>table[#table]</code>.
</div>
<span lang="en" dir="ltr" class="mw-content-ltr">If <code>comp</code> is given, then it must be a function that receives two table elements, and returns {{luai|true}} when the first is less than the second (so that <code style="white-space:nowrap">not comp(a[i+1],a[i])</code> will be true after the sort).</span>
<span lang="en" dir="ltr" class="mw-content-ltr">If <code>comp</code> is not given, then the standard Lua operator <code>&lt;</code> is used instead.</span>
<div lang="en" dir="ltr" class="mw-content-ltr">
The sort algorithm is not stable; that is, elements considered equal by the given order may have their relative positions changed by the sort.
</div>

<span id="Scribunto_libraries"></span>
== Scribunto-Bibliotheken ==

Alle Scribunto-Bibliotheken befinden sich in der Tabelle <code>mw</code>.

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Base functions ===
</div>

==== mw.addWarning ====
<code style="white-space:nowrap">mw.addWarning( text )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Adds a warning which is displayed above the preview when previewing an edit. <code>text</code> is parsed as wikitext.
</div>

==== mw.allToString ====
<code style="white-space:nowrap">mw.allToString( ... )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Calls [[#tostring|tostring()]] on all arguments, then concatenates them with tabs as separators.
</div>

==== mw.clone ====
<code style="white-space:nowrap">mw.clone( value )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Creates a deep copy of a value. All tables (and their metatables) are reconstructed from scratch. Functions are still shared, however.
</div>

==== mw.getCurrentFrame ====
<code>mw.getCurrentFrame()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the current [[#frame-object|frame object]], typically the frame object from the most recent <code>#invoke</code>.
</div>

==== mw.incrementExpensiveFunctionCount ====
<code>mw.incrementExpensiveFunctionCount()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Adds one to the "expensive parser function" count, and throws an exception if it exceeds the limit (see {{wg|ExpensiveParserFunctionLimit}}).
</div>

==== mw.isSubsting ====
<code>mw.isSubsting()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns true if the current <code>#invoke</code> is being [[Special:MyLanguage/Manual:Substitution|substed]], {{luai|false}} otherwise. See [[#Returning text|Returning text]] above for discussion on differences when substing versus not substing.
</div>

==== mw.loadData ====
<code style="white-space:nowrap">mw.loadData( module )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Sometimes a module needs large tables of data; for example, a general-purpose module to convert units of measure might need a large table of recognized units and their conversion factors. And sometimes these modules will be used many times in one page. Parsing the large data table for every <code><nowiki>{{#invoke:}}</nowiki></code> can use a significant amount of time. To avoid this issue, <code>mw.loadData()</code> is provided.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
<code>mw.loadData</code> works like <code>[[#require|require()]]</code>, with the following differences:
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* The loaded module is evaluated only once per page, rather than once per <code><nowiki>{{#invoke:}}</nowiki></code> call.
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* The loaded module is not recorded in <code>[[#package.loaded|package.loaded]]</code>.
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* The value returned from the loaded module must be a table. Other data types are not supported.
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* The returned table (and all subtables) may contain only booleans, numbers, strings, and other tables. Other data types, particularly functions, are not allowed.
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* The returned table (and all subtables) may not have a [[#Metatables|metatable]].
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* All table keys must be booleans, numbers, or strings.
</div>
<div lang="en" dir="ltr" class="mw-content-ltr">
* The table actually returned by <code>mw.loadData()</code> has metamethods that provide read-only access to the table returned by the module. Since it does not contain the data directly, <code>[[#pairs|pairs()]]</code> and <code>[[#ipairs|ipairs()]]</code> will work but other methods, including <code>[[#Length operator|#value]]</code>, <code style="white-space:nowrap">[[#next|next()]]</code>, and the functions in the [[#Table library|Table library]], will not work correctly.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The hypothetical unit-conversion module mentioned above might store its code in "Module:Convert" and its data in "Module:Convert/data", and "Module:Convert" would use <code style="white-space:nowrap">local data = mw.loadData( 'Module:Convert/data' )</code> to efficiently load the data.
</div>

==== mw.loadJsonData ====
<code style="white-space:nowrap">mw.loadJsonData( page )</code>

<span lang="en" dir="ltr" class="mw-content-ltr">This is the same as <code>mw.loadData()</code> above, except it loads data from JSON pages rather than Lua tables.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">The JSON content must be an array or object.</span>
Siehe auch <code>[[#mw.text.jsonDecode|mw.text.jsonDecode()]]</code>.

==== mw.dumpObject ====
<code style="white-space:nowrap">mw.dumpObject( object )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Serializes <code>object</code> to a human-readable representation, then returns the resulting string.
</div>

==== mw.log ====
{{Anchor|print}}
<code style="white-space:nowrap">mw.log( ... )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Passes the arguments to [[#mw.allToString|mw.allToString()]], then appends the resulting string to the log buffer.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
In the debug console, the function <code>print()</code> is an alias for this function.
</div>

==== mw.logObject ====
<code style="white-space:nowrap">mw.logObject( object )</code>
<br/>
<code style="white-space:nowrap">mw.logObject( object, prefix )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Calls [[#mw.dumpObject|mw.dumpObject()]] and appends the resulting string to the log buffer. If <code>prefix</code> is given, it will be added to the log buffer followed by an equals sign before the serialized string is appended (i.e. the logged text will be "prefix = object-string").
</div>
{{anchor|frame-object}}
<span id="Frame_object"></span>
=== Frame-Objekt ===

Das Frame-Objekt ist die Schnittstelle zu den Parametern, die an <syntaxhighlight lang="text" inline>{{#invoke:}}</syntaxhighlight> übergeben werden, und dem Parser.

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that there is no frame library, and there is no global variable named {{luai|frame}}. A frame object is typically obtained by being passed as a parameter to the function called by <syntaxhighlight lang="text" inline>{{#invoke:}}</syntaxhighlight>, and can also be obtained from <code>[[#mw.getCurrentFrame|mw.getCurrentFrame()]]</code>.
</div>
==== frame.args ====
Dieser Feldausdruck (table) bildet den Rahmen für den Zugriff auf die an das Modul übergebenen Argumente. Zum Beispiel, wenn ein Modul aus Wikitext aufgerufen wird mit

<syntaxhighlight lang="text">
{{#invoke:module|function|arg1|arg2|name=arg3}}
</syntaxhighlight>

<span lang="en" dir="ltr" class="mw-content-ltr">then {{luai|frame.args[1]}} will return <code>"arg1"</code>, {{luai|frame.args[2]}} will return <code>"arg2"</code>, and {{luai|frame.args['name']}} (or {{luai|frame.args.name}}) will return <code>"arg3"</code>. It is also possible to iterate over arguments using {{luai|pairs( frame.args )}} or {{luai|ipairs( frame.args )}}.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">However, due to how Lua implements table iterators, iterating over arguments will return them in an unspecified order, and there's no way to know the original order as they appear in wikitext.</span>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that values in this table are always strings; <code>[[#tonumber|tonumber()]]</code> may be used to convert them to numbers, if necessary. Keys, however, are numbers even if explicitly supplied in the invocation: <syntaxhighlight lang="text" inline>{{#invoke:module|function|1|2=2}}</syntaxhighlight> gives string values <code>"1"</code> and <code>"2"</code> indexed by numeric keys <code>1</code> and <code>2</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
As in MediaWiki template invocations, named arguments will have leading and trailing whitespace removed from both the name and the value before they are passed to Lua, whereas unnamed arguments will not have whitespace stripped.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
For performance reasons, <code>frame.args</code> uses a metatable, rather than directly containing the arguments. Argument values are requested from MediaWiki on demand. This means that most other table methods will not work correctly, including <code>[[#Length operator|#frame.args]]</code>, <code style="white-space:nowrap">[[#next|next]]( frame.args )</code>, and the functions in the [[#Table library|Table library]].
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If preprocessor syntax such as template invocations and triple-brace arguments are included within an argument to <code>#invoke</code>, they will not be expanded, after being passed to Lua, until their values are being requested in Lua. If certain special tags written in XML notation, such as {{tag|pre|o}}, {{tag|nowiki|o}}, {{tag|gallery|o}} and {{tag|ref|o}}, are included as arguments to <code>#invoke</code>, then these tags will be converted to "[[strip marker]]s" — special strings which begin with a delete character (ASCII 127), to be replaced with HTML after they are returned from #invoke.
</div>

==== frame:callParserFunction ====
{{ubl
|{{luai|frame:callParserFunction( name, args )}}
|{{luai|frame:callParserFunction( name, ... )}}
|<syntaxhighlight lang="lua" inline>frame:callParserFunction{ name = string, args = table }</syntaxhighlight>
}}

<div lang="en" dir="ltr" class="mw-content-ltr">
: ''Note the use of [[#named arguments|named arguments]].''
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Call a [[Special:MyLanguage/Help:Magic words#Parser functions|parser function]], returning an appropriate string. This is preferable to <code>frame:preprocess</code>, but whenever possible, native Lua functions or Scribunto library functions should be preferred to this interface.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The following calls are approximately equivalent to the indicated wikitext:
</div>

<syntaxhighlight lang="lua">
-- {{ns:0}}
frame:callParserFunction( 'ns', { 0 } )
frame:callParserFunction( 'ns', 0 )
frame:callParserFunction{ name = 'ns', args = { 0 } }

-- {{#tag:nowiki|some text}}
frame:callParserFunction( '#tag', { 'nowiki', 'some text' } )
frame:callParserFunction( '#tag', 'nowiki', 'some text' )
frame:callParserFunction( '#tag:nowiki', 'some text' )
frame:callParserFunction{ name = '#tag', args = { 'nowiki', 'some text' } }

-- {{#tag:ref|some text|name=foo|group=bar}}
frame:callParserFunction( '#tag', { 'ref',
    'some text', name = 'foo', group = 'bar'
} )
</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that, as with [[#frame:expandTemplate|frame:expandTemplate()]], the function name and arguments are not preprocessed before being passed to the parser function.
</div>

==== frame:expandTemplate ====
<syntaxhighlight lang="lua" inline>frame:expandTemplate{ title = title, args = table }</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
: ''Note the use of [[#named arguments|named arguments]].''
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
This is equivalent to a call to [[#frame:callParserFunction|frame:callParserFunction()]] with function name {{luai|'msg'}} (see [[Special:MyLanguage/Help:Magic words#Transclusion modifiers|Help:Magic words#Transclusion modifiers]]) and with {{luai|title}} prepended to {{luai|args}}.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
This is transclusion. The call:
</div>

<syntaxhighlight lang="lua">
frame:expandTemplate{ title = 'template', args = { 'arg1', 'arg2', name = 'arg3' } }
</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
does roughly the same thing from Lua that <syntaxhighlight lang="text" inline>{{template|arg1|arg2|name=arg3}}</syntaxhighlight> does in wikitext. As in transclusion, if the passed title does not contain a namespace prefix it will be assumed to be in the Template: namespace.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that the title and arguments are not preprocessed before being passed into the template:
</div>

<syntaxhighlight lang="lua">
-- This is roughly equivalent to wikitext like {{template|{{!}}}}
frame:expandTemplate{ title = 'template', args = { '|' } }
frame:callParserFunction{ 'msg', { 'template', '|' } }

-- This is roughly equivalent to wikitext like {{template|{{((}}!{{))}}}}
frame:expandTemplate{ title = 'template', args = { '{{!}}' } }
frame:callParserFunction{ 'msg', { 'template', '{{!}}' } }
</syntaxhighlight>

==== frame:extensionTag ====
{{ubl
|{{luai|frame:extensionTag( name, content, args )}}
|<syntaxhighlight lang="lua" inline>frame:extensionTag{ name = string, content = string, args = table_or_string }</syntaxhighlight>
}}

<div lang="en" dir="ltr" class="mw-content-ltr">
This is equivalent to a call to [[#frame:callParserFunction|frame:callParserFunction()]] with function name {{luai|'#tag'}} (see [[Special:MyLanguage/Help:Magic_words#Miscellaneous|Help:Magic_words#Miscellaneous]]) and with {{luai|name}} and {{luai|content}} prepended to {{luai|args}}.
</div>

<syntaxhighlight lang="lua">
-- Diese sind gleichwertig
frame:extensionTag( 'ref', 'some text', { name = 'foo', group = 'bar' } )
frame:extensionTag{ name = 'ref', content = 'some text', args = { name = 'foo', group = 'bar' } }
frame:callParserFunction( '#tag', { 'ref' ,
    'some text', name = 'foo', group = 'bar'
} )

-- Diese sind gleichwertig
frame:extensionTag{ name = 'ref', content = 'some text', args = { 'some other text' } }
frame:callParserFunction( '#tag', { 'ref',
    'some text', 'some other text'
} )
</syntaxhighlight>

==== frame:getParent ====
{{luai|frame:getParent()}}

<div lang="en" dir="ltr" class="mw-content-ltr">
Called on the frame created by <syntaxhighlight lang="text" inline>{{#invoke:}}</syntaxhighlight>, returns the frame for the page that called <syntaxhighlight lang="text" inline>{{#invoke:}}</syntaxhighlight>. Called on that frame, returns nil.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
For instance, if the template <syntaxhighlight lang="text" inline>{{Example}}</syntaxhighlight> contains the code <syntaxhighlight lang="text" inline>{{#invoke:ModuleName|FunctionName|A|B}}</syntaxhighlight>, and a page transcludes that template with the code <syntaxhighlight lang="text" inline>{{Example|C|D}}</syntaxhighlight>, then in ''Module:ModuleName'', calling <code>frame.args[1]</code> and <code>frame.args[2]</code> returns <code>"A"</code> and <code>"B"</code>, and calling <code>frame:getParent().args[1]</code> and <code>frame:getParent().args[2]</code> returns <code>"C"</code> and <code>"D"</code>, with <code>frame</code> being the first argument in the function call.
</div>

==== frame:getTitle ====
{{luai|frame:getTitle()}}

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the title associated with the frame as a string. For the frame created by <syntaxhighlight lang="text" inline>{{#invoke:}}</syntaxhighlight>, this is the title of the module invoked.
</div>

==== frame:newChild ====
<syntaxhighlight lang="lua" inline>frame:newChild{ title = title, args = table }</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
: ''Note the use of [[#named arguments|named arguments]].''
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Create a new [[#frame-object|Frame object]] that is a child of the current frame, with optional arguments and title.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
This is mainly intended for use in modules that call other modules whose name is defined by the caller (e.g. <code>{{[[w:Module:Params|#invoke:params]]|[[w:Module:Params#concat_and_invoke|concat_and_invoke]]}}</code>), or in the debug console for testing functions that would normally be called by <syntaxhighlight lang="text" inline>{{#invoke:}}</syntaxhighlight>. The number of frames that may be created at any one time is limited.
</div>

==== frame:preprocess ====
{{ubl
|{{luai|frame:preprocess( string )}}
|<syntaxhighlight lang="lua" inline>frame:preprocess{ text = string }</syntaxhighlight>
}}

<div lang="en" dir="ltr" class="mw-content-ltr">
This expands wikitext in the context of the frame, i.e. templates, parser functions, and parameters such as <syntaxhighlight lang="text" inline>{{{1}}}</syntaxhighlight> are expanded, and returns the expanded text. Certain special tags written in XML-style notation, such as {{tag|pre|o}}, {{tag|nowiki|o}}, {{tag|gallery|o}} and {{tag|ref|o}}, will be replaced with "[[Special:MyLanguage/strip marker|strip markers]]" — special strings which begin with a delete character (ASCII 127), to be replaced with HTML after they are returned from <code>#invoke</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If you are expanding a single template, use <code>[[#frame:expandTemplate|frame:expandTemplate]]</code> instead of trying to construct a wikitext string to pass to this method. It's faster and less prone to error if the arguments contain pipe characters or other wikimarkup.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
If you are expanding a single parser function, use <code>[[#frame:callParserFunction|frame:callParserFunction]]</code> for the same reasons.
</div>

==== frame:getArgument ====
{{ubl
|{{luai|frame:getArgument( arg )}}
|<syntaxhighlight lang="lua" inline>frame:getArgument{ name = arg }</syntaxhighlight>
}}

<div lang="en" dir="ltr" class="mw-content-ltr">
Gets an object for the specified argument, or nil if the argument is not provided.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The returned object has one method, <code>object:expand()</code>, that returns the expanded wikitext for the argument.
</div>

==== frame:newParserValue ====
{{ubl
|{{luai|frame:newParserValue( text )}}
|<syntaxhighlight lang="lua" inline>frame:newParserValue{ text = text }</syntaxhighlight>
}}

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns an object with one method, <code>object:expand()</code>, that returns the result of <code style="white-space:nowrap">[[#frame:preprocess|frame:preprocess]]( text )</code>.
</div>

==== frame:newTemplateParserValue ====
<syntaxhighlight lang="lua" inline>frame:newTemplateParserValue{ title = title, args = table }</syntaxhighlight>

<div lang="en" dir="ltr" class="mw-content-ltr">
: ''Note the use of [[#named arguments|named arguments]].''
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns an object with one method, <code>object:expand()</code>, that returns the result of <code>[[#frame:expandTemplate|frame:expandTemplate]]</code> called with the given arguments.
</div>

==== frame:argumentPairs ====
{{luai|frame:argumentPairs()}}

<div lang="en" dir="ltr" class="mw-content-ltr">
Same as {{luai|pairs( frame.args )}}. Included for backwards compatibility.
</div>

<span id="Hash_library"></span>
== Hash-Bibliothek ==

==== mw.hash.hashValue ====
<code style="white-space:nowrap"><span lang="en" dir="ltr" class="mw-content-ltr">mw.hash.hashValue( algo, value )</span></code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Hashes a string value with the specified algorithm. Valid algorithms may be fetched using [[#mw.hash.listAlgorithms|mw.hash.listAlgorithms()]].
</div>

==== mw.hash.listAlgorithms ====
<code style="white-space:nowrap">mw.hash.listAlgorithms()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a list of supported hashing algorithms, for use in [[#mw.hash.hashValue|mw.hash.hashValue()]].
</div>

<span id="HTML_library"></span>
=== HTML-Bibliothek ===

<div lang="en" dir="ltr" class="mw-content-ltr">
<code>mw.html</code> is a fluent interface for building complex HTML from Lua. On many Wikimedia wikis this was formerly implemented in <code>Module:HtmlBuilder</code>. A mw.html object can be created using <code>[[#mw.html.create|mw.html.create]]</code>.
</div>

{{anchor|mw.html-object}}
<div lang="en" dir="ltr" class="mw-content-ltr">
Functions documented as <code>mw.html.<var>name</var></code> are available on the global <code>mw.html</code> table; functions documented as <code>mw.html:<var>name</var></code> and <code>html:<var>name</var></code> are methods of an mw.html object (see <code>[[#mw.html.create|mw.html.create]]</code>).
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
A basic example could look like this:
</div>

<syntaxhighlight lang="lua">
local div = mw.html.create( 'div' )
div
     :attr( 'id', 'testdiv' )
     :css( 'width', '100%' )
     :wikitext( 'Some text' )
     :tag( 'hr' )
return tostring( div )
-- Output: <div id="testdiv" style="width:100%;">Some text<hr /></div>
</syntaxhighlight>

==== mw.html.create ====
<code style="white-space:nowrap">mw.html.create( tagName, args )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Creates a new mw.html object containing a <code>tagName</code> html element. You can also pass an empty string or nil as <code>tagName</code> in order to create an empty mw.html object.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
<code>args</code> can be a table with the following keys:
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* <code>args.selfClosing</code>: Force the current tag to be self-closing, even if mw.html doesn't recognize it as self-closing
* <code>args.parent</code>: Parent of the current mw.html instance (intended for internal usage)
</div>

==== mw.html:node ====
<code style="white-space:nowrap">[[#mw.html-object|html]]:node( builder )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Appends a child mw.html (<code>builder</code>) node to the current mw.html instance. If a nil parameter is passed, this is a no-op. A (<code>builder</code>) node is a string representation of an html element.
</div>

==== mw.html:wikitext ====
<code style="white-space:nowrap">[[#mw.html-object|html]]:wikitext( ... )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Appends an undetermined number of wikitext strings to the mw.html object.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that this stops at the first ''nil'' item.
</div>

<span lang="en" dir="ltr" class="mw-content-ltr">Basic wikitext will get parsed, like HTML, links, bold, lists or tables. However, templates and parser functions won't be evaluated if they are passed directly to this function, unless they came from template parameters.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">Those will be rendered in plain text instead.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">To evaluate them, they'll have to be passed through [[#frame:preprocess|frame:preprocess]].</span>

==== mw.html:newline ====
<code style="white-space:nowrap">[[#mw.html-object|html]]:newline()</code>

<span lang="en" dir="ltr" class="mw-content-ltr">Appends a newline to the mw.html object.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">Useful when used before and after [[#mw.html:wikitext|mw.html:wikitext()]], when the wikitext contains lists or tables, whose syntax only has a special meaning when present at the start of a line.</span>

==== mw.html:tag ====
<code style="white-space:nowrap">[[#mw.html-object|html]]:tag( tagName, args )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Appends a new child node with the given <code>tagName</code> to the builder, and returns a mw.html instance representing that new node. The <code>args</code> parameter is identical to that of <code>[[#mw.html.create|mw.html.create]]</code>
</div>

<span lang="en" dir="ltr" class="mw-content-ltr">Note that contrarily to other methods such as <code>[[#mw.html:node|html:node()]]</code>, this method doesn't return the current mw.html instance, but the mw.html instance of the newly inserted tag.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">Make sure to use [[#mw.html:done|<code>html:done()</code>]] to go up to the parent mw.html instance, or [[#mw.html:allDone|<code>html:allDone()</code>]] if you have nested tags on several levels.</span>

==== mw.html:attr ====
<code style="white-space:nowrap">[[#mw.html-object|html]]:attr( name, value )</code>
<br/>
<code style="white-space:nowrap">[[#mw.html-object|html]]:attr( table )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Set an HTML attribute with the given <code>name</code> and <code>value</code> on the node. Alternatively a table holding name->value pairs of attributes to set can be passed. In the first form, a value of nil causes any attribute with the given name to be unset if it was previously set.
</div>

==== mw.html:getAttr ====
<code style="white-space:nowrap">[[#mw.html-object|html]]:getAttr( name )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Get the value of a html attribute previously set using [[#mw.html:attr|<code>html:attr()</code>]] with the given <code>name</code>.
</div>

==== mw.html:addClass ====
<code style="white-space:nowrap">[[#mw.html-object|html]]:addClass( class )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Adds a class name to the node's class attribute. If a nil parameter is passed, this is a no-op.
</div>

==== mw.html:css ====
<code style="white-space:nowrap">[[#mw.html-object|html]]:css( name, value )</code>
<br/>
<code style="white-space:nowrap">[[#mw.html-object|html]]:css( table )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Set a CSS property with the given <code>name</code> and <code>value</code> on the node. Alternatively a table holding name->value pairs of properties to set can be passed. In the first form, a value of nil causes any property with the given name to be unset if it was previously set.
</div>

==== mw.html:cssText ====
<code style="white-space:nowrap">[[#mw.html-object|html]]:cssText( css )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Add some raw <code>css</code> to the node's style attribute. If a nil parameter is passed, this is a no-op.
</div>

==== mw.html:done ====
<code style="white-space:nowrap">[[#mw.html-object|html]]:done()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the parent node under which the current node was created. Like jQuery.end, this is a convenience function to allow the construction of several child nodes to be chained together into a single statement.
</div>

==== mw.html:allDone ====
<code style="white-space:nowrap">[[#mw.html-object|html]]:allDone()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Like [[#mw.html:done|<code>html:done()</code>]], but traverses all the way to the root node of the tree and returns it.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Language library ===
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Language codes are described at [[Special:MyLanguage/Language code|language code]]. Many of MediaWiki's language codes are similar to [[w:IETF language tag|IETF language tags]], but not all MediaWiki language codes are valid IETF tags or vice versa.
</div>

{{anchor|mw.language-object}}
<div lang="en" dir="ltr" class="mw-content-ltr">
Functions documented as <code>mw.language.<var>name</var></code> are available on the global <code>mw.language</code> table; functions documented as <code>mw.language:<var>name</var></code> and <code>lang:<var>name</var></code> are methods of a language object (see [[#mw.language.new|<code>mw.language.new</code>]] or [[#mw.language.getContentLanguage|<code>mw.language.getContentLanguage</code>]]).
</div>

==== mw.language.fetchLanguageName ====
<code style="white-space:nowrap">mw.language.fetchLanguageName( code, inLanguage )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
The full name of the language for the given language code: native name (language autonym) by default, name translated in target language if a value is given for <var>inLanguage</var>.
</div>

==== mw.language.fetchLanguageNames ====
<code style="white-space:nowrap">mw.language.fetchLanguageNames()</code>
<br/>
<code style="white-space:nowrap">mw.language.fetchLanguageNames( inLanguage )</code>
<br/>
<code style="white-space:nowrap">mw.language.fetchLanguageNames( inLanguage, include )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Fetch the list of languages known to MediaWiki, returning a table mapping language code to language name.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
By default the name returned is the language autonym; passing a language code for <var>inLanguage</var> returns all names in that language.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
By default, only language names known to MediaWiki are returned; passing <code>'all'</code> for <var>include</var> will return all available languages (from {{ll|Extension:CLDR}}), while passing <code>'mwfile'</code> will include only languages having customized messages included with MediaWiki core or enabled extensions. To explicitly select the default, <code>'mw'</code> may be passed.
</div>

==== mw.language.getContentLanguage ====
<code>mw.language.getContentLanguage()</code>
<br/>
<code>mw.getContentLanguage()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a new language object for the wiki's default content language.
</div>

==== mw.language.getFallbacksFor ====
[[File:MediaWiki fallback chains.svg|thumb|<span lang="en" dir="ltr" class="mw-content-ltr">Fallback chains</span>]]
<code style="white-space:nowrap">mw.language.getFallbacksFor( code )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a list of MediaWiki's fallback language codes for the specified code.
</div>

==== mw.language.isKnownLanguageTag ====
<code style="white-space:nowrap">mw.language.isKnownLanguageTag( code )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns {{luai|true}} if a language code is known to MediaWiki.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
A language code is "known" if it is a "valid built-in code" (i.e. it returns {{luai|true}} for [[#mw.language.isValidBuiltInCode|<code>mw.language.isValidBuiltInCode</code>]]) and returns a non-empty string for [[#mw.language.fetchLanguageName|<code>mw.language.fetchLanguageName</code>]].
</div>

==== mw.language.isSupportedLanguage ====
<code style="white-space:nowrap">mw.language.isSupportedLanguage( code )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Checks whether any localisation is available for that language code in MediaWiki.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
A language code is "supported" if it is a "valid" code (returns {{luai|true}} for [[#mw.language.isValidCode|<code>mw.language.isValidCode</code>]]), contains no uppercase letters, and has a message file in the currently-running version of MediaWiki.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
It is possible for a language code to be "supported" but not "known" (i.e. returning {{luai|true}} for [[#mw.language.isKnownLanguageTag|<code>mw.language.isKnownLanguageTag</code>]]). Also note that certain codes are "supported" despite [[#mw.language.isValidBuiltInCode|<code>mw.language.isValidBuiltInCode</code>]] returning {{luai|false}}.
</div>

==== mw.language.isValidBuiltInCode ====
<code style="white-space:nowrap">mw.language.isValidBuiltInCode( code )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns {{luai|true}} if a language code is of a valid form for the purposes of internal customisation of MediaWiki.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The code may not actually correspond to any known language.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
A language code is a "valid built-in code" if it is a "valid" code (i.e. it returns {{luai|true}} for [[#mw.language.isValidCode|<code>mw.language.isValidCode</code>]]); consists of only ASCII letters, numbers, and hyphens; and is at least two characters long.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Note that some codes are "supported" (i.e. returning {{luai|true}} from [[#mw.language.isSupportedLanguage|<code>mw.language.isSupportedLanguage</code>]]) even though this function returns {{luai|false}}.
</div>

==== mw.language.isValidCode ====
<code style="white-space:nowrap">mw.language.isValidCode( code )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns {{luai|true}} if a language code string is of a valid form, whether or not it exists. This includes codes which are used solely for customisation via the MediaWiki namespace.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The code may not actually correspond to any known language.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
A language code is valid if it does not contain certain unsafe characters (colons, single- or double-quotes, slashs, backslashs, angle brackets, ampersands, or ASCII NULs) and is otherwise allowed in a page title.
</div>

==== mw.language.new ====
<code style="white-space:nowrap">mw.language.new( code )</code>
<br/>
<code style="white-space:nowrap">mw.getLanguage( code )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Creates a new language object. Language objects do not have any publicly accessible properties, but they do have several methods, which are documented below.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
There is a limit of 200 on the number of distinct language codes that may be used on a page. Exceeding this limit will result in errors.
</div>

==== mw.language:getCode ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:getCode()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the language code for this language object.
</div>

==== mw.language:toBcp47Code ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:toBcp47Code()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns the standard [[w:IETF language tag|BCP-47]] language code for this language object. This is the code string which is appropriate to use in HTML, for example as the value of a <code>lang</code> attribute.
</div>

==== mw.language:getFallbackLanguages ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:getFallbackLanguages()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a list of MediaWiki's fallback language codes for this language object. Equivalent to <code style="white-space:nowrap">mw.language.getFallbacksFor( lang:getCode() )</code>.
</div>

==== mw.language:isRTL ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:isRTL()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns {{luai|true}} if the language is written right-to-left, {{luai|false}} if it is written left-to-right.
</div>

==== mw.language:lc ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:lc( s )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Converts the string to lowercase, honoring any special rules for the given language.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
When the [[#Ustring library|Ustring library]] is loaded, the [[#mw.ustring.lower|mw.ustring.lower()]] function is implemented as a call to <code style="white-space:nowrap">mw.language.getContentLanguage():lc( s )</code>.
</div>

==== mw.language:lcfirst ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:lcfirst( s )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Converts the first character of the string to lowercase, as with [[#mw.language:lc|<code>lang:lc()</code>]].
</div>

==== mw.language:uc ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:uc( s )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Converts the string to uppercase, honoring any special rules for the given language.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
When the [[#Ustring library|Ustring library]] is loaded, the [[#mw.ustring.upper|<code>mw.ustring.upper()</code>]] function is implemented as a call to <code style="white-space:nowrap">mw.language.getContentLanguage():uc( s )</code>.
</div>

==== mw.language:ucfirst ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:ucfirst( s )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Converts the first character of the string to uppercase, as with [[#mw.language:uc|lang:uc()]].
</div>

==== mw.language:caseFold ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:caseFold( s )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Converts the string to a representation appropriate for case-insensitive comparison. Note that the result may not make any sense when displayed.
</div>

==== mw.language:formatNum ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:formatNum( n )</code>
<br/>
<code style="white-space:nowrap">[[#mw.language-object|lang]]:formatNum( n, options )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Formats a number with grouping and decimal separators appropriate for the given language. Given 123456.78, this may produce "123,456.78", "123.456,78", or even something like "١٢٣٬٤٥٦٫٧٨" depending on the language and wiki configuration.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The <code>options</code> is a table of options, which can be:
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* <code>noCommafy</code>: Set {{luai|true}} to omit grouping separators and use a dot (<code>.</code>) as the decimal separator.
</div> <span lang="en" dir="ltr" class="mw-content-ltr">Digit transformation may still occur, which may include transforming the decimal separator.</span>

==== mw.language:formatDate ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:formatDate( format, timestamp, local )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Formats a date according to the given format string. If <code>timestamp</code> is omitted, the default is the current time. The value for <code>local</code> must be a boolean or nil; if {{luai|true}}, the time is formatted in the [[Special:MyLanguage/Manual:$wgLocaltimezone|wiki's local time]] rather than in UTC.
</div>

<span lang="en" dir="ltr" class="mw-content-ltr">The format string and supported values for <code>timestamp</code> are identical to those for the [[Special:MyLanguage/Help:Extension:ParserFunctions#.23time|#time parser function]] from {{ll|Extension:ParserFunctions}}.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">Note however that backslashes may need to be doubled in a Lua string literal, since Lua also uses backslash as an escape character while wikitext does not:</span>

<syntaxhighlight lang="lua">
-- This string literal contains a newline, not the two characters "\n", so it is not equivalent to {{#time:\n}}.
lang:formatDate( '\n' )

-- This is equivalent to {{#time:\n}}, not {{#time:\\n}}.
lang:formatDate( '\\n' )

-- This is equivalent to {{#time:\\n}}, not {{#time:\\\\n}}.
lang:formatDate( '\\\\n' )
</syntaxhighlight>

==== mw.language:formatDuration ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:formatDuration( seconds )</code>
<br/>
<code style="white-space:nowrap">[[#mw.language-object|lang]]:formatDuration( seconds, chosenIntervals )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Breaks a duration in seconds into more human-readable units, e.g. 12345 to 3 hours, 25 minutes and 45 seconds, returning the result as a string.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
<code>chosenIntervals</code>, if given, is a table with values naming the interval units to use in the response. These include '<code>millennia</code>', '<code>centuries</code>', '<code>decades</code>', '<code>years</code>', '<code>weeks</code>', '<code>days</code>', '<code>hours</code>', '<code>minutes</code>', and '<code>seconds</code>'.
</div>

==== mw.language:parseFormattedNumber ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:parseFormattedNumber( s )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
This takes a number as formatted by [[#mw.language:formatNum|lang:formatNum()]] and returns the actual number. In other words, this is basically a language-aware version of [[#tonumber|<code>tonumber()</code>]].
</div>

==== mw.language:convertPlural ====
{{Anchor|mw.language:plural}}
<code style="white-space:nowrap">[[#mw.language-object|lang]]:convertPlural( n, ... )</code>
<br/>
<code style="white-space:nowrap">[[#mw.language-object|lang]]:convertPlural( n, forms )</code>
<br/>
<code style="white-space:nowrap">[[#mw.language-object|lang]]:plural( n, ... )</code>
<br/>
<code style="white-space:nowrap">[[#mw.language-object|lang]]:plural( n, forms )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
This chooses the appropriate grammatical form from <code>forms</code> (which must be a [[#sequence|sequence]] table) or <code>...</code> based on the number <code>n</code>. For example, in English you might use <code style="white-space:nowrap">n .. ' ' .. lang:plural( n, 'sock', 'socks' )</code> or <code style="white-space:nowrap">n .. ' ' .. lang:plural( n, { 'sock', 'socks' } )</code> to generate grammatically-correct text whether there is only 1 sock or 200 socks.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The necessary values for the sequence are language-dependent, see [[Special:MyLanguage/Help:Magic words#Localization|localization of magic words]] and [[translatewiki:Special:MyLanguage/FAQ#PLURAL|translatewiki's FAQ on PLURAL]] for some details.
</div>

==== mw.language:convertGrammar ====
{{Anchor|mw.language:grammar}}
<code style="white-space:nowrap">[[#mw.language-object|lang]]:convertGrammar( word, case )</code>
<br/>
<code style="white-space:nowrap">[[#mw.language-object|lang]]:grammar( case, word )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
: ''Note the different parameter order between the two aliases. <code>convertGrammar</code> matches the order of the method of the same name on MediaWiki's Language object, while <code>grammar</code> matches the order of the parser function of the same name, documented at [[Special:MyLanguage/Help:Magic words#Localisation|Help:Magic words#Localisation]].''
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
This chooses the appropriate inflected form of <code>word</code> for the given inflection code <code>case</code>.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The possible values for <code>word</code> and <code>case</code> are language-dependent, see [[Special:MyLanguage/Help:Magic words#Localisation]] and [[translatewiki:Special:MyLanguage/Grammar|translatewiki:Grammar]] for some details.
</div>

==== mw.language:gender ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:gender( what, masculine, feminine, neutral )</code>
<br/>
<code style="white-space:nowrap">[[#mw.language-object|lang]]:gender( what, { masculine, feminine, neutral } )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Chooses the string corresponding to the gender of <code>what</code>, which may be "male", "female", or a registered user name.
</div>

==== mw.language:getArrow ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:getArrow( direction )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a Unicode arrow character corresponding to <code>direction</code>:
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
* '''forwards''': Either "→" or "←" depending on the directionality of the language.
* '''backwards''': Either "←" or "→" depending on the directionality of the language.
* '''left''': "←"
* '''right''': "→"
* '''up''': "↑"
* '''down''': "↓"
</div>

==== mw.language:getDir ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:getDir()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns "ltr" or "rtl", depending on the directionality of the language.
</div>

==== mw.language:getDirMark ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:getDirMark( opposite )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a string containing either U+200E (the left-to-right mark) or U+200F (the right-to-left mark), depending on the directionality of the language and whether <code>opposite</code> is a true or false value.
</div>

==== mw.language:getDirMarkEntity ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:getDirMarkEntity( opposite )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns "&amp;lrm;" or "&amp;rlm;", depending on the directionality of the language and whether <code>opposite</code> is a true or false value.
</div>

==== mw.language:getDurationIntervals ====
<code style="white-space:nowrap">[[#mw.language-object|lang]]:getDurationIntervals( seconds )</code>
<br/>
<code style="white-space:nowrap">[[#mw.language-object|lang]]:getDurationIntervals( seconds, chosenIntervals )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Breaks a duration in seconds into more human-readable units, e.g. 12345 to 3 hours, 25 minutes and 45 seconds, returning the result as a table mapping unit names to numbers.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
<code>chosenIntervals</code>, if given, is a table with values naming the interval units to use in the response. These include '<code>millennia</code>', '<code>centuries</code>', '<code>decades</code>', '<code>years</code>', '<code>weeks</code>', '<code>days</code>', '<code>hours</code>', '<code>minutes</code>', and '<code>seconds</code>'.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
Those unit keywords are also the keys used in the response table. Only units with a non-zero value are set in the response, unless the response would be empty in which case the smallest unit is returned with a value of 0.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
=== Message library ===
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
This library is an interface to the localisation messages and the MediaWiki: namespace.
</div>

{{anchor|mw.message-object}}
<div lang="en" dir="ltr" class="mw-content-ltr">
Functions documented as <code>mw.message.<var>name</var></code> are available on the global <code>mw.message</code> table; functions documented as <code>mw.message:<var>name</var></code> and <code>msg:<var>name</var></code> are methods of a message object (see [[#mw.message.new|<code>mw.message.new</code>]]).
</div>

==== mw.message.new ====
<code style="white-space:nowrap">mw.message.new( key, ... )</code>

<span lang="en" dir="ltr" class="mw-content-ltr">Creates a new message object for the given message <code>key</code>.</span>
<span lang="en" dir="ltr" class="mw-content-ltr">The remaining parameters are passed to the new object's <code>[[#mw.message:params|params()]]</code> method.</span>

<div lang="en" dir="ltr" class="mw-content-ltr">
The message object has no properties, but has several methods documented below.
</div>

==== mw.message.newFallbackSequence ====
<code style="white-space:nowrap">mw.message.newFallbackSequence( ... )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Creates a new message object for the given messages (the first one that exists will be used).
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The message object has no properties, but has several methods documented below.
</div>

==== mw.message.newRawMessage ====
<code style="white-space:nowrap">mw.message.newRawMessage( msg, ... )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Creates a new message object, using the given text directly rather than looking up an internationalized message. The remaining parameters are passed to the new object's <code>[[#mw.message:params|params()]]</code> method.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
The message object has no properties, but has several methods documented below.
</div>

==== mw.message.rawParam ====
<code style="white-space:nowrap">mw.message.rawParam( value )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Wraps the value so that it will not be parsed as wikitext by <code>[[#mw.message:parse|msg:parse()]]</code>.
</div>

==== mw.message.numParam ====
<code style="white-space:nowrap">mw.message.numParam( value )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Wraps the value so that it will automatically be formatted as by <code>[[#mw.language:formatNum|lang:formatNum()]]</code>. Note this does not depend on the [[#Language library|Language library]] actually being available.
</div>

==== mw.message.getDefaultLanguage ====
<code style="white-space:nowrap">mw.message.getDefaultLanguage()</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Returns a Language object for the default language.
</div>

==== mw.message:params ====
<code style="white-space:nowrap">[[#mw.message-object|msg]]:params( ... )</code>
<br/>
<code style="white-space:nowrap">[[#mw.message-object|msg]]:params( params )</code>

<div lang="en" dir="ltr" class="mw-content-ltr">
Add parameters to the message, which may be passed as individual arguments or as a [[#sequence|sequence]] table. Parameters must be numbers, strings, or the special values returned by [[#mw.message.numParam|mw.message.numParam()]] or [[#mw.message.rawParam|mw.message.rawParam()]]. If a sequence table is used, parameters must be directly present in the table; references using the [[#Metatables|__index metamethod]] will not work.
</div>