View source for Extension:Scribunto/Lua reference manual/cs

<languages />
<!--WARNING: This page is 252 kio long; consider shortening it to better serve readers.--> 
{{Shortcut|Lua manual|LUAREF}}
Tato příručka je založena na rozšíření {{ll|Lua}}.
Některé části jsou odvozeny z [https://www.lua.org/manual/5.1/index.html Lua 5.1 referenčního manuálu], který je dostupný pod [[#License|MIT licencí]].

{{mbox
| type = notice
| text = Tato stránka dokumentuje nejnovější verzi rozšíření Scribunto. Některé funkce ještě nemusí být nasazeny.
}}
{{TOCright}}

<span id="Introduction"></span>
== Úvod ==

<span id="Getting_started"></span>
=== Začínáme ===
Na wiki MediaWiki s povoleným Scribunto [[Special:MyLanguage/Help:Starting a new page|vytvořte stránku]] s názvem začínajícím na <code>Module:</code>, například "[[Module:Bananas]]".
Na tuto novou stránku zkopírujte následující text:

<syntaxhighlight lang="lua">
local p = {} --p znamená balíček

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

return p
</syntaxhighlight>

Uložte to a poté na jinou (nemodulovou) stránku, jako na [[Sandbox|sandbox page]], napište:
<pre>
{{#invoke:Bananas|hello}}
</pre>
Až na to, že byste měli nahradit "Bananas" jakkoli, co jste nazvali modul. To zavolá funkci "hello" exportovanou z tohoto modulu. <code><nowiki>{{#invoke:Bananas|hello}}</nowiki></code> bude nahrazeno textem, který funkce vrátila, v tomto případě "Hello, world!"

Obecně je dobré vyvolat kód Lua z kontextu šablony.
To znamená, že z pohledu volající stránky je syntaxe nezávislá na tom, zda je logika šablony implementována v Lua nebo ve wikitextu.
Také se vyhne zavedení další složité syntaxe do jmenného prostoru obsahu wiki.

<span id="Module_structure"></span>
=== Struktura modulu ===
Samotný modul musí vrátit tabulku Lua obsahující funkce, které může <code><nowiki>{{#invoke:}}</nowiki></code> volat.
Obecně, jak je uvedeno výše, je deklarována lokální proměnná obsahující tabulku, funkce jsou přidány do této tabulky a tabulka je vrácena na konec kódu modulu.

Jakékoli funkce, které nejsou přidány do této tabulky, ať už lokální nebo globální, nebudou přístupné pro <code><nowiki>{{#invoke:}}</nowiki></code>, ale globální mohou být přístupné z jiných modulů načtených pomocí <code>[[#require|require()]]</code>.
Obecně je dobrým stylem modulu deklarovat všechny funkce a proměnné jako místní.

<span id="Accessing_parameters_from_wikitext"></span>
=== Přístup k parametrům z wikitextu ===

Funkce volané <code><nowiki>{{#invoke:}}</nowiki></code> budou předány jediným parametrem, kterým je [[#frame-object|frame objekt]]. Pro přístup k parametrům předávaným do <code><nowiki>{{#invoke:}}</nowiki></code> bude kód obvykle používat tabulku <code>[[#frame.args|args]]</code> daného objektu frame. Je také možné přistupovat k parametrům předávaným do šablony obsahující <code><nowiki>{{#invoke:}}</nowiki></code> pomocí <code>[[#frame:getParent|frame:getParent()]]</code> a přístupu k <code>args</code> daného frame.

Tento objekt frame se také používá pro přístup ke kontextově specifickým funkcím analyzátoru wikitextu, jako je [[#frame:callParserFunction|volání funkcí analyzátoru]], [[#frame:expandTemplate|rozšiřující šablony]] a [[#frame:preprocess|rozšiřování libovolných řetězců wikitextu ]].

<span id="Returning_text"></span>
=== Vracející se text ===

Funkce modulu by měla obvykle vracet jeden řetězec; jakékoli vrácené hodnoty budou předány přes [[#tostring|tostring()]] a poté zřetězeny bez oddělovače. Tento řetězec je začleněn do wikitextu jako výsledek <code><nowiki>{{#invoke:}}</nowiki></code>.

V tomto okamžiku analýzy stránky již byly šablony rozšířeny, funkce analyzátoru a značky rozšíření již byly zpracovány a [[Special:MyLanguage/Pre-save transforms|pre-save transforms]] (tj. už se stalo). Modul proto nemůže tyto funkce použít ve svém výstupním textu. Pokud například modul vrátí <code><nowiki>"Hello, [[world]]! {{welcome}}"</nowiki></code>, stránka bude číst "Hello, [[world]]! <nowiki>{{welcome}}</nowiki>".

Na druhou stranu [[Special:MyLanguage/Help:Substitution|subst]] je zpracováno v dřívější fázi zpracování, takže s <code><nowiki>{{subst:#invoke:}}</nowiki></code> budou zpracovány pouze další pokusy o substituci. Protože neúspěšné nahrazení zůstane ve wikitextu, bude poté zpracováno při ''další'' úpravě. Tomu je třeba se obecně vyhnout.

<span id="Module_documentation"></span>
=== Dokumentace modulu ===

Scribunto umožňuje dokumentaci modulů automatickým přidružením modulu k dokumentační stránce wikitextu. Ve výchozím nastavení se pro tento účel používá podstránka modulu "/doc" a je umístěna nad zdrojovým kódem modulu na stránce modulu. Například dokumentace pro "Module:Bananas" by byla na "Module:Bananas/doc".

To lze nakonfigurovat pomocí stránky {{ll|Nápověda:Systémová zpráva}}:

* <code>scribunto-doc-page-name</code> — nastaví název stránky použité pro dokumentaci. Název modulu (bez předpony Module:) je předán jako <code>$1</code>. Pokud jsou ve jmenném prostoru modulu, zde uvedené stránky budou interpretovány jako wikitext spíše než zdroj Lua a nelze je použít s <code><nowiki>{{#invoke:}}</nowiki></code>. Výchozí hodnota je "Module:$1/doc", tj. podstránka /doc modulu. Všimněte si, že v této zprávě nelze použít funkce analyzátoru a další rozšíření složené závorky.
* <code>scribunto-doc-page-does-not-exist</code> — zpráva se zobrazí, pokud stránka dokumentu neexistuje. Název stránky je předán jako <code>$1</code>. Výchozí hodnota je prázdná.
* <code>scribunto-doc-page-show</code> — zpráva se zobrazí, pokud stránka dokumentu existuje. Název stránky je předán jako <code>$1</code>. Výchozí nastavení je převést stránku dokumentace.
* <code>scribunto-doc-page-header</code> — záhlaví zobrazené při prohlížení samotné stránky dokumentace. Název modulu (s prefixem Module:), který je dokumentován, je předán jako <code>$1</code>. Ve výchozím nastavení se jednoduše zobrazí krátké vysvětlení kurzívou.

Upozorňujeme, že moduly nelze přímo kategorizovat.
Vložení kategorií lze umístit na stránku dokumentace do značek {{tag|includeonly}}, kde budou aplikovány na modul, když se stránka dokumentace přenese na stránku modulu.

<span id="Renaming_or_moving_modules"></span>
=== Přejmenování nebo přesun modulů ===

Chcete-li modul přejmenovat nebo přesunout, použijte odkaz <u>Přesunout stránku</u> na postranním panelu Nástroje. Můžete přesunout jak samotný modul, tak i podstránku obsahující jeho dokumentaci.

<span id="Redirects"></span>
=== Přesměrování ===
{{MW version|version=1.42|gerrit change=574086}}
Od verze 1.42, Scribunto rozpoznává jednu konkrétní syntaxi pro přesměrování (takže jsou zvýrazněna na speciálních stránkách, objevují se na Special:WhatLinksHere atd.) a také vytváří přesměrování při přejmenování/přesunutí modulu, podobně jako přejmenování stránek wikitextu funguje (předtím po přejmenování modulů nezůstala žádná přesměrování, nyní jsou k potlačení přesměrování potřeba další práva).

Chcete-li ručně vytvořit přesměrování modulu, použijte následující syntaxi (což je platný kód Lua a fungovalo jako přesměrování i před verzí 1.42, ale bez toho, aby to MediaWiki jako takové rozpoznalo):
<syntaxhighlight lang="lua">
return require [[Module:Foo]]
</syntaxhighlight>
Nahraďte <code>Foo</code> názvem modulu, na který chcete přesměrovat.

Upozorňujeme, že další podobně platné varianty syntaxe Lua (např. použití uvozovek místo hranatých závorek, použití závorek kolem parametru <code>require</code> nebo dokonce variace mezer) MediaWiki stále nerozpozná jako přesměrování.

<span id="Lua_language"></span>
== Jazyk Lua ==

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

{{Anchor|name}}
''Jméno'' (nazývané také ''identifikátor'') v Lua může být libovolný řetězec písmen, číslic a podtržítek, který nezačíná číslicí. V názvech se rozlišují velká a malá písmena; "foo", "Foo" a "FOO" jsou různá jména.

Následující klíčová slova jsou vyhrazena a nelze je použít jako názvy:

<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>

Názvy začínající podtržítkem následovaným velkými písmeny jsou vyhrazeny pro interní globální proměnné Lua.

Další tokeny jsou:

<div style="margin:0.3em 1.6em; column-width: 10em;">
* <code>#</code>
* <code>%</code>
* <code>(</code>
* <code>)</code>
* <code>*</code>
* <code>+</code>
* <code>,</code>
* <code>-</code>
* <code>--</code>
* <code>.</code>
* <code>..</code>
* <code>...</code>
* <code>/</code>
* <code>:</code>
* <code>;</code>
* <code>&lt;</code>
* <code>&lt;=</code>
* <code>=</code>
* <code>==</code>
* <code>&gt;</code>
* <code>>=</code>
* <code>[</code>
* <code>]</code>
* <code>^</code>
* <code>{</code>
* <code>}</code>
* <code>~=</code>
</div>

<span id="Comments"></span>
=== Komentáře ===

Komentář začíná znakem <code>--</code> kdekoli mimo řetězec. Pokud za <code>--</code> bezprostředně následuje [[#long brackets|úvodní dlouhá závorka]], komentář pokračuje do odpovídající uzavírací dlouhé závorky. Jinak komentář běží na konec aktuálního řádku.

<syntaxhighlight lang="lua">
-- Komentář v Lua začíná dvojitou pomlčkou a běží na konec řádku.
--[[ Víceřádkové řetězce a komentáře
      jsou ohraničeny dvojitými hranatými závorkami. ]]
--[=[ Komentáře jako tento mohou mít vnořené další ---[[komentáře]]. ]=]
--[==[ Komentáře jako tento mohou mít i jiné
      --[===[ dlouhé --[=[komentáře]=] --vnořené
        ]===] vícekrát, i když jsou všechny
      --[[ neohraničeny odpovídajícími dlouhými závorkami! ]===]
  ]==]
</syntaxhighlight>

<span id="Data_types"></span>
=== Datové typy ===

Lua je dynamicky typovaný jazyk, což znamená, že proměnné a argumenty funkcí nemají žádný typ, pouze hodnoty, které jsou jim přiřazeny. Všechny hodnoty nesou typ.

Lua má osm základních datových typů, avšak pouze šest je relevantních pro rozšíření Scribunto. Funkce <code>[[#type|type()]]</code> vrátí typ hodnoty.

Funkce <code>[[#tostring|tostring()]]</code> převede hodnotu na řetězec. Funkce <code>[[#tonumber|tonumber()]]</code> převede hodnotu na číslo, pokud je to možné, a jinak vrátí nulu. Neexistují žádné explicitní funkce pro převod hodnoty na jiné datové typy.

Čísla jsou automaticky převedena na řetězce při použití tam, kde se očekává řetězec, např. při použití s operátorem zřetězení. Řetězce rozpoznávané funkcí <code>[[#tonumber|tonumber()]]</code> jsou automaticky převedeny na čísla při použití s aritmetickými operátory. Když se očekává logická hodnota, všechny hodnoty kromě nula a false jsou považovány za pravdivé.

==== nil ====

{{luai|"nil"}} je datový typ {{luai|nil}}, který představuje absenci hodnoty.

Nil nelze použít jako klíč v tabulce a není žádný rozdíl mezi nepřiřazeným klíčem tabulky a klíčem, kterému je přiřazena nulová hodnota.

Při převodu na řetězec je výsledek {{luai|"nil"}}. Při převodu na booleovskou hodnotu je nil považováno za nepravdivé.

Poznámka: Lua v některých omezených situacích rozlišuje mezi {{luai|nil}} a vůbec ničím.
Například {{luai|tostring(nil)}} vrátí {{luai|"nil"}}, ale {{luai|tostring()}} vyvolá chybu, protože první parametr je povinný.
Toto rozlišení je zvláště důležité pro funkci [[#select|select()]].

==== boolean ====

Booleovské hodnoty jsou {{luai|true}} a {{luai|false}}.

Při převodu na řetězec je výsledek {{luai|"true"}} nebo {{luai|"false"}}.

Na rozdíl od mnoha jiných jazyků nemusí být booleovské hodnoty přímo převedeny na čísla. A na rozdíl od mnoha jiných jazyků, pouze {{luai|false}} a nul jsou považovány za false pro booleovskou konverzi. Číslo 0 a prázdný řetězec se považují za pravdivé.

<span id="string"></span>
==== řetězec ====

Lua řetězce jsou považovány za sérii 8bitových bajtů. Je na aplikaci, aby je interpretovala v jakémkoli konkrétním kódování.

Řetězcové literály mohou být odděleny buď jednoduchými nebo dvojitými uvozovkami (<code>'</code> nebo <code>"</code>). Jako JavaScript a na rozdíl od PHP mezi nimi není žádný rozdíl. Jsou rozpoznány následující sekvence escape:

<div style="column-width:20em;">
* <code>\a</code> (zvonek, byte 7)
* <code>\b</code> (backspace, byte 8)
* <code>\t</code> (horizontální tab, byte 9)
* <code>\n</code> (nový řádek, byte 10)
* <code>\v</code> (vertikální tab, byte 11)
* <code>\f</code> (form feed, byte 12)
* <code>\r</code> (carriage return, byte 13)
* <code>\"</code> (double quote, byte 34)
* <code>\'</code> (single quote, byte 39)
* <code>\\</code> (backslash, byte 92)
</div>

Doslovný nový řádek může být také zahrnut do řetězce tak, že jej předchází zpětné lomítko. Bajty lze také zadat pomocí escape sekvence '\''ddd''<nowiki/>', kde ''ddd'' je desetinná hodnota bajtu v rozsahu 0–255. Chcete-li zahrnout znaky Unicode pomocí sekvencí escape, musí být specifikovány jednotlivé bajty pro kódování [[:en:UTF-8|UTF-8]]. Obecně bude jednodušší zadávat znaky Unicode přímo.

{{Anchor|long brackets}}
Doslovné řetězce lze také definovat pomocí ''dlouhých závorek''.
Úvodní dlouhá závorka se skládá z otevírací hranaté závorky následované nulou nebo více stejnými znaménky, za nimiž následuje další otevírací hranatá závorka, např. <code><nowiki>[[</nowiki></code>, <code>[=[</code> nebo <code>[=====[</code>.
Otevírací dlouhá závorka musí odpovídat odpovídající zavírací dlouhé závorce, např. <code><nowiki>]]</nowiki></code>, <code>]=]</code> nebo <code>]=====]</code>.
Ve speciálním případě, pokud je po úvodní dlouhé závorce bezprostředně následován nový řádek, nový řádek není zahrnut do řetězce, ale nový řádek těsně před uzavírací dlouhou závorkou je zachován.
Řetězce oddělené dlouhými závorkami neinterpretují escape sekvence.

<syntaxhighlight lang="lua">
-- dlouhý řetězec
foo = [[
bar\tbaz
]]

-- je ekvivalentní tomuto řetězci oddělenému uvozovkami
foo = 'bar\\tbaz\n'
</syntaxhighlight>

Všimněte si, že všechny řetězce jsou považovány za pravdivé, když jsou převedeny na booleovské. To je na rozdíl od většiny ostatních jazyků, kde je prázdný řetězec obvykle považován za nepravdivý.

<span id="number"></span>
==== číslo ====

Lua má pouze jeden číselný typ, který je obvykle interně reprezentován jako [[:en:double-precision floating-point format|64bitová hodnota s plovoucí desetinnou čárkou s dvojitou přesností]]. V tomto formátu mohou být celá čísla mezi <code>-9007199254740991</code> (-2<sup>53</sup> + 1) a <code>9007199254740991</code> (2<sup>53</sup> - 1) reprezentována přesně. Větší čísla a čísla se zlomkovou částí mohou trpět zaokrouhlovací chybou.

Číselné konstanty se zadávají pomocí tečky (<code>.</code>) jako oddělovač desetinných míst a bez oddělovačů seskupení, např. <code>123456.78</code>.
Čísla mohou být také reprezentována pomocí [[:en:E notation|E notace]] bez mezer, např. <code>1.23e-10</code>e-10, <code>1.23e-10</code>e20 nebo <code>1.23e-10</code>e5.
Celá čísla mohou být také specifikována v hexadecimálním zápisu pomocí předpony <code>0x</code>, např. <code>0x3A</code>.

S malým počtem číselných hodnot se zachází zvláštním způsobem:
* Kladné a záporné nekonečno, které jsou vyhodnoceny jako větší nebo menší než každé jiné číslo (kromě NaN - viz níže). Lze k nim přistupovat dvěma způsoby: prostřednictvím knihovny {{luai|math}}, jako {{luai|math.huge}} a {{luai|-math.huge}}, nebo pomocí numerických operací jako <code>1/0</code> a <code>-1/0</code>.
* Lua občas rozlišuje <code>0</code> a <code>-0</code> (více informací o nulách se znaménkem viz [[w:IEEE 754#Signed zero|IEEE 754]]). <code>0</code> a <code>-0</code> jsou přísně ekvivalentní pro téměř všechny účely, ale chovají se odlišně v malém počtu numerických operací (např. <code>1/0</code> vrátí nekonečno , zatímco <code>1/-0</code> vrací záporné nekonečno). Rozdíl také ovlivňuje převody z čísla na řetězec (a naopak).
* Pozitivní a negativní [[:en:NaN|NaN]] (znamenající Not a Number). Žádná konstanta není poskytnuta pro žádnou z nich, ale <code>0/0</code> se vyhodnotí jako negativní NaN. Všimněte si, že obě NaN mají jedinečnou kvalitu, kterou jakékoli srovnání, které je zahrnuje, vyhodnotí jako {{luai|false}} (což znamená, že se ani nevyhodnotí jako sobě rovné). Jediný praktický rozdíl mezi těmito dvěma je převod typu do az řetězce (viz níže).

Všimněte si, že všechna čísla (včetně <code>0</code>, <code>-0</code>, nekonečna a NaN) jsou při převodu na booleovské hodnoty považována za pravdivá. To je na rozdíl od většiny ostatních jazyků, kde se <code>0</code> obvykle považuje za nepravdu. Při převodu na řetězec jsou konečná čísla reprezentována v desítkové soustavě a zápisu E, pokud je 10<sup>14</sup> nebo větší (např. {{luai|"1e+14"}}); nekonečna jsou {{luai|"inf"}} a {{luai|"-inf"}}; a NaN jsou {{luai|"nan"}} a {{luai|"-nan"}}.

{{red|Známá chyba}}: interpret Lua bude se všemi výskyty <code>0</code> '''a''' <code>-0</code> zacházet jako s tím, který z nich narazí jako první když je skript zkompilován, což znamená, že návratové hodnoty {{luai|tostring(0)}}, {{luai|1/-0}} (a tak dále) jsou ovlivněny tím, kde se v kódu vyskytují.
To může způsobit neočekávané výsledky, zejména pokud jsou všechny instance <code>0</code> při návratu převedeny na {{luai|"-0"}}.
V případě potřeby to lze obejít vygenerováním nulových hodnot pomocí {{luai|tonumber("0")}} a {{luai|tonumber("-0")}}, které zřejmě nezpůsobují ani nejsou ovlivněny problém. Viz [https://lua-l.lua.narkive.com/k4kbwgKi/tostring-and-0].

<span id="table"></span>
==== tabulka ====

Tabulky Lua jsou asociativní pole, podobně jako pole PHP a objekty JavaScriptu.

Tabulky se vytvářejí pomocí složených závorek. Prázdná tabulka je <code>{}</code>. Pro naplnění polí při vytváření může být do složených závorek zahrnut seznam specifikátorů polí oddělených čárkou nebo středníkem. Mohou mít několik podob:

* * <code style="white-space:nowrap">[''[[#Expressions|expression1]]''] = ''[[#Expressions|expression2]]''</code> používá (první) hodnotu ''expression1'' jako klíč a (první) hodnotu ''expression2'' jako hodnotu.
* * <code style="white-space:nowrap">''[[#name|name]]'' = ''[[#Expressions|expression]]''</code> odpovídá <code style="white-space:nowrap">["''name''"] = ''expression''</code>
* * <code>''[[#Expressions|expression]]''</code> je zhruba ekvivalentní <code style="white-space:nowrap">[''i''] = ''expression''</code>, kde ''i'' je celé číslo začínající na 1 a zvyšující se s každou specifikací pole tohoto formuláře. Pokud se jedná o poslední specifikátor pole a výraz má více hodnot, použijí se všechny hodnoty. Jinak zůstane zachováno pouze první.

K polím v tabulce se přistupuje pomocí zápisu v závorkách, např. <code>table[key]</code>. K řetězcovým klíčům, které jsou také platné [[#name|names]], lze také přistupovat pomocí tečkové notace, např. <code>table.key</code> odpovídá <code>table['key']</code>. Volání funkce, která je hodnotou v tabulce, může používat zápis dvojtečkou. Například <code style="white-space:nowrap">table:func( ... )</code>, což odpovídá <code style="white-space:nowrap">table['func']( table, ... )</code> nebo <code style="white-space:nowrap">table.func( table, ... )</code>.

{{Anchor|sequence}}
''Pole'' (také nazývané ''sekvence'' nebo ''seznam'') je tabulka s nenulovými hodnotami pro všechna kladná celá čísla od 1 do N a bez hodnoty (nula) pro všechna kladná celá čísla větší než N. Mnoho funkcí Lua pracuje pouze s poli a ignoruje klíče s kladnými celými čísly.

Na rozdíl od mnoha jiných jazyků, jako je PHP nebo JavaScript, lze jako klíč použít jakoukoli hodnotu kromě nil a NaN a neprovádí se žádná konverze typu. Všechny jsou platné a odlišné:

<syntaxhighlight lang="lua">
-- Vytvoření tabulky
t = {}
t["foo"] = "foo"
t.bar = "bar"
t[1] = "jedna"
t[2] = "dva"
t[3] = "tři"
t[12] = "číslo dvanáct"
t["12"] = "řetězec dvanáct"
t[true] = "true"
t[tonumber] = "ano, i funkce mohou být klíče tabulky"
t[t] = "ano, tabulka může být také klíčem k tabulce. Dokonce i sama o sobě."

-- Vznikne tak tabulka zhruba ekvivalentní výše uvedené
t2 = {
    foo = "foo",
    bar = "bar",
    "jedna",
    "dva",
    [12] = "číslo dvanáct"
    ["12"] = "řetězec dvanáct"
    "tři"
    [true] = "true",
    [tonumber] = "ano, i funkce mohou být klíče tabulky"
}
t2[t2] = "ano, tabulka může být také klíčem k tabulce. Dokonce i sama o sobě."
</syntaxhighlight>

Podobně jakákoliv hodnota kromě nil může být uložena jako hodnota v tabulce. Uložení nil je ekvivalentní smazání klíče z tabulky a přístup k libovolnému klíči, který nebyl nastaven, bude mít za následek hodnotu nil.

Všimněte si, že tabulky nejsou nikdy implicitně zkopírovány v Lua. Pokud je funkci předána jako argument tabulka a funkce manipuluje s klíči nebo hodnotami v tabulce, tyto změny budou viditelné ve volajícím.

Při převodu na řetězec je obvyklým výsledkem "tabulka", ale může být přepsána pomocí <code>__tostring</code> [[#Metatables|metametody]]. Dokonce i prázdná tabulka je považována za pravdivou jako boolean.

<span id="function"></span>
==== funkce ====

Funkce v Lua jsou priritní hodnoty: Mohou být vytvořeny anonymně, předány jako argumenty, přiřazeny k proměnným a tak dále.

Funkce se vytvářejí pomocí klíčového slova <code>function</code> a volají se pomocí závorek. [[w:syntactic sugar|Syntactic sugar]] je dostupný pro pojmenované funkce, lokální funkce a funkce, které fungují jako členské funkce tabulky. Podrobnosti viz [[#Function declarations|Deklarace funkcí]] a [[#Function calls|Volání funkcí]] níže.

Funkce Lua jsou [[w:Closure (computer science)|uzavřené]], což znamená, že udržují odkaz na rozsah, ve kterém jsou deklarovány, a mohou přistupovat a manipulovat s proměnnými v tomto rozsahu.

Stejně jako tabulky, pokud je funkce přiřazena jiné proměnné nebo předána jako argument jiné funkci, je to stále stejný základní "funkční objekt", který bude volán.

Po převodu na řetězec je výsledkem "funkce".

<span id="Unsupported_types"></span>
==== Nepodporované typy ====

{{Anchor|userdata}}
Typ ''userdata'' se používá k uchování neprůhledných hodnot pro rozšíření Lua napsaná v jiných jazycích. Například uživatelská data mohou být použita k udržení ukazatele C nebo struktury. Aby bylo možné používat Scribunto v hostitelských prostředích, kde není povolen vlastní kompilovaný kód, žádná taková rozšíření se nepoužívají.

{{Anchor|thread}}
Typ ''thread'' (vlákno) představuje úchyty pro rutiny, které nejsou dostupné v sandboxu Scribunto.

<span id="Upvalues"></span>
=== Upvalues (vyšší hodnoty) ===

Existuje přísný limit na max. 60 jedinečných hodnot zpřístupněných uvnitř funkce. Upvalue je hodnota deklarovaná mimo funkci a použitá v ní. Jak se hodnoty počítají:
* proměnné (tabulka s mnoha prvky se počítá jako jedna vyšší hodnota)
* funkce (pouze ty přímo volané z dané funkce, nikoli jejich závislosti)
Překročení limitu může být vyvoláno použitím takové proměnné nebo funkce, nikoli její pouhou přítomností nebo dostupností. Opakovaný přístup ke stejné hodnotě limit dále nevyčerpává.

<span id="Metatables"></span>
=== Meta tabulky ===

Každá tabulka může mít přidruženou tabulku známou jako ''metatable''. Pole v metatabulce používají některé operátory a funkce k určení odlišného nebo záložního chování pro tabulku. K metatabulce pro tabulku lze přistupovat pomocí funkce [[#getmetatable|getmetatable()]] a nastavit ji pomocí funkce [[#setmetatable|setmetatable()]].

Při přístupu k jejich meta funkcím se k polím metatabulek přistupuje jako s [[#rawget|rawget()]].

Metatable pole, která ovlivňují samotnou tabulku, jsou:
; __index
: používá se, když by přístup k tabulce <code>t[key]</code> vrátil nulu. Pokud je hodnotou tohoto pole tabulka, přístup se bude v této tabulce opakovat, tj. <code>__index[key]</code> (což může vyvolat __index metatabulky této tabulky). Pokud je hodnotou tohoto pole funkce, funkce bude volána jako <code style="white-space:nowrap">__index( t, key )</code>. Funkce [[#rawget|rawget()]] tuto metametodu obchází.
; __newindex
: používá se při přiřazování klíče k tabulce <code style="white-space:nowrap">t[key] = hodnota</code>, kde <code style="white-space:nowrap">[[#rawget|rawget]]( t, key )</code> vrátí nulu. Pokud je hodnotou tohoto pole tabulka, přiřazení bude provedeno k této tabulce, tj. <code style="white-space:nowrap">__newindex[key] = hodnota</code> (což může vyvolat metatabulku této tabulky __newindex). Pokud je hodnotou tohoto pole funkce, funkce bude volána jako <code style="white-space:nowrap">__newindex( t, klíč, hodnota )</code>. Funkce [[#rawset|rawset()]] tuto metametodu obchází.
; __call
: používá se, pokud je v tabulce použita syntaxe volání funkce, <code style="white-space:nowrap">t( ··· )</code>. Hodnota musí být funkce, která se nazývá něco jako <code style="white-space:nowrap">__call( t, ··· )</code>.
; {{Anchor|weak tables}}__mode
: používá se k vytvoření tabulek obsahujících slabé reference. Hodnota musí být řetězec. Ve výchozím nastavení nebude žádná hodnota, která je použita jako klíč nebo jako hodnota v tabulce, shromažďována. Pokud však toto metapole obsahuje písmeno 'k', mohou být klíče shromážděny nesmyslně, pokud neexistují žádné slabé odkazy, a pokud obsahuje hodnoty 'v', mohou být. V obou případech se z tabulky odstraní odpovídající klíč i hodnota. Všimněte si, že chování není definováno, pokud je toto pole změněno poté, co je tabulka použita jako metatabulka.

Mezi další metatabulková pole patří:

<div style="margin:0 1.6em; column-width: 10em;">
* [[#Arithmetic operators|__add]]<sup>[[#binop-note|†]]</sup>
* [[#Arithmetic operators|__sub]]<sup>[[#binop-note|†]]</sup>
* [[#Arithmetic operators|__mul]]<sup>[[#binop-note|†]]</sup>
* [[#Arithmetic operators|__div]]<sup>[[#binop-note|†]]</sup>
* [[#Arithmetic operators|__mod]]<sup>[[#binop-note|†]]</sup>
* [[#Arithmetic operators|__pow]]<sup>[[#binop-note|†]]</sup>
* [[#Arithmetic operators|__unm]]
* [[#Concatenation operator|__concat]]<sup>[[#binop-note|†]]</sup>
* [[#Relational operators|__eq]]<sup>[[#relop-note|‡]]</sup>
* [[#Relational operators|__lt]]<sup>[[#relop-note|‡]]</sup>
* [[#Relational operators|__le]]<sup>[[#relop-note|‡]]</sup>
* [[#pairs|__pairs]]
* [[#ipairs|__ipairs]]
* __metatable<sup>[[#metatable-note|*]]</sup>
* [[#tostring|__tostring]]
</div>

<div style="font-size:smaller">
<div id="binop-note" style="padding:0 1em;text-indent: -1em;"><sup>†</sup> U binárních operátorů se Lua nejprve podívá na metatabulku levého argumentu (pokud existuje), pak na pravou, když hledá metametodu k použití.</div>
<div id="relop-note" style="padding:0 1em;text-indent: -1em;"><sup>‡</sup> U relačních operátorů se metametoda používá pouze v případě, že je v metatabulkách obou argumentů zadána stejná funkce. Různé anonymní funkce, dokonce i se stejným tělem a uzávřením, nelze považovat za stejné.</div>
<div id="metatable-note" style="padding:0 1em;text-indent: -1em;"><sup>*</sup> 
__metatable ovlivňuje jak [[#getmetatable|getmetatable()]], tak [[#setmetatable|setmetatable()]]</div>
</div>

Poznámka: V Lua všechny řetězce také sdílejí jednu metatabulku, ve které <code>__index</code> odkazuje na <code>[[#String library|string]]</code> tabulku. Tato metatabulka není ve Scribuntu přístupná, stejně jako odkazovaná tabulka <code>string</code>. Tabulka řetězců dostupná pro moduly je kopií.

<span id="Variables"></span>
=== Proměnné ===

Proměnné jsou místa, která uchovávají hodnoty. V Lua jsou tři druhy proměnných: globální proměnné, lokální proměnné a pole tabulky.

[[#name|Jméno]] představuje globální nebo lokální proměnnou (nebo argument funkce, což je jen druh lokální proměnné). Předpokládá se, že proměnné jsou globální, pokud nejsou explicitně deklarovány jako lokální pomocí klíčového slova <code>local</code>. Každá proměnná, které nebyla přiřazena žádná hodnota, je považována za nulovou.

Globální proměnné jsou uloženy ve standardní Lua tabulce zvané ''environment'' (prostředí). Tato tabulka je často dostupná jako globální proměnná <code>_G</code>. Pro tuto tabulku globálních proměnných je možné nastavit metatabulku. Metametody __index a __newindex budou volány pro přístupy a přiřazení ke globálním proměnným stejně jako pro přístupy a přiřazení k polím v jakékoli jiné tabulce.

K prostředí pro funkci lze přistupovat pomocí funkce [[#getfenv|getfenv()]] a měnit pomocí funkce [[#setfenv|setfenv()]]. Ve Scribuntu jsou tyto funkce přísně omezeny, pokud jsou vůbec dostupné.

Lokální proměnné jsou lexikálně vymezeny. Podrobnosti naleznete na stránce [[#Local variable declarations|Deklarace místních proměnných]].

<span id="Expressions"></span>
=== Výrazy ===

''Výraz'' je něco, co má hodnoty: literály (čísla, řetězce, pravda, nepravda, nula), anonymní deklarace funkcí, konstruktory tabulek, odkazy na proměnné, volání funkcí, [[#varargs|výraz vararg]], zabalené výrazy v závorkách, unární operátory aplikované na výrazy a výrazy kombinované s binárními operátory.

Většina výrazů má jednu hodnotu. Volání funkcí a výraz vararg může mít libovolné číslo. Všimněte si, že zabalením volání funkce nebo výrazu vararg do závorek ztratíte všechny kromě první hodnoty.

{{Anchor|expression-list|exp-list}}
Seznamy výrazů jsou seznamy výrazů oddělených čárkami. Všechny kromě posledního výrazu jsou nuceny na jednu hodnotu (vypuštění dalších hodnot nebo použití nuly, pokud výraz nemá žádné hodnoty). Všechny hodnoty z posledního výrazu jsou zahrnuty do hodnot seznamu výrazů.

<span id="Arithmetic_operators"></span>
==== Aritmetické operátory ====

Lua podporuje obvyklé aritmetické operátory: sčítání, odčítání, násobení, dělení, modul, umocňování a negace.

Když jsou všechny operandy čísla nebo řetězce, pro které [[#tonumber|tonumber()]] vrací nenulovou hodnotu, mají operace svůj obvyklý význam.

Pokud je některým z operandů tabulka s vhodnou [[#Metatables|metamethodou]], bude zavolána metametoda.

{| class="wikitable" style="text-align:center"
|-
! Operátor !! Funkce !! Příklad !! Metametoda !! Poznámky
|-
| + || Addition || a + b || __add ||
|-
| - || Subtraction || a - b || __sub ||
|-
| * || Multiplication || a * b || __mul ||
|-
| / || Division || a / b || __div || dělení nulou není chyba; NaN nebo nekonečno bude vráceno
|-
| % || Modulo || a % b || __mod || definované jako <code style="white-space:nowrap">a % b == a - math.floor( a / b ) * b</code>
|-
| ^ || Exponentiation || a ^ b || __pow || jsou povoleny neceločíselné exponenty
|-
| - || Negation || -a || __unm ||
|}

<span id="Relational_operators"></span>
==== Relační operátory ====

Relační operátory v Lua jsou <code>==</code>, <code>~=</code>, <code><</code>, <code>></code>, <code><=</code> a <code>>=</code>. Výsledkem relačního operátoru je vždy logická hodnota.

Rovnost (<code>==</code>) nejprve porovná typy svých operandů. Pokud se liší, výsledek je nepravdivý. Poté porovná hodnoty: nula, boolean, číslo a řetězec jsou porovnány očekávaným způsobem. Funkce jsou stejné, pokud odkazují na přesně stejný funkční objekt. <code style="white-space:nowrap">function() end == function() end</code> vrátí false, protože porovnává dvě různé anonymní funkce. Tabulky jsou standardně porovnávány stejným způsobem, ale to lze změnit pomocí __eq [[#Metatables|metametody]].

Nerovnost (<code>~=</code>) je přesnou negací rovnosti.

Pro operátory řazení platí, že pokud jsou oba čísla nebo oba řetězce, jsou porovnány přímo. Dále se zkontrolují metametody:

* <code style="white-space:nowrap">a < b</code> používá <code>__lt</code>
* <code style="white-space:nowrap">a <= b</code> používá <code>__le</code>, pokud je k dispozici, nebo pokud je k dispozici <code>__lt</code>, považuje se za ekvivalentní na <code style="white-space:nowrap">not ( b < a )</code>
* <code style="white-space:nowrap">a > b</code> je považováno za ekvivalentní <code style="white-space:nowrap">b < a</code>
* <code style="white-space:nowrap">a >= b</code> je považováno za ekvivalentní <code style="white-space:nowrap">b <= a</code>

Pokud potřebné metametody nejsou k dispozici, dojde k chybě.

<span id="Logical_operators"></span>
==== Logické operátory ====

Logické operátory jsou <code>and</code>, <code>or</code> a <code>not</code>. Všechny používají standardní výklad, kde nula a nepravda jsou považovány za nepravdivé a cokoli jiného je považováno za pravdivé.

Pro <code>and</code>, pokud je levý operand považován za nepravdivý, pak je vrácen a druhý operand není vyhodnocen. Jinak je vrácen druhý operand.

Pro <code>or</code>, pokud je levý operand považován za pravdivý, pak je vrácen a druhý operand není vyhodnocen. Jinak je vrácen druhý operand.

Pro <code>not</code> je výsledek vždy pravdivý nebo nepravdivý.

Všimněte si, že <code>and</code> a <code>or</code> zkratují. Například <code style="white-space:nowrap">foo() or bar()</code> zavolá <code>bar()</code> pouze v případě, že <code>foo()</code> vrací false nebo nil jako svou první hodnotu.

<span id="Concatenation_operator"></span>
==== Operátor zřetězení ====

Operátor zřetězení jsou dvě tečky, používané jako <code style="white-space:nowrap">a .. b</code>. Pokud jsou oba operandy čísla nebo řetězce, jsou převedeny na řetězce a zřetězeny. Jinak, pokud je k dispozici __concat [[#Metatables|metamethod]], použije se. V opačném případě se objeví chyba.

Všimněte si, že řetězce Lua jsou neměnné a Lua neposkytuje žádný druh "tvůrce řetězců", takže smyčka, která opakovaně dělá <code style="white-space:nowrap">a = a .. b</code>, bude muset vytvořte nový řetězec pro každou iteraci a případně staré řetězce posbírat. Pokud mnoho řetězců potřebuje zřetězení, může být rychlejší použít [[#string.format|string.format()]] nebo vložit všechny řetězce do [[#sequence|sekvence]] a použít na konci [[#table.concat|table.concat()]].

<span id="Length_operator"></span>
==== Operátor délky ====

Operátor délky je <code>#</code>, používá se jako <code>#a</code>. Pokud je <code>a</code> řetězec, vrátí délku v bajtech. Pokud <code>a</code> je tabulka [[#sequence|sekvence]], vrátí délku sekvence.

Pokud <code>a</code> je tabulka, která ''není'' sekvencí, může <code>#a</code> vrátit 0 nebo jakoukoli hodnotu N, takže <code>a[N]</code> není nula a <code>a[N+1]</code> je nula, i když u vyšších indexů existují nenulové hodnoty. Například,

<syntaxhighlight lang="lua">
-- Toto není posloupnost, protože a[3] je nula a a[4] není.
a = { 1, 2, nil, 4 }

-- To může mít výstup 2 nebo 4.
-- A to se může změnit, i když se tabulka nezmění.
mw.log( #a )
</syntaxhighlight>
<span id="Operator_precedence"></span>
==== Přednost operátora ====

Priorita operátora Lua nebo [[w:order of operations|pořadí operací]], od nejvyšší po nejnižší:

# <code>^</code>
# <code>not</code> <code>#</code> <code>-</code> (negace)
# <code>*</code> <code>/</code> <code>%</code>
# <code>+</code> <code>-</code> (odčítání)
# <code>..</code>
# <code><</code> <code>></code> <code><=</code> <code>>=</code> <code>~=</code> <code>==</code>
# <code>and</code>
# <code>or</code>

V rámci úrovně priority je většina binárních operátorů asociativních vlevo, tj. <code style="white-space:nowrap">a / b / c</code> je interpretováno jako <code style="white-space:nowrap">(a / b) / c</code>. Umocňování a zřetězení jsou asociativní vpravo, tj. <code style="white-space:nowrap">a ^ b ^ c</code> se interpretuje jako <code style="white-space:nowrap">a ^ (b ^ c)</code>.

<span id="Function_calls"></span>
==== Volání funkcí ====

Volání funkcí Lua vypadá jako ve většině ostatních jazyků: Název následovaný seznamem argumentů v závorkách:

 func( [[#expression-list|''seznam-výrazů'']] )

Jak je obvyklé u seznamů výrazů v Lua, poslední výraz v seznamu může poskytnout více hodnot argumentů.

Pokud je funkce volána s menším počtem hodnot v seznamu výrazů, než je argumentů v definici funkce, budou mít další argumenty nulovou hodnotu. Pokud seznam výrazů obsahuje více hodnot, než je argumentů, nadbytečné hodnoty se zahodí. Je také možné, aby funkce přijala proměnný počet argumentů. Podrobnosti naleznete na stránce [[#Function declarations|Deklarace funkcí]].

Lua také umožňuje přímé volání návratové hodnoty funkce, tj. <code>func()()</code>. Pokud je k určení funkce, která má být volána, zapotřebí výraz složitější než proměnný přístup, lze místo proměnného přístupu použít výraz v závorkách.

Lua má syntaktický sugar pro dva běžné případy. První je, když je tabulka používána jako objekt a funkce má být volána jako metoda na objektu. Syntaxe

 table:name( [[#expression-list|''seznam-výrazů'']] )

je přesně ekvivalentní

 table.name( table, [[#expression-list|''seznam-výrazů'']] )

{{Anchor|named arguments}}
Druhým běžným případem je Luaova metoda implementace ''pojmenování argumentů'' předáním tabulky obsahující mapování jména na hodnotu jako jediného pozičního argumentu do funkce. V tomto případě mohou být závorky kolem seznamu argumentů vynechány. To také funguje, pokud má být funkci předán jeden doslovný řetězec. Například volání

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

jsou ekvivalentní s

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

Tyto mohou být kombinovány. Následující volání jsou ekvivalentní:

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

<span id="Function_declarations"></span>
==== Deklarace funkcí ====

Syntaxe deklarace funkce vypadá takto:

<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">''blok''</span>]]
 <span class="kr">end</span>
</div>

Všechny proměnné ve ''var-list'' (seznam proměnných) jsou pro funkci lokální, s hodnotami přiřazenými ze seznamu výrazů ve [[#Function calls|volání funkce]]. Uvnitř bloku mohou být deklarovány další lokální proměnné.

Když je funkce volána, příkazy v ''bloku'' jsou provedeny poté, co jsou vytvořeny lokální proměnné odpovídající ''var-listu'' a přiřazeny hodnoty. Pokud je dosaženo [[#return|příkazu return]], blok se opustí a hodnoty výrazu volání funkce jsou hodnoty dané příkazem return. Pokud provádění dosáhne konce bloku funkce, aniž by narazilo na příkaz return, bude mít výsledek výrazu volání funkce nulové hodnoty.

Funkce Lua jsou [[w:Closure (computer science)|lexikální uzávěry]]. Běžným idiomem je deklarovat "soukromé statické" proměnné jako místní v rozsahu, kde je funkce deklarována. Například,

<syntaxhighlight lang="lua">
-- To vrátí funkci, která ke svému argumentu přidá číslo
function makeAdder( n )
    return function( x )
        -- Proměnná n z vnějšího rozsahu je zde k dispozici pro přidání k x
        return x + n
    end
end

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

{{Anchor|varargs}}
Funkce může být deklarována tak, aby přijímala proměnný počet argumentů, zadáním <code>...</code> jako poslední položku ve ''var-listu'':

<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">''blok''</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">''blok''</span>]]
 <span class="kr">end</span>
</div>

V rámci bloku lze použít varargs výraz <code>...</code>, jehož výsledkem jsou všechny hodnoty navíc ve volání funkce. Například,

<syntaxhighlight lang="lua">
local join = function ( separator, ... )
    -- získat další argumenty jako novou tabulku
    local args = { ... }
    -- získat počet argumentů navíc, správně
    local n = select( '#', ... )
    return table.concat( args, separator, 1, n )
end

join( ', ', 'foo', 'bar', 'baz' )
-- vrátí řetězec "foo, bar, baz"
</syntaxhighlight>

Funkce [[#select|select()]] je navržena pro práci s výrazem varargs. Konkrétně by měl být použit <code style="white-space:nowrap">select( '#', ... )</code> namísto <code style="white-space:nowrap">#{ ... }</code>, abyste spočítali počet hodnot ve výrazu varargs, protože <code style="white-space:nowrap">{ ... }</code> nemusí být [[#sequence|sekvence] ].

Lua poskytuje syntaktický sugar pro kombinaci deklarace funkce a přiřazení k proměnné. Podrobnosti najdete na stránce [[#Function declaration statements|Prohlášení deklarace funkce]].

Všimněte si, že to nebude fungovat:

<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>

Protože deklarace funkce je zpracována před dokončením příkazu přiřazení lokální proměnné, "faktoriální" uvnitř těla funkce odkazuje na (pravděpodobně nedefinovanou) proměnnou tohoto jména ve vnějším rozsahu. Tomuto problému se lze vyhnout tak, že nejprve deklarujete lokální proměnnou a poté ji přiřadíte v následujícím příkazu, nebo použijete syntaxi [[#Function declaration statements|deklarace funkce]].

<span id="Statements"></span>
=== Výroky ===

''Příkaz'' je základní jednotkou provádění: jedno přiřazení, řídicí struktura, volání funkce, deklarace proměnné atd.

{{Anchor|chunk}}
''Chunk'' (kus) je posloupnost příkazů, volitelně oddělená středníky. Blok je v podstatě považován za tělo anonymní funkce, takže může deklarovat lokální proměnné, přijímat argumenty a vracet hodnoty.

{{Anchor|block}}
''Blok'' je také posloupnost příkazů, stejně jako kus. Blok lze oddělit a vytvořit tak jeden příkaz: {{tmpl|0=<code style="white-space:nowrap">do ''$1'' end</code>|block}}. Ty lze použít k omezení rozsahu lokálních proměnných nebo k přidání <code>return</code> nebo <code>break</code> uprostřed jiného bloku.

<span id="Assignments"></span>
==== Zadání ====
<code style="white-space:nowrap">''seznam-proměnných'' = [[#expression-list|''seznam-výrazů'']]</code>

''variable-list'' je seznam proměnných oddělených čárkami. ''expression-list'' je čárkami oddělený seznam jednoho nebo více výrazů. Všechny výrazy jsou vyhodnoceny před provedením jakéhokoli přiřazení, takže <code style="white-space:nowrap">a, b = b, a</code> zamění hodnoty <var>a</var> a <var >b</var>.

<span id="Local_variable_declarations"></span>
==== Deklarace lokálních proměnných ====
<code style="white-space:nowrap">local ''seznam-proměnných''</code>

<code style="white-space:nowrap">local ''seznam-proměnných'' = [[#expression-list|''seznam-výrazů'']]</code>

Lokální proměnné mohou být deklarovány kdekoli v [[#block|bloku]] nebo [[#block|kusu]]. První formulář bez seznamu výrazů deklaruje proměnné, ale nepřiřazuje hodnotu, takže všechny proměnné mají hodnotu nula. Druhý formulář přiřazuje hodnoty lokálním proměnným, jak je popsáno v [[#Assignments|Úkolech]] výše.

Všimněte si, že viditelnost lokální proměnné začíná příkazem po deklaraci lokální proměnné. Takže deklarace jako <code style="white-space:nowrap">local x = x</code> deklaruje lokální proměnnou x a přiřadí jí hodnotu x z vnějšího rozsahu. Lokální proměnná zůstává v rozsahu až do konce nejvnitřnějšího bloku obsahujícího deklaraci lokální proměnné.

<span id="Control_structures"></span>
==== Struktury kontroly ====
{{Anchor|while}}
<code style="white-space:nowrap">while ''výraz'' do ''[[#block|blok]]'' end</code>

Příkaz while opakuje blok, dokud je výraz vyhodnocen jako pravdivá hodnota.

{{Anchor|repeat}}
<code style="white-space:nowrap">repeat ''[[#block|blok]]'' until ''výraz''</code>

Příkaz repeat opakuje blok, dokud se výraz nevyhodnotí jako pravdivá hodnota. Ve výrazu lze přistupovat k lokálním proměnným deklarovaným uvnitř bloku.

{{Anchor|for}}
<code style="white-space:nowrap">for ''name'' = ''exp1'', ''exp2'', ''exp3'' do ''[[#block|blok]]'' end</code><br/>
<code style="white-space:nowrap">for ''name'' = ''exp1'', ''exp2'' do ''[[#block|blok]]'' end</code>

Tato první forma cyklu for deklaruje lokální proměnnou a opakuje blok pro hodnoty od ''exp1'' do ''exp2'' přidáním ''exp3'' při každé iteraci. Všimněte si, že ''exp3'' může být úplně vynecháno, v takovém případě se použije 1, ale nečíselné hodnoty jako <code>nil</code> a <code>false</code> jsou chybou. Všechny výrazy jsou vyhodnoceny jednou před spuštěním cyklu.

Tato forma cyklu for je zhruba ekvivalentní
<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>

kromě toho, že proměnné var, limit a step nejsou dostupné nikde jinde. Všimněte si, že proměnná ''name'' je pro daný blok lokální. Chcete-li použít hodnotu za smyčkou, musí být zkopírována do proměnné deklarované mimo smyčku.

{{Anchor|iterators}}
<code style="white-space:nowrap">for ''seznam-proměnných'' in [[#expression-list|''seznam-výrazů'']] do ''[[#block|blok]]'' end</code>

Druhá forma cyklu for pracuje s funkcemi ''iterátor''. Stejně jako v prvním formuláři je ''seznam-výrazů'' vyhodnocen pouze jednou před začátkem cyklu.

Tato forma cyklu for je zhruba ekvivalentní
<syntaxhighlight lang="lua">
do
    local func, static, var = expression-list
    while true do
        local var-list = func( static, var )
        var = var1  -- ''var1'' je první proměnná v ''seznamu-proměnných''
        if var == nil then
            break
        end
        block
    end
end
</syntaxhighlight>

kromě toho, že opět proměnné func, static a var nejsou dostupné nikde jinde. Všimněte si, že proměnné v ''var-list'' jsou pro daný blok lokální; chcete-li je použít po cyklu, musí být zkopírovány do proměnných deklarovaných mimo cyklus.

''Seznam výrazů'' je často volání jediné funkce, která vrací tři hodnoty. Pokud lze funkci iterátoru zapsat tak, že závisí pouze na parametrech, které jsou do ní předány, bylo by to nejúčinnější. Pokud ne, [https://www.lua.org/pil/7.4.html programování v Lua] navrhuje, aby se upřednostňovalo uzavření před vrácením tabulky jako statické proměnné a aktualizací jejích členů při každé iteraci.

{{Anchor|if}}
<code style="white-space:nowrap">if ''exp1'' then ''[[#block|block1]]'' elseif ''exp2'' then ''[[#block|block2]]'' else ''[[#block|block3]]'' end</code>

Provede ''block1'', pokud ''exp1'' vrátí true, jinak provede ''block2'', pokud ''exp2'' vrátí true, a ''block3'' jinak. Část <code style="white-space:nowrap">else ''block3''</code> může být vynechána a část <code style="white-space:nowrap">elseif ''exp2'' then ''block2''</code> může být podle potřeby opakována nebo vynechána.

{{Anchor|return}}
<code style="white-space:nowrap">return [[#expression-list|''seznam-výrazů'']]</code>

Příkaz return se používá k vrácení hodnot z funkce nebo [[#chunk|chunk]] (což je pouze funkce). ''Seznam-výrazů'' je čárkami oddělený seznam nula nebo více výrazů.

Lua implementuje [[w:tail call|volání tail]]: Pokud ''výraz-seznam'' obsahuje přesně jeden výraz, který je voláním funkce, bude pro volání této funkce znovu použit aktuální zásobníkový rámec. To má důsledky pro funkce, které se zabývají zásobníkem volání, jako je <code>[[#getfenv|getfenv()]]</code> a <code>[[#debug.traceback|debug.traceback()]]</code>.

Příkaz return musí být posledním příkazem v jeho [[#block|bloku]]. Pokud je z nějakého důvodu potřeba návrat uprostřed bloku, lze použít explicitní blok <code style="white-space:nowrap">do return end</code>.

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

Příkaz break se používá k ukončení provádění cyklu while, repeat nebo for, přičemž se přeskočí na další příkaz následující po cyklu.

Příkaz break musí být posledním příkazem v jeho [[#block|bloku]]. Pokud je z nějakého důvodu potřeba přerušení uprostřed bloku, lze použít explicitní blok <code style="white-space:nowrap">do break end</code>.

Na rozdíl od některých jiných jazyků nemá Lua pro cykly příkaz "continue" (tj. příkaz pro přechod na další iteraci bez úplného přerušení smyčky).
Je přímočaré dosáhnout stejného efektu vnořením bloku <code style="white-space:nowrap">repeat ... until true</code> přímo do hlavní smyčky, která se bude opakovat pouze jednou pro každou iteraci hlavní smyčky (jelikož podmínka je vždy pravdivá).
Použití <code style="white-space:nowrap">break</code> pouze ukončí vnitřní smyčku, což má praktický účinek, že hlavní smyčka bude pokračovat v další iteraci.
Pokud je nutné použít <code style="white-space:nowrap">break</code> v hlavní smyčce, jednoduše deklarujte proměnnou, která je kontrolována pokaždé, když se vnitřní smyčka dokončí, a v případě potřeby ji nastavte.

<span id="Function_calls_as_statements"></span>
==== Volání funkcí jako příkazů ====

Volání funkce lze použít jako příkaz. V tomto případě je funkce volána pouze pro jakékoli vedlejší účinky, které může mít (např. [[#mw.log|mw.log()]] protokoluje hodnoty) a všechny návratové hodnoty jsou zahozeny.

<span id="Function_declaration_statements"></span>
==== Příkazy deklarace funkce ====

Lua poskytuje syntaktický sugar, aby bylo deklarování funkce a její přiřazení k proměnné přirozenější. Následující dvojice deklarací jsou ekvivalentní

 -- Základní prohlášení
 function func( ''var-list'' ) ''[[#block|blok]]'' end
 func = function ( ''var-list'' ) ''[[#block|blok]]'' end

 -- Lokální funkce
 local function func( ''var-list'' ) ''[[#block|blok]]'' end
 local func; func = function ( ''var-list'' ) ''[[#block|blok]]'' end

 -- Funkce jako pole v tabulce
 function table.func( ''var-list'' ) ''[[#block|blok]]'' end
 table.func = function ( ''var-list'' ) ''[[#block|blok]]'' end

 -- Funkce jako metoda v tabulce
 function table:func( ''var-list'' ) ''[[#block|blok]]'' end
 table.func = function ( self, ''var-list'' ) ''[[#block|blok]]'' end

Všimněte si, že zápis dvojtečkou zde odpovídá zápisu dvojtečky pro [[#Function calls|volání funkcí]] a na začátek seznamu argumentů přidává implicitní argument s názvem <code>self</code>.

<span id="Error_handling"></span>
=== Zpracování chyb ===

Chyby lze "vyvolat" pomocí funkcí [[#error|error()]] a [[#assert|assert()]]. Chcete-li "zachytit" chyby, použijte [[#pcall|pcall()]] nebo [[#xpcall|xpcall()]]. Všimněte si, že určité interní chyby Scriunto nelze zachytit v kódu Lua.

=== Garbage collection ===

Lua provádí automatickou správu paměti. To znamená, že se nemusíte starat ani o alokaci paměti pro nové objekty, ani o její uvolnění, když již objekty nejsou potřeba. Lua spravuje paměť automaticky tak, že čas od času spustí ''garbage collector'', aby shromáždil všechny mrtvé objekty (tj. objekty, které již nejsou dostupné z Lua) a objekty, které jsou dosažitelné pouze prostřednictvím [[#weak tables|slabých referencí]]. Veškerá paměť používaná Lua podléhá automatické správě: tabulky, funkce, řetězce atd.

Garbage collection (sběr odpadu) probíhá automaticky a nelze jej konfigurovat ze Scriunta.

<span id="Standard_libraries"></span>
== Standardní knihovny ==

Standardní knihovny Lua poskytují Lua základní služby a funkce kritické pro výkon. Zde jsou zdokumentovány pouze ty části standardních knihoven, které jsou dostupné ve Scriuntu.

<span id="Basic_functions"></span>
=== Základní funkce ===

==== _G ====
<span id="_G"></span><!-- Don't use {{anchor}}, it strips the underscore -->

Tato proměnná obsahuje odkaz na aktuální tabulku globálních proměnných. Ke globální proměnné <code>foo</code> lze také přistupovat jako <code>_G.foo</code>. Všimněte si však, že na samotných _G není nic zvláštního. Může být znovu přiřazena stejným způsobem jako jakákoli jiná proměnná:

<syntaxhighlight lang="lua">
foo = 1
mw.log( foo ) -- logy "1"
_G.foo = 2
mw.log( foo ) -- logy "2"
_G = {}       -- _G již neukazuje na tabulku globálních proměnných
_G.foo = 3
mw.log( foo ) -- přetrvávající logy "2"
</syntaxhighlight>

Tabulku globálních proměnných lze použít stejně jako jakoukoli jinou tabulku. Například,

<syntaxhighlight lang="lua">
-- Volání funkce, jejíž název je uložen v proměnné
_G[var]()

-- Protokolujte názvy a zřetězené hodnoty všech globálních proměnných
for k, v in pairs( _G ) do
   mw.log( k, v )
end

-- Zaznamenejte vytvoření nových globálních proměnných
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><!-- Don't use {{anchor}}, it strips the underscore -->

Řetězec obsahující běžící verzi Lua, např. "Lua 5.1".

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

Pokud je <code>v</code> nula nebo nepravda, vydá chybu. V tomto případě se jako text chyby použije <code>message</code>: pokud je nula (nebo není zadáno), text je "tvrzení se nezdařilo!". Pokud je řetězec nebo číslo, text je tato hodnota. Jinak samo tvrzení vyvolá chybu.

Pokud je <code>v</code> jakákoliv jiná hodnota, tvrzení vrátí všechny argumenty včetně <code>v</code> a <code>message</code>.

Poněkud běžný idiom v Lua je, že funkce v normálním provozu vrátí hodnotu "true" a při selhání vrátí nulu nebo nepravdu jako první hodnotu a chybovou zprávu jako druhou hodnotu. Snadnou kontrolu chyb lze poté implementovat zabalením hovoru do volání <code>assert</code>:

<syntaxhighlight lang="lua">
-- Toto nekontroluje chyby
local result1, result2, etc = func( ... )

-- Funguje to stejně, ale kontroluje chyby
local result1, result2, etc = assert( func( ... ) )
</syntaxhighlight>

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

Vydá chybu s textem <code>message</code>.

<code>error</code> obvykle přidává nějaké informace o umístění chyby. Pokud <code>level</code> je 1 nebo je vynechán, je tato informace místem samotného volání <code>error</code>. 2 používá umístění volání funkce, která volala chybu. A tak dále. Předání 0 vynechá zahrnutí informací o poloze.

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

Upozorňujeme, že tato funkce nemusí být dostupná v závislosti na <code>allowEnvFuncs</code> v konfiguraci motoru.

Vrátí ''prostředí'' (globální tabulku proměnných), jak je specifikováno <code>f</code>:

* Pokud je 1, nula nebo je vynecháno, vrátí prostředí funkce volající <code>getfenv</code>. Často to bude stejné jako [[#_G|_G]].
* Celá čísla 2–10 vrátí prostředí funkcí výše v zásobníku volání. Například 2 vrátí prostředí pro funkci, která volala aktuální funkci, 3 vrátí prostředí pro funkci volající tuto funkci a tak dále. Pokud je hodnota vyšší než počet volání funkcí v zásobníku nebo pokud se cílová úroveň zásobníku vrátí s voláním konce, dojde k chybě.
* Předání funkce vrátí prostředí, které bude použito při volání této funkce.

Prostředí používaná všemi standardními knihovními funkcemi a funkcemi knihovny Scriunto jsou chráněna. Pokus o přístup do těchto prostředí pomocí <code>getfenv</code> vrátí nulu.

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

Vrátí [[#Metatables|metatable]] [[#table|tabulky]]. Jakýkoli jiný typ vrátí nulu.

Pokud má metatabulka pole <code>__metatable</code>, bude vrácena tato hodnota namísto skutečné metatabulky.

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

Vrátí tři hodnoty: funkci iterátoru, tabulku <code>t</code> a 0. Toto je určeno pro použití ve tvaru [[#iterators|iterator <code>for</code>]]:

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

Toto bude iterovat přes dvojice ( 1, t[1] ), ( 2, t[2] ) atd., přičemž se zastaví, když t[i] bude nulové.

Standardní chování může být potlačeno poskytnutím <code>__ipairs</code> [[#Metatables|metametody]]. Pokud tato metametoda existuje, volání ipairs místo toho vrátí tři hodnoty vrácené <code style="white-space:nowrap">__ipairs( t )</code>.

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

To umožňuje iteraci přes klíče v tabulce. Pokud je <code>key</code> nula nebo není specifikováno, vrátí "první" klíč v tabulce a jeho hodnotu; jinak vrátí klíč "další" a jeho hodnotu. Pokud nejsou k dispozici žádné další klíče, vrátí hodnotu nula. Zda je tabulka prázdná, je možné zkontrolovat pomocí výrazu <code style="white-space:nowrap">next( t ) == nil</code>.

Všimněte si, že pořadí, ve kterém jsou klíče vráceny, není určeno, a to ani pro tabulky s číselnými indexy. Chcete-li procházet tabulkou v číselném pořadí, použijte [[#for|numerical for]] nebo [[#ipairs|ipairs]].

Chování je nedefinované, pokud je při použití next pro procházení přiřazena hodnota jakémukoli neexistujícímu klíči. Přiřazení nové hodnoty (včetně nuly) existujícímu poli je povoleno.

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

Vrátí tři hodnoty: funkci iterátoru ([[#next|next]] nebo podobnou práci), tabulku <code>t</code> a nulu. Toto je určeno pro použití ve [[#iterators|iterátorové formě <code>for</code>]]:

<syntaxhighlight lang="lua">
for k, v in pairs( t ) do
    -- zpracovat každý pár klíč–hodnota
end
</syntaxhighlight>

To bude opakovat páry klíč-hodnota v <code>t</code> stejně jako [[#next|next]]. V dokumentaci k [[#next|next]] naleznete omezení týkající se úprav tabulky během procházení.

Standardní chování může být potlačeno poskytnutím __pairs [[#Metatables|metametoda]]. Pokud tato metametoda existuje, volání párů místo toho vrátí tři hodnoty vrácené <code style="white-space:nowrap">__pairs( t )</code>.

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

Volá funkci <code>f</code> s danými argumenty v ''chráněném režimu''. To znamená, že pokud se během volání na <code>f</code> objeví chyba, pcall vrátí false a vyvolá se chybová zpráva. Pokud nedojde k žádné chybě, pcall vrátí true a všechny hodnoty vrácené voláním.

V [[:en:pseudocode|pseudokódu]] může být <code>pcall</code> definován nějak takto:

<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>

To je ekvivalent <code style="white-space:nowrap">a == b</code> kromě toho, že ignoruje jakoukoli __eq [[#Metatables|metametodu]].

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

To je ekvivalent <code>table[k]</code> kromě toho, že ignoruje jakoukoli __index [[#Metatables|metametodu]].

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

To je ekvivalent <code style="white-space:nowrap">table[k] = v</code> kromě toho, že ignoruje jakoukoli __newindex [[#Metatables|metametodU]].

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

Pokud je <code>index</code> číslo, vrátí všechny argumenty v <code>...</code> od tohoto indexu dále.
Pokud je <code>index</code> řetězec {{luai|"#"}}, vrátí počet argumentů v <code>...</code>.

Poznámka: Na rozdíl od tabulek seznamy argumentů (včetně [[#varargs|výrazu vararg]] <code>...</code>) považují {{luai|nil}} za odlišnou hodnotu (viz dokumentace k [[#Length operator|#]] a [[#unpack |unpack]] pro problém s {{luai|nil}} v tabulkách). Například:
* {{luai|select(2, "foo", "bar")}} vrátí {{luai|"bar"}}.
* {{luai|select(2, "foo", nil, "bar", nil)}} vrátí {{luai|nil, "bar", nil}}.
* {{luai|select("#", "foo", "bar")}} vrátí {{luai|2}}.
* {{luai|select("#", "foo", "bar", nil)}} vrátí {{luai|3}}.

Jinými slovy, <code>select</code> je zhruba jako následující (kromě toho, že také zpracovává všechny {{luai|nil}} argumenty po posledním nenulovém argumentu):

<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>

Nastavuje z [[#table|tabulky]] [[#Metatables|metatabulku]]. <code>metatable</code> může být nula, ale musí být výslovně uvedeno.

Pokud má aktuální metatabulka pole __metatable, <code>setmetatable</code> vyvolá chybu.

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

Pokusí se převést <code>value</code> na číslo. Pokud se již jedná o číslo nebo řetězec převoditelný na číslo, pak <code>tonumber</code> toto číslo vrátí; jinak vrátí nulu.

Volitelné <code>base</code> (výchozí 10) určuje základ pro interpretaci čísla. Základem může být jakékoli celé číslo mezi 2 a 36 včetně. V základech nad 10 představuje písmeno "A" (buď velké nebo malé) 10, "B" představuje 11 a tak dále, přičemž "Z" představuje 35.

V základu 10 může mít hodnota desetinnou část, může být vyjádřena v [[:en:E notation|E zápisu]] a může mít na začátku "0x" pro označení základu 16. V jiných základech jsou akceptována pouze celá čísla bez znaménka.

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

Převede <code>value</code> na řetězec. Podrobnosti o převodu jednotlivých typů viz [[#Data types|Datové typy]] výše.

Standardní chování tabulek může být potlačeno poskytnutím __tostring [[#Metatables|metametody]]. Pokud tato metametoda existuje, volání tostring místo toho vrátí jedinou hodnotu vrácenou <code style="white-space:nowrap">__tostring( value )</code>.

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

Vrátí typ <code>value</code> jako řetězec: <code>"[[#nil|nil]]"</code>, <code>"[[#number|number]]"</code>, <code>"[[#string|string]]"</code>, <code>"[[#boolean|boolean]]"</code>, <code>"[[#table|table]]"</code> nebo <code>"[[#function|function]]"</code>.

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

Vrátí hodnoty z dané tabulky, něco jako <code style="white-space:nowrap">table[i], table[i+1], ···, table[j]</code> by udělalo, pokud by bylo zapsáno ručně. Pokud je nula nebo není zadáno, <code>i</code> výchozí hodnota 1 a <code>j</code> výchozí <code style="white-space:nowrap">[[#Length operator|#]]table</code>.

Pokud tabulka nemá hodnotu pro konkrétní klíč, rozbalení vrátí pro tuto hodnotu nulu. Například {{luai|1=unpack({"foo", [3] = "bar"}, 1, 4)}} vrátí {{luai|"foo", nil, "bar", nil}}.

Všimněte si, že výsledky nejsou deterministické, pokud <code>table</code> není [[#sequence|sekvence]] a <code>j</code> je nula nebo není specifikováno.Podrobnosti viz [[#Length operator|Operátor délky]].

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

Je to podobné jako <code>[[#pcall|pcall]]</code>, s tím rozdílem, že chybová zpráva je před jejím vrácením předána funkci <code>errhandler</code>.

V [[w:pseudocode|pseudokódu]] může být <code>xpcall</code> definován nějak takto:

<syntaxhighlight lang="lua">
function xpcall( f, errhandler )
    try
        return true, f()
    catch ( message )
        message = errhandler( message )
        return false, message
    end
end
</syntaxhighlight>
<span id="Debug_library"></span>
=== Knihovna ladění ===

==== debug.traceback ====
<code style="white-space:nowrap">debug.traceback (zpráva, úroveň)</code>

Vrátí řetězec se zpětným sledováním zásobníku volání. Na začátek zpětného sledování je připojen volitelný řetězec zprávy. Volitelné číslo úrovně říká, na které úrovni zásobníku se má zahájit sledování.

<span id="Math_library"></span>
=== Matematická knihovna ===

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

Vrátí absolutní hodnotu <code>x</code>.

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

Vrátí arc cosinus <code>x</code> (zadaný v radiánech).

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

Vrátí úhlový sinus <code>x</code> (zadaný v radiánech).

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

Vrátí arkus tangens <code>x</code> (zadaný v radiánech).

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

Vrátí arkus tangens <code>y/x</code> (zadaný v radiánech) pomocí znamének obou parametrů k nalezení kvadrantu výsledku.

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

Vrátí nejmenší celé číslo větší nebo rovné <code>x</code>.

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

Vrátí kosinus <code>x</code> (zadaný v radiánech).

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

Vrátí hyperbolický kosinus <code>x</code>.

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

Vrátí úhel <code>x</code> (zadaný v radiánech) ve stupních.

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

Vrátí hodnotu <math>e^x</math>.

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

Vrátí největší celé číslo menší nebo rovné <code>x</code>.

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

Vrátí zbytek dělení <code>x</code> ku <code>y</code>, který zaokrouhlí podíl směrem k nule. Například <code>math.fmod( 10, 3 )</code> vychází <code>1</code>.

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

Vrátí dvě hodnoty <code>m</code> a <code>e</code> takové, že:

* Pokud je <code>x</code> konečný a nenulový: <math>x = m \times 2^e</math>, <code>e</code> je celé číslo a absolutní hodnota <code>m</code> je v rozsahu <math>[0.5, 1)</math>
* Pokud je <code>x</code> nula: <code>m</code> a <code>e</code> jsou 0
* Pokud je <code>x</code> NaN (Not a Number ("nečíslo")) nebo nekonečno: <code>m</code> je <code>x</code> a <code>e</code> není specifikováno
==== math.huge ====
Hodnota představující kladné nekonečno. Větší nebo rovno jakékoli jiné číselné hodnotě.

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

Vrátí <math>m \times 2^e</math> (<code>e</code> by mělo být celé číslo).

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

Vrátí přirozený logaritmus <code>x</code>.

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

Vrátí základní-10 logaritmus <code>x</code>.

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

Vrátí maximální hodnotu mezi svými argumenty.

Chování s NaN není specifikováno. S aktuální implementací bude NaN vráceno, pokud <code>x</code> je NaN, ale všechny ostatní NaN budou ignorovány.

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

Vrátí minimální hodnotu mezi svými argumenty.

Chování s NaN není specifikováno. S aktuální implementací bude NaN vráceno, pokud <code>x</code> je NaN, ale všechny ostatní NaN budou ignorovány.

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

Vrátí dvě čísla, integrální část <code>x</code> a zlomkovou část <code>x</code>. Například <code>math.modf( 1.25 )</code> zobrazí <code>1, 0.25</code>.

==== math.pi ====
Hodnota <math>\pi</math>.

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

Ekvivalent <code>x^y</code>.

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

Vrátí úhel <code>x</code> (zadaný ve stupních) v radiánech.

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

Vrátí pseudonáhodné číslo.

Argumenty <code>m</code> a <code>n</code> mohou být vynechány, ale pokud jsou uvedeny, musí být převoditelné na celá čísla.

* Bez argumentů vrátí skutečné číslo v rozsahu <math>[0,1)</math>
* S jedním argumentem vrátí celé číslo v rozsahu <math>[1,m]</math>
* Se dvěma argumenty vrátí celé číslo v rozsahu <math>[m,n]</math>

Všimněte si, že nesprávný výstup může vzniknout, pokud je <code>m</code> nebo <code>n</code> menší než −2147483648 nebo větší než 2147483647 nebo pokud je <code>n - m</code> větší než 2147483646.

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

Nastaví <code>x</code> jako [[w:Random seed|jádro]] pro pseudonáhodný generátor.

Všimněte si, že použití stejného semena způsobí, že <code>math.random</code> vypíše stejnou sekvenci čísel.

<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>

Vrátí sinus <code>x</code> (zadaný v radiánech).

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

Vrátí hyperbolický sinus <code>x</code>.

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

Vrátí druhou odmocninu z <code>x</code>. Ekvivalent <code>x^0.5</code>.

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

Vrátí tangens <code>x</code> (zadaný v radiánech).

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

Vrátí hyperbolický tangens <code>x</code>.

<span id="Operating_system_library"></span>
=== Knihovna operačního systému ===

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

Vrátí přibližnou hodnotu v sekundách času procesoru použitého programem.

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

: ''[[#mw.language:formatDate|Formát jazykové knihovny]] lze použít pro komplexnější formátování data''

Vrátí řetězec nebo tabulku obsahující datum a čas ve formátu <code>format</code>. Pokud je formát vynechán nebo je nulový, použije se "%c".

Pokud je zadáno <code>time</code>, je to čas, který má být formátován (viz <code>[[#os.time|os.time()]]</code>). Jinak se použije aktuální čas.

Pokud <code>format</code> začíná znakem '!', pak je datum formátováno v UTC, nikoli v místním čase serveru. Za tímto volitelným znakem, pokud je formátem řetězec "*t", pak datum vrátí tabulku s následujícími poli:

* year (rok) (full)
* month (měsíc) (1–12)
* day (den) (1–31)
* hour (hodina) (0–23)
* min (0–59)
* sec (0–60, umožní [[:en:leap second|přestupné sekundy]])
* wday (všední den, neděle je 1)
* yday (den v roce)
* isdst (příznak letního času, boolean; může chybět, pokud informace nejsou k dispozici)

Pokud formát není "*t", pak datum vrátí datum jako řetězec, naformátovaný podle stejných pravidel jako funkce C [http://man7.org/linux/man-pages/man3/strftime.3.html strftime].

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

Vrátí počet sekund od <code>t1</code> do <code>t2</code>.

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

Vrátí číslo představující aktuální [[w:Unix time|unixový čas]].

Při volání bez argumentů vrátí aktuální čas. Pokud projde tabulkou, bude analyzován čas zakódovaný v tabulce. Tabulka musí obsahovat pole "rok", "měsíc" a "den" a může také obsahovat "hodinu" (výchozí 12), "min" (výchozí 0), "sec" (výchozí 0) a "isdst".

<span id="Package_library"></span>
=== Knihovna balíčků ===

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

Načte zadaný modul.

Nejprve se podívá do <code>package.loaded[modulename]</code>, aby zjistil, zda je modul již načten. Pokud ano, vrátí <code>package.loaded[modulename]</code>.

Jinak volá každý zavaděč v sekvenci <code>package.loaders</code>, aby se pokusil najít zavaděč pro modul. Pokud je nalezen zavaděč, zavolá se tento zavaděč. Hodnota vrácená zavaděčem se uloží do <code>package.loaded[modulename]</code> a vrátí se.

Informace o dostupných zavaděčích naleznete v dokumentaci pro <code>[[#package.loaders|package.loaders]]</code>.

Pokud máte například modul "Module:Giving" obsahující následující:

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

p.someDataValue = 'Ahoj!'

return p
</syntaxhighlight>

Můžete to načíst do jiného modulu s kódem, jako je tento:

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

local value = giving.someDataValue -- hodnota je nyní 'Ahoj!'
</syntaxhighlight>

==== package.loaded ====
Tato tabulka obsahuje načtené moduly. Klíče jsou názvy modulů a hodnoty jsou hodnoty vrácené při načtení modulu.
==== package.loaders ====
Tato tabulka obsahuje posloupnost vyhledávacích funkcí, které se mají použít při načítání modulů. Každá vyhledávací funkce je volána s jediným argumentem, názvem modulu, který se má načíst. Pokud je modul nalezen, hledač musí vrátit funkci, která modul skutečně načte a vrátí hodnotu, kterou má vrátit [[#require|požadavek]]. V opačném případě musí vrátit nulu.

Scribunto nabízí dva vyhledávače:

# V <code>package.preload[modulename]</code> vyhledejte funkci loader
# Hledejte v [[#Loadable libraries|modulech poskytovaných se Scribuntem]] název modulu, a pokud to selže, hledejte ve jmenném prostoru Module:. Musí být zadána předpona "Module:".

Všimněte si, že standardní zavaděče Lua '''nejsou''' součástí dodávky.
==== package.preload ====
Tato tabulka obsahuje funkce zavaděče, které používá první vyhledávač, který Scriunto obsahuje v [[#package.loaders|package.loaders]].

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

Nastaví __index [[#Metatables|metody Meta]] pro <code>table</code> na [[#_G|_G]].

<span id="String_library"></span>
=== Knihovna řetězců ===

Ve všech řetězcových funkcích je první znak na pozici&nbsp;1, nikoli na pozici&nbsp;0 jako v C, PHP a JavaScript. Indexy mohou být záporné, v takovém případě se počítají od konce řetězce: pozice&nbsp;-1 je poslední znak v řetězci, -2 je předposlední atd.

{{red|Upozornění:}} Knihovna řetězců předpokládá jednobajtové kódování znaků. '''Nedokáže zpracovat znaky Unicode'''. Chcete-li pracovat s řetězci Unicode, použijte odpovídající metody v knihovně [[#Ustring library|Scribunto Ustring]].

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

Pokud je řetězec považován za pole bajtů, vrátí hodnoty bajtů pro <code>s[i]</code>, <code>s[i+1]</code>, ···, <code>s[j]</code>.
Výchozí hodnota <code>i</code> je&nbsp;1;
výchozí hodnota pro <code>j</code> je&nbsp;<code>i</code>.
Stejné jako [[#mw.ustring.byte|mw.ustring.byte()]].

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

Přijímá nulu nebo více celých čísel. Vrátí řetězec s délkou rovnou počtu argumentů, ve kterém má každý znak hodnotu bajtu rovnou jeho odpovídajícímu argumentu.

<syntaxhighlight lang="lua">
local value = string.char( 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21 ) --hodnota je nyní 'Ahoj!'
</syntaxhighlight>

Viz [[#mw.ustring.char|mw.ustring.char()]] pro podobnou funkci, která používá kódové body Unicode spíše než bajtové hodnoty.

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

Vyhledá první shodu <code>[[#Patterns|pattern]]</code> v řetězci <code>s</code>. Pokud najde shodu, pak <code>find</code> vrátí offsety v&nbsp;<code>s</code>, kde tento výskyt začíná a končí. Jinak vrátí nulu. Pokud má vzor záchyty, pak jsou při úspěšné shodě zachycené hodnoty také vráceny po dvou indexech.

Třetí, volitelný číselný argument <code>init</code> určuje, kde má začít hledání. Jeho výchozí hodnota je&nbsp;1 a může být záporná. Hodnota true jako čtvrtý, volitelný argument <code>plain</code> vypne funkce porovnávání vzorů, takže funkce provede jednoduchou operaci "najít podřetězec", přičemž v <code>pattern</code> nejsou žádné znaky považovány za "kouzelné".

Všimněte si, že pokud je zadáno <code>plain</code>, musí být zadáno také <code>init</code>.

Viz [[#mw.ustring.find|mw.ustring.find()]], kde najdete podobnou funkci rozšířenou, jak je popsáno ve [[#Ustring patterns|vzorech Ustring]] a kde offset <code>init</code> je ve znacích, nikoli v bajtech.

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

Vrátí formátovanou verzi svého proměnného počtu argumentů po popisu uvedeném v prvním argumentu (což musí být řetězec).

Formátovací řetězec používá omezenou podmnožinu [http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html <code>printf</code> specifikátorů formátu]:

* Rozpoznané příznaky jsou <code>'-', '+', ' ', '#',</code> a <code>'0'</code>.
* Jsou podporovány celočíselné šířky pole až 99. <code>'*'</code> není podporováno.
* Podporovány jsou přesnosti celých čísel až 99. <code>'*'</code> není podporováno.
* Modifikátory délky nejsou podporovány.
* Uznávané konverzní specifikátory jsou <code>'c', 'd', 'i', 'o', 'u', 'x', 'X', 'e', 'E', 'f', 'g', 'G', 's', '%',</code> a nestandardní <code>'q'</code>.
* Specifikátory polohy (např. "%2$s") nejsou podporovány.

Konverzní specifikátor <code>q</code> je jako  <code>s</code>, ale formátuje řetězec ve formě vhodné k bezpečnému zpětnému přečtení překladačem Lua: Řetězec je zapsán mezi dvojité uvozovky a všechny dvojité uvozovky, nové řádky, vložené nuly a zpětná lomítka v řetězci jsou při zápisu správně uvozeny.

Konverze mezi řetězci a čísly se provádí tak, jak je uvedeno na stránce [[#Data types|Datové typy]]. Ostatní typy nejsou automaticky převedeny na řetězce. Řetězce obsahující znaky NUL (hodnota bajtu 0) nejsou správně zpracovány.

Totožné s [[#mw.ustring.format|mw.ustring.format()]].

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

Vrací funkci iterátoru, která při každém svém volání vrací další zachycení z [[#Patterns|<code>pattern</code>]] přes řetězec <code>s</code>. Pokud <code>pattern</code> neurčuje žádné zachycení, pak se v každém volání vytvoří celá shoda.

Pro tuto funkci není '<code>^</code>' na začátku vzoru magické, protože by to zabránilo opakování. Zachází se s ním jako s doslovným znakem.

Viz [[#mw.ustring.gmatch|mw.ustring.gmatch()]] pro podobnou funkci, pro kterou je vzor rozšířen, jak je popsáno ve [[#Ustring patterns|vzorech Ustring]].

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

Vrátí dvě hodnoty:

# Kopie <code>s</code>, ve které byly všechny (nebo první <code>n</code>, pokud jsou uvedeny) výskyty [[#Patterns|<code>pattern</code>]] nahrazeny náhradním řetězcem specifikovaným <code>repl</code>, což může být řetězec, tabulka nebo funkce.
# Celkový počet shod, ke kterým došlo.

Pokud je <code>repl</code> řetězec, pak se jeho hodnota použije k nahrazení. Znak&nbsp;<code>%</code> funguje jako znak escape: Jakákoli sekvence v <code>repl</code> ve tvaru <code>%''d''</code>, s ''d'' mezi 1 a 9 znamená hodnotu ''d''-tého zachyceného podřetězce. Sekvence <code>%0</code> představuje celou shodu a sekvence <code>%%</code> představuje jeden&nbsp;<code>%</code>.

Je-li <code>repl</code> tabulka, pak je tabulka dotazována pro každou shodu s použitím prvního zachycení jako klíče. Pokud vzor neurčuje žádné zachycení, pak se jako klíč použije celá shoda.

Je-li <code>repl</code> funkce, pak je tato funkce volána pokaždé, když dojde ke shodě, se všemi zachycenými podřetězci předanými jako argumenty v pořadí. Pokud vzor neurčuje žádné zachycení, pak je celá shoda předána jako jediný argument.

Pokud je hodnota vrácená tabulkovým dotazem nebo voláním funkce řetězec nebo číslo, použije se jako náhradní řetězec. V opačném případě, je-li nepravda nebo nula, neexistuje žádná náhrada (tj. původní shoda je v řetězci zachována).

Viz [[#mw.ustring.gsub|mw.ustring.gsub()]] pro podobnou funkci, ve které je vzor rozšířen, jak je popsáno ve [[#Ustring patterns|vzorech Ustring]].

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

Vrátí délku řetězce v bajtech. Není zmaten znaky ASCII NUL. Ekvivalent <code style="white-space:nowrap">[[#Length operator|#]]s</code>.

Viz [[#mw.ustring.len|mw.ustring.len()]] pro podobnou funkci používající kódové body Unicode místo bajtů.

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

Vrátí kopii tohoto řetězce se všemi velkými písmeny ASCII změněnými na malá. Všechny ostatní znaky jsou ponechány beze změny.

Viz [[#mw.ustring.lower|mw.ustring.lower()]] pro podobnou funkci, ve které jsou převedeny všechny znaky s definicemi velkých písmen na malá v Unicode.

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

Hledá první shodu [[#Patterns|<code>pattern</code>]] v řetězci. Pokud nějaký najde, pak <code>match</code> vrátí zachycení ze vzoru; jinak vrátí nulu. Pokud <code>pattern</code> neurčuje žádné zachycení, vrátí se celá shoda.

Třetí, volitelný číselný argument <code>init</code> určuje, kde má začít hledání. Jeho výchozí hodnota je&nbsp;1 a může být záporná.

Viz [[#mw.ustring.match|mw.ustring.match()]] pro podobnou funkci, ve které je vzor rozšířen, jak je popsáno v [[#Ustring patterns|Ustring vzory]] a offset <code>init</code> je v znaků spíše než bajtů.

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

Vrátí řetězec, který je zřetězením <code>n</code> kopií řetězce <code>s</code>. Totožné s [[#mw.ustring.rep|mw.ustring.rep()]].

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

Vrátí řetězec, který je obrácený řetězec <code>s</code> (bajtově).

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

Vrátí podřetězec <code>s</code>, který začíná na <code>i</code> a pokračuje až do <code>j</code>; <code>i</code> a <code>j</code> mohou být záporné. Pokud je <code>j</code> nula nebo je vynecháno, bude pokračovat až do konce řetězce.

Konkrétně volání <code>string.sub(s,1,j)</code> vrátí předponu <code>s</code> s délkou <code>j</code> a <code style="white-space:nowrap">string.sub(s, -i)</code> vrátí příponu <code>s</code> s délkou <code>i</code>.

Viz [[#mw.ustring.sub|mw.ustring.sub()]] pro podobnou funkci, ve které jsou offsety spíše znaky než bajty.

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

Alias pro [[#mw.ustring.lower|mw.ustring.lower()]].

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

Vrátí kopii tohoto řetězce se všemi malými písmeny ASCII změněnými na velká. Všechny ostatní znaky jsou ponechány beze změny.

Viz [[#mw.ustring.upper|mw.ustring.upper()]] pro podobnou funkci, ve které jsou převedeny všechny znaky s definicemi malých písmen na velká v Unicode.

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

Alias pro [[#mw.ustring.upper|mw.ustring.upper()]].

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

Všimněte si, že vzory Lua jsou podobné [[w:regular expression|regulární výrazy]], ale nejsou totožné. Všimněte si zejména následujících rozdílů od regulárních výrazů a [[w:PCRE|PCRE]]:

* Znak uvozovky je procento (<code>%</code>), nikoli zpětné lomítko (<code>\</code>).
* Tečka (<code>.</code>) vždy odpovídá všem znakům, včetně nových řádků.
* Žádný režim bez rozlišení velkých a malých písmen.
* Žádná alternace (operátor <code>|</code>).
* Kvantifikátory (<code>*</code>, <code>+</code>, <code>?</code> a <code>-</code>) lze použít pouze na jednotlivé znaky nebo třídy znaků , nikoli k zachycení skupin.
* Jediným nezištným kvantifikátorem je <code>-</code>, což je ekvivalentní kvantifikátoru PCRE <code>*?</code>.
* Žádný zobecněný konečný kvantifikátor (např. kvantifikátor <code>{''n'',''m''}</code> v PCRE).
* Jediné výrazy s nulovou šířkou jsou <code>^</code>, <code>$</code> a vzor "hraniční" <code>%f[set]</code>. Tvrzení jako PCRE <code>\b</code> nebo <code>(?=···)</code> nejsou přítomna.
* Vzory samy o sobě nerozpoznají escapes znaků, jako je <code>\''ddd''</code><!-- jsou zamýšleny vyvážené uvozovky, předpokládám 2021-03-06 -->. Protože jsou však vzory [[#string|strings]], lze tento druh escapes použít v řetězcových literálech používaných k vytvoření řetězce vzoru.
<!-- 
** For example, in PCRE the regexp <code>\x65</code> (from a string literal such as <code>"\\x65"</code>) will match the string "hello", because the PCRE engine interprets escaped characters. But in Lua the equivalent pattern <code>\101</code> (from a string literal such as <code>"\\101"</code>) will not match "hello".
-->

Všimněte si také, že vzor nemůže obsahovat vložených nula bajtů (ASCII NUL, <code>"\0"</code>). Místo toho použijte <code>%z</code>.

Viz také [[#Ustring patterns|Ustring vzory]] pro podobné schéma porovnávání vzorů pomocí znaků Unicode.

<span id="Character_class"></span>
===== Třída znaků =====

''Třída znaků'' se používá k reprezentaci sady znaků. Při popisu třídy znaků jsou povoleny následující kombinace:

{| class="wikitable"
! scope="row" | <code>{{var|x}}</code>
| (kde <code>{{var|x}}</code> není jeden z magických znaků <code>^$()%.[]*+-?</code>) představuje samotný znak <code>{{var|x}}</code>.
|-
! scope="row" | <code>.</code>
| (tečka) Představuje všechny znaky.
|-
! scope="row" | <code>%a</code>
| Představuje všechna písmena ASCII.
|-
! scope="row" | <code>%c</code>
| Představuje všechny řídicí znaky ASCII.
|-
! scope="row" | <code>%d</code>
| Představuje všechny číslice.
|-
! scope="row" | <code>%l</code>
| Představuje všechna malá písmena ASCII.
|-
! scope="row" | <code>%p</code>
| Představuje všechny interpunkční znaky.
|-
! scope="row" | <code>%s</code>
| Představuje všechny mezery ASCII.
|-
! scope="row" | <code>%u</code>
| Představuje všechna velká písmena ASCII.
|-
! scope="row" | <code>%w</code>
| Představuje všechny alfanumerické znaky ASCII. Všimněte si, že neobsahuje znak podtržítka (<code>_</code>), na rozdíl od obvyklé třídy <code>\w</code> v regulárních výrazech.
|-
! scope="row" | <code>%x</code>
| Představuje všechny hexadecimální číslice.
|-
! scope="row" | <code>%z</code>
| Představuje ASCII NUL, nulový bajt.
|-
! scope="row" | <code>%A</code>
| Všechny znaky nejsou v <code>%a</code>.
|-
! scope="row" | <code>%C</code>
| Všechny znaky nejsou v <code>%c</code>.
|-
! scope="row" | <code>%D</code>
| Všechny znaky nejsou v <code>%d</code>.
|-
! scope="row" | <code>%L</code>
| Všechny znaky nejsou v <code>%l</code>.
|-
! scope="row" | <code>%P</code>
| Všechny znaky nejsou v <code>%p</code>.
|-
! scope="row" | <code>%S</code>
| Všechny znaky nejsou v <code>%s</code>.
|-
! scope="row" | <code>%U</code>
| Všechny znaky nejsou v <code>%u</code>.
|-
! scope="row" | <code>%W</code>
| Všechny znaky nejsou v <code>%w</code>.
|-
! scope="row" | <code>%X</code>
| Všechny znaky nejsou v <code>%x</code>.
|-
! scope="row" | <code>%Z</code>
| Všechny znaky nejsou v <code>%z</code>.
|-
! scope="row" | <code>%{{var|y}}</code>
| (kde <code>{{var|y}}</code> je libovolný nealfanumerický znak) představuje znak <code>{{var|y}}</code>. Toto je standardní způsob, jak uniknout magickým znakům. Každému interpunkčnímu znaku (dokonce i nemagickému) může předcházet '<code>%</code>', když se používá k reprezentaci sebe sama ve vzoru.
|-
! scope="row" | <code>[{{var|set}}]</code>
|
Představuje třídu, která je sjednocením všech znaků v {{var|set}}. Rozsah znaků lze určit oddělením koncových znaků rozsahu '<code>-</code>'. Všechny výše popsané třídy <code>%{{var|y}}</code> lze také použít jako komponenty v {{var|set}}. Všechny ostatní znaky v {{var|set}} představují samy sebe. Například <code>[%w_]</code> (nebo <code>[_%w]</code>) představuje všechny alfanumerické znaky plus podtržítko a <code style="white-space:nowrap">[0-7]</code> představuje osmičkové číslice. Chcete-li do sady zahrnout doslovný spojovník '<code>-</code>', použijte '<code>%-</code>', takže <code style="white-space:nowrap">[0-7%l%-]</code> představuje osmičkové číslice plus malá písmena plus znak '<code>-</code>'.

Interakce mezi rozsahy a třídami není definována. Proto vzory jako <code>[%a-z]</code> nebo <code>[a-%%]</code> nemají žádný význam.
|-
! scope="row" | <code>[^{{var|set}}]</code>
| Představuje doplněk {{var|set}}, kde {{var|set}} je interpretován jako výše.
|}

<span id="Pattern_items"></span>
===== Vzorové položky =====

''Položka vzoru'' může být

* třída jednoho znaku, která odpovídá libovolnému jednotlivému znaku ve třídě;
* třída jednoho znaku následovaná '<code>*</code>', která odpovídá 0 nebo více opakování znaků ve třídě. Tyto položky opakování budou vždy odpovídat nejdelší možné sekvenci;
* třída jednoho znaku následovaná '<code>+</code>', která odpovídá 1 nebo více opakování znaků ve třídě. Tyto položky opakování budou vždy odpovídat nejdelší možné sekvenci;
* třída jednoho znaku následovaná '<code>-</code>', která také odpovídá 0 nebo více opakování znaků ve třídě. Na rozdíl od '<code>*</code>' budou tyto položky opakování vždy odpovídat ''nejkratší'' možné sekvenci;
* třída jednoho znaku následovaná '<code>?</code>', která odpovídá 0 nebo 1 výskytu znaku ve třídě;
* <code>%''n''</code>, pro ''n'' mezi 1 a 9. Taková položka odpovídá podřetězci rovnému ''n''-tému zachycenému řetězci (viz níže);
* <code>%b''xy''</code>, kde ''x'' a ''y'' jsou dva odlišné znaky; taková položka odpovídá řetězcům, které začínají&nbsp;''x'', končí&nbsp;''y'' a kde jsou ''x'' a ''y'' ''vyvážené''. To znamená, že pokud čtete řetězec zleva doprava, počítáme-li +1 pro ''x'' a -1 pro ''y'', koncovka ''y'' je první ''y'', kde počet dosáhne 0. Například položka <code>%b()</code> odpovídá výrazům s vyváženým závorky.
<!-- This description of frontier patterns is from the Lua 5.2 manual, which is under the same license as the 5.1 manual. -->
* <code>%f[''set'']</code>, ''hraniční vzor''. Položka odpovídá prázdnému řetězci na libovolné pozici tak, že další znak patří do ''set'' a předchozí znak nepatří do ''set''. Sada ''set'' je interpretována tak, jak bylo popsáno dříve. Začátek a konec předmětu jsou zpracovány tak, jako by šlo o znak&nbsp;'\0'.<br/><small>Všimněte si, že hraniční vzory byly přítomné, ale nezdokumentované v Lua&nbsp;5.1 a oficiálně přidány do Lua v 5.2. Implementace v Lua&nbsp;5.2.1 se oproti 5.1.0 nezměnila.</small>
<span id="Pattern"></span>
===== Vzor =====

''Vzor'' je posloupnost položek vzoru.

<code>^</code> na začátku vzoru ukotví shodu na začátku řetězce předmětu. <code>$</code> na konci vzoru ukotví shodu na konci řetězce předmětu. Na jiných pozicích nemají <code>^</code> a <code>$</code> žádný zvláštní význam a představují samy sebe.

<span id="Captures"></span>
===== Zachycení =====

Vzor může obsahovat dílčí vzory uzavřené v závorkách. Popisují ''zachycení''. Když je shoda úspěšná, podřetězce předmětu, které odpovídají zachyceným, jsou uloženy ("zachyceny") pro budoucí použití. Záběry jsou číslovány podle levých závorek. Například ve vzoru <code>(a*(.)%w(%s*))</code> je část řetězce odpovídající <code>a*(.)%w(%s*)</code> je uložen jako první zachycení (a má tedy číslo&nbsp;1); znak odpovídající <code>.</code> je zachycen číslem&nbsp;2 a část odpovídající <code>%s*</code> má číslo&nbsp;3.

Odkazy na zachycení se mohou objevit v samotném řetězci vzoru a odkazovat zpět na text, který byl zachycen dříve ve shodě. Například <code>([a-z])%1</code> bude odpovídat libovolnému páru identických malých písmen, zatímco <code>([a-z])([a-z])([a-z])[a-z]%3%2%1</code> bude odpovídat libovolnému 7písmennému [[w:Palindrome|palindromu]].

Jako zvláštní případ, prázdný capture <code>()</code> zachycuje aktuální pozici řetězce (číslo). Pokud například použijeme vzor <code>"()aa()"</code> na řetězec <code>"flaaap"</code>, dojde ke dvěma zachycením: 3&nbsp;a&nbsp;5.

{{red|Známá omezení}}: Na rozdíl od [[#Ustring patterns|vzorů knihovny Ustring]] vzory knihovny řetězců nesmí obsahovat více než 32 zachycení. Pokud má vzor více, funkce String vyvolá chybu. Protože knihovna Ustring má vlastní maximum 10 000 bajtů pro vzory (na rozdíl od knihovny String), není možné použít vzor, který přesahuje oba limity, protože bude nekompatibilní s oběma knihovnami.

<span id="Table_library"></span>
=== Knihovna tabulek ===

Většina funkcí v knihovně tabulek předpokládá, že tabulka představuje [[#sequence|sekvenci]].

Funkce <code>table.foreach()</code>, <code>table.foreachi()</code> a <code>table.getn()</code> mohou být dostupné, ale jsou zastaralé; použijte smyčku for s <code>[[#pairs|pairs()]]</code>, smyčku for s <code>[[#ipairs|ipairs()]]</code> nebo [[#Length operator|length operator]] <code>#</code>, v daném pořadí. Funkce <code>table.setn()</code> je však zcela zastaralá a při použití vyvolá chybu.

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

Zadané pole, kde všechny prvky jsou řetězce nebo čísla, vrátí <code style="white-space:nowrap">table[i] .. sep .. table[i+1] ··· sep .. table[j]</code>.

Výchozí hodnota pro <code>sep</code> je prázdný řetězec, výchozí hodnota pro <code>i</code> je 1 a výchozí hodnota pro <code>j</code> je délka tabulky. Pokud je <code>i</code> větší než <code>j</code>, vrátí prázdný řetězec.

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

Vloží prvek <code>value</code> na pozici <code>pos</code> v <code>table</code> a v případě potřeby posune ostatní prvky nahoru do volného prostoru. Výchozí hodnota pro <code>pos</code> je délka tabulky plus 1, takže volání <code style="white-space:nowrap">table.insert(t, x)</code> vloží <code>x</code> na konci tabulky <code>t</code>.

Prvky až do <code>#table</code> jsou posunuty. Viz [[#Length operator|Operátor délky]] pro upozornění, pokud tabulka není [[#sequence|sekvence]].

{{red|Poznámka}}: při použití parametru <code>pos</code> by <code>value</code> nemělo být <code>nil</code>. Pokus o vložení explicitní hodnoty <code>nil</code> doprostřed tabulky bude mít za následek nedefinované chování, které může nepředvídatelně odstranit prvky v tabulce.

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

Vrátí největší kladný číselný index dané tabulky nebo nulu, pokud tabulka nemá žádné kladné číselné indexy.

K tomu iteruje přes celou tabulku. To je zhruba ekvivalentní

<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>

Odebere z <code>table</code> prvek na pozici <code>pos</code>, posunutím dalších prvků dolů, aby se prostor v případě potřeby uzavřel. Vrátí hodnotu odstraněného prvku. Výchozí hodnota pro <code>pos</code> je délka tabulky, takže volání <code style="white-space:nowrap">table.remove( t )</code> odstraní poslední prvek tabulky tabulka <code>t</code>.

Prvky až do <code>#table</code> jsou posunuty. Viz [[#Length operator|Operátor délky]] pro upozornění, pokud tabulka není [[#sequence|sekvence]].

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

Seřadí prvky tabulky v daném pořadí, ''na místě'', od <code>table[1]</code> do <code>table[#table]</code>.
Je-li zadáno <code>comp</code>, pak to musí být funkce, která přijímá dva prvky tabulky a vrací {{luai|true}}, když je první menší než druhý (takže <code style="white-space:nowrap">not comp(a[i+1],a[i])</code> bude po třídění pravdivé).
Pokud není zadáno <code>comp</code>, použije se místo něj standardní operátor Lua <code>&lt;</code>.
Algoritmus řazení není stabilní. To znamená, že prvky považované za stejné daným řádem mohou mít svou relativní polohu změněnou řazením.

<span id="Scribunto_libraries"></span>
== Knihovny Scribunto ==

Všechny knihovny Scribunto jsou umístěny v tabulce <code>mw</code>.

<span id="Base_functions"></span>
=== Základní funkce ===

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

Přidá upozornění, které se zobrazí nad náhledem při náhledu úpravy. <code>text</code> je analyzován jako wikitext.

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

Volá [[#tostring|tostring()]] u všech argumentů a poté je zřetězí pomocí tabulátorů jako oddělovačů.

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

Vytvoří hlubokou kopii hodnoty. Všechny tabulky (a jejich metatabulky) jsou od základu rekonstruovány. Funkce jsou však stále sdílené.

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

Vrátí aktuální [[#frame-object|objekt frame]], obvykle objekt frame z nejnovějšího <code>#invoke</code>.

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

Přidá jedničku k počtu "náročné funkce analyzátoru" a vyvolá výjimku, pokud překročí limit (viz {{wg|ExpensiveParserFunctionLimit}}).

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

Vrátí true, pokud je aktuální <code>#invoke</code> [[Special:MyLanguage/Manual:Substitution|substed]], v opačném případě {{luai|false}}. Viz [[#Returning text|Vracející se text]] výše, kde najdete diskuzi o rozdílech mezi nahrazováním a nevracením.

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

Někdy modul potřebuje velké tabulky dat. Například modul pro všeobecné použití pro převod měrných jednotek může potřebovat velkou tabulku rozpoznaných jednotek a jejich převodních faktorů. A někdy budou tyto moduly použity mnohokrát na jedné stránce. Analýza velké datové tabulky pro každý <code><nowiki>{{#invoke:}}</nowiki></code> může zabrat značné množství času. Chcete-li se tomuto problému vyhnout, poskytujeme <code>mw.loadData()</code>.

<code>mw.loadData</code> funguje jako <code>[[#require|require()]]</code> s následujícími rozdíly:

* Načtený modul je vyhodnocen pouze jednou na stránku, nikoli jednou za volání <code><nowiki>{{#invoke:}}</nowiki></code>.
* Načtený modul není zaznamenán v <code>[[#package.loaded|package.loaded]]</code>.
* Hodnota vrácená z načteného modulu musí být tabulka. Jiné datové typy nejsou podporovány.
* Vrácená tabulka (a všechny podtabulky) může obsahovat pouze logické hodnoty, čísla, řetězce a další tabulky. Jiné datové typy, zejména funkce, nejsou povoleny.
* Vrácená tabulka (a všechny podtabulky) nemusí mít [[#Metatables|metatable]].
* Všechny klíče tabulky musí být booleovské, čísla nebo řetězce.
* Tabulka skutečně vrácená <code>mw.loadData()</code> má metametody, které poskytují přístup pouze pro čtení k tabulce vrácené modulem. Protože neobsahuje data přímo, <code>[[#pairs|pairs()]]</code> a <code>[[#ipairs|ipairs()]]</code> budou fungovat, ale jiné metody, včetně <code>[[#Length operator|#value]]</code>, <code style="white-space:nowrap">[[#next|next()]]</code> a funkce v [[#Table library|Knihovně tabulek]] nebudou fungovat správně.

Výše zmíněný hypotetický modul převodu jednotek by mohl ukládat svůj kód do "Module:Convert" a jeho data do "Module:Convert/data" a "Module:Convert" by používal <code style="white-space:nowrap">local data = mw.loadData( 'Module:Convert/data' )</code> pro efektivní načítání dat.

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

<!-- description of mw.loadJsonData -->
To je stejné jako <code>mw.loadData()</code> výše, kromě toho, že načítá data ze stránek JSON, nikoli z tabulek Lua.
Obsah JSON musí být pole nebo objekt.
Více na stránce <code>[[#mw.text.jsonDecode|mw.text.jsonDecode()]]</code>.
<!-- link of mw.text.jsonDecode -->

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

Serializuje <code>object</code> na lidsky čitelnou reprezentaci a poté vrátí výsledný řetězec.

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

Předá argumenty [[#mw.allToString|mw.allToString()]] a poté připojí výsledný řetězec do vyrovnávací paměti protokolu.

V ladicí konzoli je funkce <code>print()</code> aliasem této funkce.

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

Zavolá [[#mw.dumpObject|mw.dumpObject()]] a připojí výsledný řetězec k vyrovnávací paměti protokolu. Pokud je zadán <code>prefix</code>, bude přidán do vyrovnávací paměti protokolu následovaný znakem rovná se před připojením serializovaného řetězce (tj. protokolovaný text bude "prefix = object-string").
{{anchor|frame-object}}
<span id="Frame_object"></span>
=== Objekt frame ===

Objekt frame je rozhraním pro parametry předávané <syntaxhighlight lang="text" inline>{{#invoke:}}</syntaxhighlight> a pro analyzátor.

Všimněte si, že neexistuje žádná knihovna frame a neexistuje žádná globální proměnná s názvem {{luai|frame}}. Objekt frame se obvykle získává předáním jako parametr funkci volané <syntaxhighlight lang="text" inline>{{#invoke:}}</syntaxhighlight> a lze jej také získat z <code>[[#mw.getCurrentFrame|mw.getCurrentFrame()]]</code>.
==== frame.args ====
Tabulka pro přístup k argumentům předávaným do frame. Například pokud je modul volán z wikitextu s

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

potom {{luai|frame.args[1]}} vrátí <code>"arg1"</code>, {{luai|frame.args[2]}} vrátí <code>"arg2"</code> a {{luai|frame.args['name']}} (nebo {{luai|frame.args.name}}) vrátí <code>"arg3"</code>. Je také možné opakovat argumenty pomocí {{luai|pairs( frame.args )}} nebo {{luai|ipairs( frame.args )}}.
Nicméně vzhledem k tomu, jak Lua implementuje iterátory tabulek, iterace přes argumenty je vrátí v nespecifikovaném pořadí a neexistuje způsob, jak zjistit původní pořadí, jak se objevují ve wikitextu.

Všimněte si, že hodnoty v této tabulce jsou vždy řetězce. <code>[[#tonumber|tonumber()]]</code> lze v případě potřeby použít k jejich převodu na čísla. Klíče jsou však čísla, i když jsou ve vyvolání explicitně zadány: <syntaxhighlight lang="text" inline>{{#invoke:module|function|1|2=2}}</syntaxhighlight> udává řetězcové hodnoty <code>"1"</code> a <code>"2"</code> indexované pomocí číselných klíčů <code>1</code> a <code>2</code>.

Stejně jako při vyvolání šablon MediaWiki budou mít pojmenované argumenty před předáním Lua úvodní a koncové prázdné znaky odstraněné z názvu i hodnoty, zatímco u nepojmenovaných argumentů nebudou prázdné znaky odstraněny.

Z důvodů výkonu <code>frame.args</code> používá metatabulku, nikoli přímo obsahující argumenty. Hodnoty argumentů jsou vyžadovány od MediaWiki na vyžádání. To znamená, že většina ostatních metod tabulky nebude fungovat správně, včetně <code>[[#Length operator|#frame.args]]</code>, <code style="white-space:nowrap">[[#next|next]]( frame.args )</code> a funkce v [[#Table library|Knihovně tabulek]].

Pokud je v argumentu <code>#invoke</code> zahrnuta syntaxe preprocesoru, jako je vyvolání šablony a argumenty se třemi závorkami, nebudou po předání do Lua rozbaleny, dokud jejich hodnoty nebudou požadovány v Lua. Pokud jsou určité speciální značky napsané v notaci XML, jako například {{tag|pre|o}}, {{tag|nowiki|o}}, {{tag|gallery|o}} a {{tag|ref|o}}, zahrnuty jako argumenty <code>#invoke</code>, pak budou tyto značky převedeny na "[[strip marker]]s" — speciální řetězce které začínají znakem delete (ASCII 127), které mají být nahrazeny HTML poté, co jsou vráceny z #invoke.

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

: ''Všimněte si použití [[#named arguments|pojmenovaných argumentů]].''

Zavolejte [[Special:MyLanguage/Help:Magic words#Parser functions|funkci analyzátoru]] a vrátíte příslušný řetězec. Toto je vhodnější než <code>frame:preprocess</code>, ale kdykoli je to možné, měly by být před tímto rozhraním upřednostňovány nativní funkce Lua nebo funkce knihovny Scriunto.

Následující volání jsou přibližně ekvivalentní uvedenému wikitextu:

<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>

Všimněte si, že stejně jako u [[#frame:expandTemplate|frame:expandTemplate()]] nejsou název funkce a argumenty před předáním do funkce analyzátoru předzpracovány.

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

: ''Všimněte si použití [[#named arguments|pojmenovaných argumentů]].''

To je ekvivalentní volání [[#frame:callParserFunction|frame:callParserFunction()]] s názvem funkce {{luai|'msg'}} (viz [[Special:MyLanguage/Help:Magic words#Transclusion modifiers|Nápověda:Kouzelná slova#Modifikátory transkluze]]) a s {{luai|title}} předřazeným {{luai|args}}.

Toto je transkluze. Volání:

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

dělá v Lua zhruba to samé, co <syntaxhighlight lang="text" inline>{{template|arg1|arg2|name=arg3}}</syntaxhighlight> dělá ve wikitextu. Stejně jako v transkluzi, pokud předaný název neobsahuje předponu jmenného prostoru, bude se předpokládat, že je ve jmenném prostoru Template:.

Všimněte si, že nadpis a argumenty nejsou před předáním do šablony předzpracovány:

<syntaxhighlight lang="lua">
-- To je zhruba ekvivalentní wikitextu jako {{template|{{!}}}}
frame:expandTemplate{ title = 'template', args = { '|' } }
frame:callParserFunction{ 'msg', { 'template', '|' } }

-- To je zhruba ekvivalentní wikitextu jako {{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>
}}

To je ekvivalentní volání [[#frame:callParserFunction|frame:callParserFunction()]] s názvem funkce {{luai|'#tag'}} (viz [[Special:MyLanguage/Help:Magic_words#Miscellaneous|Help:Magic_words#Miscellaneous]]) a s {{luai|name}} a {{luai|content}} připojenými k {{luai|args}}.

<syntaxhighlight lang="lua">
-- Tyto jsou rovnocenné
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'
} )

-- Tyto jsou rovnocenné
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()}}

Volaný v rámci vytvořeném <syntaxhighlight lang="text" inline>{{#invoke:}}</syntaxhighlight> vrátí rámec pro stránku, která volala <syntaxhighlight lang="text" inline>{{#invoke:}}</syntaxhighlight>. Volaný na tomto snímku vrací nulu.

Pokud například šablona <syntaxhighlight lang="text" inline>{{Example}}</syntaxhighlight> obsahuje kód <syntaxhighlight lang="text" inline>{{#invoke:ModuleName|FunctionName|A|B}}</syntaxhighlight> a stránka tuto šablonu převede kódem <syntaxhighlight lang="text" inline>{{Example|C|D}}</syntaxhighlight>, pak v ''Module:ModuleName'' volání <code>frame.args[1]</code> a <code>frame.args[2]</code> vrátí <code>"A"</code> a <code>"B"</code> a volání <code>frame:getParent().args[1]</code> a <code>frame:getParent().args[2]</code> vrátí <code>"C"</code> a <code>"D"</code>, přičemž <code>frame</code> je první argument ve volání funkce.

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

Vrátí název spojený s rámcem jako řetězec. Pro rámec vytvořený <syntaxhighlight lang="text" inline>{{#invoke:}}</syntaxhighlight> je to název vyvolaného modulu.

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

: ''Všimněte si použití [[#named arguments|pojmenovaných argumentů]].''

Vytvořte nový [[#frame-object|objekt frame]], který je potomkem aktuálního frame, s volitelnými argumenty a názvem.

Toto je určeno hlavně pro použití v modulech, které volají jiné moduly, jejichž jméno je definováno volajícím (např. <code>{{[[w:Module:Params|#invoke:params]]|[[w:Module:Params#concat_and_invoke|concat_and_invoke]]}}</code>, nebo v ladicí konzoli pro testování funkcí, které by normálně volalo <syntaxhighlight lang="text" inline>{{#invoke:}}</syntaxhighlight>. Počet frame, které mohou být vytvořeny v libovolném čas je omezený.

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

Tím se rozbalí wikitext v kontextu rámce, tj. rozbalí se šablony, funkce analyzátoru a parametry, jako je <syntaxhighlight lang="text" inline>{{{1}}}</syntaxhighlight>, a vrátí se rozbalený text. Některé speciální značky napsané ve stylu XML, jako například {{tag|pre|o}}, {{tag|nowiki|o}}, {{tag|gallery|o}} a {{tag|ref|o}}, budou nahrazeny "[[Special:MyLanguage/strip marker|strip markers]]" — speciálními řetězci, které začínají znakem delete (ASCII 127), které mají být nahrazeny HTML poté, co budou vráceny z <code>#invoke</code>.

Pokud rozšiřujete jednu šablonu, použijte <code>[[#frame:expandTemplate|frame:expandTemplate]]</code> místo toho, abyste se snažili vytvořit řetězec wikitextu pro předání této metodě. Je rychlejší a méně náchylné k chybám, pokud argumenty obsahují svislé znaky nebo jiné wikimarkupy.

Pokud rozšiřujete funkci jednoho analyzátoru, použijte ze stejných důvodů <code>[[#frame:callParserFunction|frame:callParserFunction]]</code>.

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

Získá objekt pro zadaný argument nebo nulu, pokud argument není zadán.

Vrácený objekt má jednu metodu, <code>object:expand()</code>, která vrací rozšířený wikitext pro argument.

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

Vrátí objekt jednou metodou, <code>object:expand()</code>, která vrátí výsledek <code style="white-space:nowrap">[[#frame:preprocess|frame:preprocess]]( text )</code>.

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

: ''Všimněte si použití [[#named arguments|pojmenovaných argumentů]].''

Vrátí objekt s jednou metodou, <code>object:expand()</code>, která vrátí výsledek <code>[[#frame:expandTemplate|frame:expandTemplate]]</code> volaného s danými argumenty.

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

Stejně jako {{luai|pairs( frame.args )}}. Zahrnuto pro zpětnou kompatibilitu.

<span id="Hash_library"></span>
=== Knihovna hash ===

==== mw.hash.hashValue ====
<code style="white-space:nowrap">mw.hash.hashValue( něco, hodnota )</code>

Hašuje hodnotu řetězce se zadaným algoritmem. Platné algoritmy lze načíst pomocí [[#mw.hash.listAlgorithms|mw.hash.listAlgorithms()]].

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

Vrátí seznam podporovaných hashovacích algoritmů pro použití v [[#mw.hash.hashValue|mw.hash.hashValue()]].

<span id="HTML_library"></span>
=== Knihovna HTML ===

<code>mw.html</code> je plynulé rozhraní pro vytváření komplexního HTML z Lua. Na mnoha wikinách Wikimedie to bylo dříve implementováno v <code>Module:HtmlBuilder</code>. Objekt mw.html lze vytvořit pomocí <code>[[#mw.html.create|mw.html.create]]</code>.

{{anchor|mw.html-object}}
Funkce dokumentované jako <code>mw.html.<var>name</var></code> jsou dostupné v globální tabulce <code>mw.html</code>. Funkce dokumentované jako <code>mw.html:<var>name</var></code> a <code>html:<var>name</var></code> jsou metody objektu mw.html (viz <code>[[#mw.html.create|mw.html.create]]</code>).

Základní příklad by mohl vypadat takto:

<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>

Vytvoří nový objekt mw.html obsahující prvek html <code>tagName</code>. Můžete také předat prázdný řetězec nebo nil jako <code>tagName</code>, abyste vytvořili prázdný objekt mw.html.

<code>args</code> může být tabulka s následujícími klíči:

* <code>args.selfClosing</code>: Vynutí automatické uzavření aktuální značky, i když ji mw.html jako samouzavírací nerozpozná
* <code>args.parent</code>: Nadřazený prvek aktuální instance mw.html (určeno pro interní použití)

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

Připojí podřízený uzel mw.html (<code>builder</code>) k aktuální instanci mw.html. Pokud je předán nulový parametr, jedná se o neoperaci. Uzel (<code>builder</code>) je řetězcová reprezentace prvku html.

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

Připojí k objektu mw.html neurčený počet řetězců wikitextu.

Všimněte si, že toto končí u první položky ''nula'' (nil).

Základní wikitext bude analyzován, jako je HTML, odkazy, tučné písmo, seznamy nebo tabulky. Šablony a funkce analyzátoru však nebudou vyhodnoceny, pokud jsou předány přímo této funkci, pokud nepocházejí z parametrů šablony.
Ty budou místo toho vykresleny jako prostý text.
Chcete-li je vyhodnotit, musíte je projít [[#frame:preprocess|frame:preprocess]].

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

Připojí nový řádek k objektu mw.html.
Užitečné při použití před a po [[#mw.html:wikitext|mw.html:wikitext()]], když wikitext obsahuje seznamy nebo tabulky, jejichž syntaxe má zvláštní význam pouze tehdy, jsou-li uvedeny na začátku řádku.

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

Připojí nový podřízený uzel s daným <code>tagName</code> k staviteli a vrátí instanci mw.html představující tento nový uzel. Parametr <code>args</code> je shodný s parametrem <code>[[#mw.html.create|mw.html.create]]</code>

Všimněte si, že na rozdíl od jiných metod, jako je <code>[[#mw.html:node|html:node()]]</code>, tato metoda nevrací aktuální instanci mw.html, ale instanci mw.html nově vložené značky.
Ujistěte se, že používáte [[#mw.html:done|<code>html:done()</code>]] pro přechod na nadřazenou instanci mw.html nebo [[#mw.html:allDone|<code>html:allDone()</code>]], pokud máte vnořené značky na několika úrovních.

==== 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>

Nastavte atribut HTML s daným <code>name</code> a <code>value</code> na uzlu. Alternativně lze předat tabulku obsahující páry atributů název->hodnota k nastavení. V prvním formuláři hodnota nil způsobí, že jakýkoli atribut s daným názvem nebude nastaven, pokud byl dříve nastaven.

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

Získejte hodnotu dříve nastaveného atributu html pomocí [[#mw.html:attr|<code>html:attr()</code>]] s daným <code>name</code>.

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

Přidá název třídy do atributu class uzlu. Pokud je předán nulový parametr, nejedná se o operaci.

==== 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>

Nastavte vlastnost CSS s daným <code>name</code> a <code>value</code> na uzlu. Alternativně lze předat tabulku obsahující páry vlastností název->hodnota k nastavení. V prvním formuláři hodnota nil způsobí, že jakákoli vlastnost s daným názvem nebude nastavena, pokud byla dříve nastavena.

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

Přidejte nějaké nezpracované <code>css</code> do atributu stylu uzlu. Pokud je předán nulový parametr, nejedná se o operaci.

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

Vrátí nadřazený uzel, pod kterým byl vytvořen aktuální uzel. Stejně jako jQuery.end se jedná o pohodlnou funkci, která umožňuje zřetězení několika podřízených uzlů do jednoho příkazu.

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

Jako [[#mw.html:done|<code>html:done()</code>]], ale projde celou cestu ke kořenovému uzlu stromu a vrátí jej.

<span id="Language_library"></span>
=== Jazyková knihovna ===

Kódy jazyků jsou popsány na [[Special:MyLanguage/Language code|kód jazyka]]. Mnoho jazykových kódů MediaWiki je podobných [[w:IETF language tag|jazykovým značkám IETF]], ale ne všechny kódy jazyků MediaWiki jsou platnými značkami IETF a naopak.

{{anchor|mw.language-object}}
Funkce dokumentované jako <code>mw.language.<var>name</var></code> jsou dostupné v globální tabulce <code>mw.language</code>. Funkce dokumentované jako <code>mw.language:<var>name</var></code> a <code>lang:<var>name</var></code> jsou metody jazykového objektu (viz [[#mw.language.new|<code>mw.language.new</code>]] nebo [[#mw.language.getContentLanguage|<code>mw.language.getContentLanguage</code>]]).

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

Úplný název jazyka pro daný kód jazyka: Ve výchozím nastavení nativní název (autonomní jazyka), název přeložený do cílového jazyka, pokud je uvedena hodnota pro <var>inLanguage</var>.

==== 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>

Načte seznam jazyků známých MediaWiki a vraťte tabulku mapující kód jazyka na název jazyka.

Ve výchozím nastavení je vrácen název autonomního jazyka. Předání kódu jazyka pro <var>inLanguage</var> vrátí všechna jména v tomto jazyce.

Ve výchozím nastavení jsou vráceny pouze názvy jazyků známé MediaWiki. Předání <code>'all'</code> pro <var>include</var> vrátí všechny dostupné jazyky (od {{ll|Extension:CLDR}}), zatímco předání <code>'mwfile'</code> zahrne pouze jazyky s přizpůsobenými zprávami zahrnutými do jádra MediaWiki nebo povolených rozšíření. Chcete-li explicitně vybrat výchozí hodnotu, může být předáno <code>'mw'</code>.

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

Vrátí nový jazykový objekt pro výchozí jazyk obsahu wiki.

==== mw.language.getFallbacksFor ====
[[File:MediaWiki fallback chains.svg|thumb|Záložní řetězce]]
<code style="white-space:nowrap">mw.language.getFallbacksFor( code )</code>

Vrátí seznam záložních jazykových kódů MediaWiki pro zadaný kód.

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

Vrátí hodnotu {{luai|true}}, pokud MediaWiki zná kód jazyka.

Kód jazyka je "známý", pokud se jedná o "platný vestavěný kód" (tj. vrací hodnotu {{luai|true}} pro [[#mw.language.isValidBuiltInCode|<code>mw.language.isValidBuiltInCode</code>]]) a vrací neprázdný řetězec pro [[#mw.language.fetchLanguageName|<code>mw.language.fetchLanguageName</code>]].

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

Zkontroluje, zda je v MediaWiki pro daný kód jazyka k dispozici nějaká lokalizace.

Jazykový kód je "podporován", pokud je "platným" kódem (vrací hodnotu {{luai|true}} pro [[#mw.language.isValidCode|<code>mw.language.isValidCode</code>]]), neobsahuje žádná velká písmena a má soubor zpráv v aktuálně spuštěné verzi MediaWiki.

Je možné, že kód jazyka bude "podporován", ale není „známý“ (tj. vrátí hodnotu {{luai|true}} pro [[#mw.language.isKnownLanguageTag|<code>mw.language.isKnownLanguageTag</code>]]). Všimněte si také, že některé kódy jsou "podporovány", přestože [[#mw.language.isValidBuiltInCode|<code>mw.language.isValidBuiltInCode</code>]] vrací {{luai|false}}.

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

Vrátí hodnotu {{luai|true}}, pokud má kód jazyka platnou formu pro účely interního přizpůsobení MediaWiki.

Kód nemusí ve skutečnosti odpovídat žádnému známému jazyku.

Kód jazyka je "platný vestavěný kód", pokud je "platným" kódem (tj. vrací hodnotu {{luai|true}} pro [[#mw.language.isValidCode|<code>mw.language.isValidCode</code>]]); sestává pouze z ASCII písmen, čísel a pomlček. A má alespoň dva znaky.

Všimněte si, že některé kódy jsou "podporovány" (tj. vrací {{luai|true}} pro [[#mw.language.isSupportedLanguage|<code>mw.language.isSupportedLanguage</code>]]), i když tato funkce vrací {{luai|false}}.

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

Vrátí hodnotu {{luai|true}}, pokud má řetězec kódu jazyka platnou formu, ať už existuje či nikoli. To zahrnuje kódy, které se používají výhradně pro přizpůsobení prostřednictvím jmenného prostoru MediaWiki.

Kód nemusí ve skutečnosti odpovídat žádnému známému jazyku.

Jazykový kód je platný, pokud neobsahuje určité nebezpečné znaky (dvojtečky, jednoduché nebo dvojité uvozovky, lomítka, zpětná lomítka, lomené závorky, ampersandy nebo ASCII NUL) a je jinak povolen v názvu stránky.

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

Vytvoří nový jazykový objekt. Jazykové objekty nemají žádné veřejně přístupné vlastnosti, ale mají několik metod, které jsou zdokumentovány níže.

Počet odlišných jazykových kódů, které lze na stránce použít, je omezen na 200. Překročení tohoto limitu bude mít za následek chyby.

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

Vrátí kód jazyka pro tento jazykový objekt.

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

Vrátí standardní [[w:IETF language tag|BCP-47]] kód jazyka pro tento objekt jazyka. Toto je kódový řetězec, který je vhodné použít v HTML, například jako hodnotu atributu <code>lang</code>.

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

Vrátí seznam záložních jazykových kódů MediaWiki pro tento jazykový objekt. Ekvivalent <code style="white-space:nowrap">mw.language.getFallbacksFor( lang:getCode() )</code>.

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

Vrátí {{luai|true}}, pokud je jazyk psán zprava doleva, {{luai|false}}, pokud je psán zleva doprava.

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

Převede řetězec na malá písmena, respektuje všechna speciální pravidla pro daný jazyk.

Pokud je načtena knihovna [[#Ustring library|Ustring]], je funkce [[#mw.ustring.lower|mw.ustring.lower()]] implementována jako volání <code style="white-space:nowrap">mw.language.getContentLanguage():lc( s )</code>.

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

Převede první znak řetězce na malá písmena, jako u [[#mw.language:lc|<code>lang:lc()</code>]].

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

Převede řetězec na velká písmena, respektuje všechna speciální pravidla pro daný jazyk.

Pokud je načtena knihovna [[#Ustring library|Ustring]], je funkce [[#mw.ustring.upper|<code>mw.ustring.upper()</code>]] implementována jako volání <code style="white-space:nowrap">mw.language.getContentLanguage():uc( s )</code>.

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

Převede první znak řetězce na velká písmena, jako u [[#mw.language:uc|lang:uc()]].

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

Převede řetězec na reprezentaci vhodnou pro porovnání bez ohledu na velikost písmen. Pamatujte, že výsledek nemusí při zobrazení dávat smysl.

==== 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>

Formátuje číslo se seskupením a oddělovači desetinných míst vhodnými pro daný jazyk. Vzhledem k 123456.78 může vytvořit "123,456.78", "123.456,78" nebo dokonce něco jako "١٢٣٬٤٥٦٫٧٨" v závislosti na jazyku a konfiguraci wiki.

<code>options</code> je tabulka možností, které mohou být:

* <code>noCommafy</code>: Nastavením {{luai|true}} vynecháte oddělovače seskupení a jako oddělovač desetinných míst použijete tečku (<code>.</code>). Stále může docházet k transformaci číslic, což může zahrnovat transformaci desetinného oddělovače.

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

Formátuje datum podle zadaného formátovacího řetězce. Pokud je <code>timestamp</code> vynechán, výchozí je aktuální čas. Hodnota pro <code>local</code> musí být booleovská nebo nulová; pokud je {{luai|true}}, čas je formátován v [[Special:MyLanguage/Manual:$wgLocaltimezone|místním čase wiki]] spíše než v UTC.

Formátovací řetězec a podporované hodnoty pro <code>timestamp</code> jsou totožné s těmi pro [[Special:MyLanguage/Help:Extension:ParserFunctions#.23time|#funkci analyzátoru času]] z {{ll|Extension:ParserFunctions}}.
Všimněte si však, že zpětná lomítka může být nutné zdvojnásobit v řetězcovém literálu Lua, protože Lua také používá zpětné lomítko jako znak escape, zatímco wikitext ne:

<syntaxhighlight lang="lua">
-- Tento řetězcový literál obsahuje nový řádek, nikoli dva znaky "\n", takže není ekvivalentní k {{#time:\n}}.
lang:formatDate( '\n' )

-- Toto je ekvivalentní {{#time:\n}}, nikoli {{#time:\\n}}.
lang:formatDate( '\\n' )

-- Toto je ekvivalent {{#time:\\n}}, nikoli {{#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>

Rozdělí dobu trvání v sekundách do více čitelných jednotek, např. 12345 na 3 hodiny, 25 minut a 45 sekund, výsledek se vrátí jako řetězec.

<code>chosenIntervals</code>, pokud je zadán, je tabulka s hodnotami pojmenujícími jednotky intervalu, které se mají použít v odpovědi. Patří mezi ně '<code>millennia</code>' (tisíciletí), '<code>centuries</code>' (století), '<code>decades</code>' (dekády), '<code>years</code>' (roky), '<code>weeks</code>' (týdny), '<code>days</code>' (dny), '<code>hours</code>' (hodiny), '<code>minutes</code>' (minuty) a '<code>seconds</code>' (sekundy).

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

To převezme číslo ve formátu [[#mw.language:formatNum|lang:formatNum()]] a vrátí skutečné číslo. Jinými slovy, toto je v podstatě jazyková verze [[#tonumber|<code>tonumber()</code>]].

==== 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>

Vybere vhodnou gramatickou formu z <code>forms</code> (což musí být tabulka [[#sequence|sequence]]) nebo <code>...</code> na základě čísla <code>n</code>. Například v angličtině můžete použít <code style="white-space:nowrap">n .. ' ' .. lang:plural( n, 'sock', 'socks' )</code> nebo <code style="white-space:nowrap">n .. ' ' .. lang:plural( n, { 'sock', 'socks' } )</code> pro vygenerování gramaticky správného textu bez ohledu na to, zda je k dispozici pouze 1 ponožka nebo 200 ponožek.

Potřebné hodnoty pro sekvenci jsou závislé na jazyce, viz [[Special:MyLanguage/Help:Magic words#Localization|lokalizace kouzelných slov]] a [[translatewiki:Special:MyLanguage/FAQ#PLURAL|Nejčastější dotazy na translatewiki na PLURALu]], kde jsou některé podrobnosti.

==== 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>

: ''Všimněte si rozdílného pořadí parametrů mezi dvěma aliasy. <code>convertGrammar</code> odpovídá pořadí stejnojmenné metody v objektu Language MediaWiki, zatímco <code>grammar</code> odpovídá pořadí stejnojmenné funkce analyzátoru, dokumentované na stránce[[Special:MyLanguage/Help:Magic words#Localisation|Nápověda:Magická slovíčka#Lokalizace]].''

Tím se vybere vhodná skloňovaná forma <code>word</code> pro daný kód skloňování <code>case</code>.

Možné hodnoty pro <code>word</code> a <code>case</code> jsou závislé na jazyce, viz [[Special:MyLanguage/Help:Magic words#Localisation]] a [[translatewiki:Special:MyLanguage/Grammar|translatewiki:Grammar]] pro některé podrobnosti.

==== 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>

Vybere řetězec odpovídající pohlaví <code>what</code>, což může být "muž", "žena" nebo registrované uživatelské jméno.

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

Vrátí znak šipky Unicode odpovídající <code>směru</code>:

* '''vpřed''': Buď "→" nebo "←" v závislosti na směrovosti jazyka.
* '''zpět''': Buď "←" nebo "→" v závislosti na směrovosti jazyka.
* '''vlevo''': "←"
* '''správně''': "→"
* '''nahoru''': "↑"
* '''dolů''': "↓"

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

Vrátí "ltr" nebo "rtl" v závislosti na směrovosti jazyka.

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

Vrátí řetězec obsahující buď U+200E (značka zleva doprava) nebo U+200F (značka zprava doleva), v závislosti na směrovosti jazyka a na tom, zda je <code>opačný</code> pravdivá nebo nepravdivá hodnota.

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

Vrátí "&amp;lrm;" nebo "&amp;rlm;", v závislosti na směrovosti jazyka a na tom, zda je <code>opačná</code> hodnota pravdivá nebo nepravdivá.

==== 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>

Rozdělí dobu trvání v sekundách do více čitelných jednotek, např. 12345 na 3 hodiny, 25 minut a 45 sekund, přičemž výsledek se vrátí jako tabulka mapující názvy jednotek na čísla.

<code>chosenIntervals</code>, pokud je zadán, je tabulka s hodnotami pojmenujícími jednotky intervalu, které se mají použít v odpovědi. Patří mezi ně '<code>millennia</code>' (tisíciletí), '<code>centuries</code>' (století), '<code>decades</code>' (dekády), '<code>years</code>' (roky), '<code>weeks</code>' (týdny), '<code>days</code>' (dny), '<code>hours</code>' (hodiny), '<code>minutes</code>' (minuty) a '<code>seconds</code>' (sekundy).

Tato klíčová slova jednotek jsou také klíči používanými v tabulce odpovědí. V odpovědi jsou nastaveny pouze jednotky s nenulovou hodnotou, pokud by odpověď nebyla prázdná, v takovém případě je vrácena nejmenší jednotka s hodnotou 0.

<span id="Message_library"></span>
=== Knihovna zpráv ===

Tato knihovna je rozhraním pro lokalizační zprávy a jmenný prostor MediaWiki:.

{{anchor|mw.message-object}}
Funkce dokumentované jako <code>mw.message.<var>name</var></code> jsou dostupné v globální tabulce <code>mw.message</code>. Funkce dokumentované jako <code>mw.message:<var>name</var></code> a <code>msg:<var>name</var></code> jsou metody objektu zprávy (viz [[#mw.message.new|<code>mw.message.new</code>]]).

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

Vytvoří nový objekt zprávy pro danou zprávu <code>key</code>.
Zbývající parametry jsou předány metodě <code>[[#mw.message:params|params()]]</code> nového objektu.

Objekt zprávy nemá žádné vlastnosti, ale má několik níže popsaných metod.

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

Vytvoří nový objekt zprávy pro dané zprávy (použije se první, který existuje).

Objekt zprávy nemá žádné vlastnosti, ale má několik níže popsaných metod.

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

Vytvoří nový objekt zprávy, který použije přímo daný text, místo aby vyhledával internacionalizovanou zprávu. Zbývající parametry jsou předány metodě <code>[[#mw.message:params|params()]]</code> nového objektu.

Objekt zprávy nemá žádné vlastnosti, ale má několik níže popsaných metod.

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

Zabalí hodnotu tak, aby nebyla analyzována jako wikitext pomocí <code>[[#mw.message:parse|msg:parse()]]</code>.

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

Zabalí hodnotu tak, aby byla automaticky naformátována jako <code>[[#mw.language:formatNum|lang:formatNum()]]</code>. Všimněte si, že to nezávisí na skutečně dostupné [[#Language library|knihovně jazyků]].

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

Vrátí jazykový objekt pro výchozí jazyk.

==== 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>

Přidá do zprávy parametry, které mohou být předány jako jednotlivé argumenty nebo jako [[#sequence|sekvenční]] tabulka. Parametry musí být čísla, řetězce nebo speciální hodnoty vrácené funkcí [[#mw.message.numParam|mw.message.numParam()]] nebo [[#mw.message.rawParam|mw.message.rawParam()]]. Pokud je použita sekvenční tabulka, parametry musí být přímo přítomny v tabulce. Odkazy používající [[#Metatables|__index metamethod]] nebudou fungovat.

Vrátí objekt <code>msg</code>, aby bylo umožněno řetězení hovorů.

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

Jako [[#mw.message:params|:params()]], ale má za následek předání všech parametrů nejprve přes [[#mw.message.rawParam|mw.message.rawParam()]].

Vrátí objekt <code>msg</code>, aby bylo umožněno řetězení hovorů.

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

Jako [[#mw.message:params|:params()]], ale má za následek předání všech parametrů nejprve přes [[#mw.message.numParam|mw.message.numParam()]].

Vrátí objekt <code>msg</code>, aby bylo umožněno řetězení hovorů.

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

Určuje jazyk, který se má použít při zpracování zprávy. <code>lang</code> může být řetězec nebo tabulka s metodou <code>getCode()</code> (tj. [[#Language library|Jazykový objekt]]).

Výchozí jazyk je ten, který vrací <code>[[#mw.message.getDefaultLanguage|mw.message.getDefaultLanguage()]]</code>.

Vrátí objekt <code>msg</code>, aby bylo umožněno řetězení hovorů.

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

Určuje, zda se mají vyhledávat zprávy v MediaWiki: Jmenný prostor (tj. hledat v databázi) nebo jen použít výchozí zprávy distribuované s MediaWiki.

Výchozí hodnota je {{luai|true}}.

Vrátí objekt <code>msg</code>, aby bylo umožněno řetězení hovorů.

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

Nahradí parametry a vrátí zprávu wikitext tak, jak je. Volání šablony a funkce analyzátoru jsou nedotčeny.

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

Vrátí boolean označující, zda klíč zprávy existuje.

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

Vrací logickou hodnotu označující, zda má klíč zprávy obsah. Vrátí hodnotu {{luai|true}}, pokud klíč zprávy neexistuje nebo je zpráva prázdný řetězec.

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

Vrátí logickou hodnotu označující, zda je klíč zprávy zakázán. Vrátí hodnotu {{luai|true}}, pokud klíč zprávy neexistuje nebo pokud je zpráva prázdný řetězec nebo řetězec "-".

<span id="Site_library"></span>
=== Knihovna stránek ===

==== mw.site.currentVersion ====
Řetězec obsahující aktuální verzi MediaWiki.

==== mw.site.scriptPath ====
Hodnota {{wg|ScriptPath}}.

==== mw.site.server ====
Hodnota {{wg|Server}}.

==== mw.site.siteName ====
Hodnota {{wg|Sitename}}.

==== mw.site.stylePath ====
Hodnota {{wg|StylePath}}.

==== mw.site.namespaces ====
Tabulka obsahující data pro všechny jmenné prostory, indexovaná podle čísla.

Dostupné údaje jsou:

* '''id''': Číslo jmenného prostoru.
* '''name''': Místní název jmenného prostoru.
* '''canonicalName''': Kanonický název jmenného prostoru.
* '''displayName''': Nastaveno na jmenný prostor 0, název, který se má použít pro zobrazení (protože název je často prázdný řetězec).
* '''hasSubpages''': Zda jsou pro jmenný prostor povoleny podstránky.
* '''hasGenderDistinction''': Zda má jmenný prostor různé aliasy pro různá pohlaví.
* '''isCapitalized''': Zda je první písmeno stránek v jmenném prostoru velké.
* '''isContent''': Zda se jedná o jmenný prostor obsahu.
* '''isIncludable''': Zda lze stránky v jmenném prostoru transkludovat.
* '''isMovable''': Zda lze v jmenném prostoru přesouvat stránky.
* '''isSubject''': Zda se jedná o předmětový jmenný prostor.
* '''isTalk''': Ať už se jedná o jmenný prostor pro diskuse.
* '''defaultContentModel''': Výchozí model obsahu pro jmenný prostor jako řetězec.
* '''aliases''': Seznam aliasů pro jmenný prostor.
* '''subject''': Odkaz na odpovídající data jmenného prostoru předmětu.
* '''talk''': Odkaz na odpovídající data jmenného prostoru diskuse.
* '''associated''': Odkaz na data souvisejícího jmenného prostoru.

Je také nastavena metatabulka, která umožňuje vyhledávat jmenné prostory podle názvu (lokalizovaného nebo kanonického). Například <code>mw.site.namespaces[4]</code> a <code>mw.site.namespaces.Project</code> vrátí informace o jmenném prostoru projektu.

==== mw.site.contentNamespaces ====
Tabulka obsahující pouze jmenné prostory obsahu, indexované podle čísla. Podrobnosti viz [[#mw.site.namespaces|mw.site.namespaces]].

==== mw.site.subjectNamespaces ====
Tabulka obsahující pouze obory názvů předmětů, indexované podle čísla. Podrobnosti viz [[#mw.site.namespaces|mw.site.namespaces]].

==== mw.site.talkNamespaces ====
Tabulka obsahující pouze jmenné prostory talk, indexované podle čísla. Podrobnosti viz [[#mw.site.namespaces|mw.site.namespaces]].

==== mw.site.stats ====
Tabulka statistiky webu. Dostupné statistiky jsou:

* '''pages''': Počet stránek na wiki.
* '''articles''': Počet článků na wiki.
* '''files''': Počet souborů na wiki.
* '''edits''': Počet úprav na wiki.
* '''users''': Počet uživatelů na wiki.
* '''activeUsers''': Počet aktivních uživatelů na wiki.
* '''admins''': Počet uživatelů ve skupině 'sysop' na wiki.


==== mw.site.stats.pagesInCategory ====
<code style="white-space:nowrap">mw.site.stats.pagesInCategory( kategorie, jaká )</code>

: {{red|Tato funkce je [[Special:MyLanguage/Manual:$wgExpensiveParserFunctionLimit|náročná]]}}

Získá statistiky o kategorii. Pokud má <code>jaká</code> speciální hodnotu "<code>*</code>", výsledkem je tabulka s následujícími vlastnostmi:

* '''all''': Celkový počet stránek, souborů a podkategorií.
* '''subcats''': Počet podkategorií.
* '''files''': Počet souborů.
* '''pages''': Počet stránek.

Pokud je <code>jaká</code> jedním z výše uvedených klíčů ("all", "subcats", "files", "pages"), výsledkem je číslo s odpovídající hodnotou.

Každá nová dotazovaná kategorie zvýší počet náročných funkcí.

==== mw.site.stats.pagesInNamespace ====
<code style="white-space:nowrap">mw.site.stats.pagesInNamespace( jmenný prostor )</code>

Vrátí počet stránek v daném jmenném prostoru (zadané číslem).

==== mw.site.stats.usersInGroup ====
<code style="white-space:nowrap">mw.site.stats.usersInGroup( skupina )</code>

Vrátí počet uživatelů v dané skupině.

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

Vrátí tabulku obsahující data o dostupných [[Special:MyLanguage/Manual:Interwiki|interwiki]] prefixech. Pokud je <code>filtr</code> řetězec "local", vrátí se pouze data pro místní předpony interwiki. Pokud je <code>filtr</code> řetězec "!local", vrátí se pouze data pro nelokální předpony. Pokud není zadán žádný filtr, vrátí se data pro všechny předpony. Předpona "local" v tomto kontextu je ta, která je pro stejný projekt. Například na anglické Wikipedii jsou jiné jazykové Wikipedie považovány za místní, zatímco Wikislovník a podobně nikoli.

Klíče v tabulce vrácené touto funkcí jsou interwiki předpony a hodnoty jsou podtabulky s následujícími vlastnostmi:


* '''prefix''' - předpona interwiki.
* '''url''' - URL, na kterou interwiki odkazuje. Název stránky je reprezentován parametrem $1.
* '''isProtocolRelative''' - boolean ukazující, zda je adresa URL [[w:Protocol-relative URL|protokolově relativní]].
* '''isLocal''' - zda je adresa URL pro web v aktuálním projektu.
* '''isCurrentWiki''' - zda je adresa URL pro aktuální wiki.
* '''isTranscludable''' - zda stránky používající tuto předponu interwiki jsou [[Transclusion|transcludable]]. To vyžaduje [[Special:MyLanguage/Manual:$wgEnableScaryTranscluding|náročnou transkluzi]], která je na wikinách Wikimedie zakázána.
* '''isExtraLanguageLink''' - zda je interwiki uvedena v {{wg|ExtraInterlanguageLinkPrefixes}}.
* '''displayText''' - pro odkazy uvedené v $wgExtraInterlanguageLinkPrefixes je to zobrazovaný text zobrazený pro mezijazykový odkaz. Není-li uvedeno, nula.
* '''tooltip'''  - pro odkazy uvedené v $wgExtraInterlanguageLinkPrefixes se jedná o text popisku, který se zobrazí, když uživatel najede na mezijazykový odkaz. Není-li uvedeno, nula.

<span id="Text_library"></span>
=== Textová knihovna ===

Textová knihovna poskytuje některé běžné funkce pro zpracování textu, které chybí v [[#String library|knihovně řetězců]] a [[#Ustring library|knihovně Ustring]]. Tyto funkce jsou bezpečné pro použití s řetězci UTF-8.

==== mw.text.decode ====
<code style="white-space:nowrap">mw.text.decode( řetězec )</code>
<br/>
<code style="white-space:nowrap">mw.text.decode( řetězec, dekódované pojmenované entity )</code>

Nahradí [[:en:HTML entities|entity HTML]] v řetězci odpovídajícími znaky.

Pokud je logická hodnota <code>decodeNamedEntities</code> vynechána nebo je nepravdivá, jsou rozpoznány pouze pojmenované entity <code>&amp;lt;</code> (<), <code>&amp;gt;</code> (>), <code>&amp;amp;</code> (&), <code>&amp;quot;</code> (") a <code>&amp;nbsp;</code> (nerozdělitelná mezera, U+00A0).
Jinak se seznam pojmenovaných entit HTML5 k rozpoznání načte z funkce [https://php.net/get_html_translation_table <code>get_html_translation_table</code>] PHP.

{{red|Známé chyby}}: Přibližně 600 z přibližně {{formatnum:2200}} pojmenovaných entit ve standardu HTML5 nelze dekódovat, i když jsou použity <code>decodeNamedEntities</code>. To zahrnuje přibližně 40 z přibližně 250 entit, které jsou také zahrnuty v HTML4.
K tomu dochází, protože funkce <code>get_html_translation_table</code> PHP vrací pouze jedno mapování pro každý znak, takže například {{code|lang=text|inline=1|&rarr;}} není dekódováno, protože PHP vrací pouze {{code|lang=text|inline=1|&srarr;}} jako mapování pro {{code|lang=text|inline=1|→}}.

==== mw.text.encode ====
<code style="white-space:nowrap">mw.text.encode( řetězec )</code>
<br/>
<code style="white-space:nowrap">mw.text.encode( řetězec, znaková sada )</code>

Nahradí znaky v řetězci [[w:HTML entities|HTML entity]].
Pět znaků je nahrazeno příslušnými pojmenovanými entitami: <code>&lt;</code>, <code>&gt;</code>, <code>&</code>, <code>"</code> a nerozdělitelná mezera (U+00A0).
Všechny ostatní jsou nahrazeny číselnými entitami.

Je-li zadána <code>charset</code>, měl by to být řetězec podle potřeby, který bude vložen do závorek ve [[#Ustring patterns|vzorech Ustring]], tj. "set" v <code>[set]</code>. Výchozí znaková sada obsahuje šest znaků: <code>&lt;</code>, <code>&gt;</code>, <code>&</code>, <code>"</code>, <code>'</code> a pevnou mezeru (U+00A0).

==== mw.text.jsonDecode ====
<code style="white-space:nowrap">mw.text.jsonDecode( řetězec )</code>
<br/>
<code style="white-space:nowrap">mw.text.jsonDecode( řetězec, příznaky )</code>

Dekóduje řetězec JSON. <code>flags</code> je 0 nebo kombinace (použijte <code>+</code>) příznaky <code>mw.text.JSON_PRESERVE_KEYS</code> a <code>mw.text.JSON_TRY_FIXING</code>.

Normálně jsou pole JSON založená na nule přečíslována na tabulky sekvencí založené na jedné Lua. Abyste tomu zabránili, předejte <code>mw.text.JSON_PRESERVE_KEYS</code>.

Chcete-li zmírnit určité požadavky v JSON, například žádné koncové čárky v polích nebo objektech, předejte <code>mw.text.JSON_TRY_FIXING</code>. To se nedoporučuje.

Omezení:

* Dekódovaná pole JSON nemusí být sekvencemi Lua, pokud pole obsahuje hodnoty null.
* Objekty JSON zahodí klíče s hodnotami null.
* Není možné přímo zjistit, zda vstupem bylo pole JSON nebo objekt JSON se sekvenčními celočíselnými klíči.
* Objekt JSON, který má sekvenční celočíselné klíče začínající 1, se dekóduje do stejné struktury tabulky jako pole JSON se stejnými hodnotami, přestože tyto nejsou vůbec ekvivalentní, pokud není použit <code>mw.text.JSON_PRESERVE_KEYS</code>.

==== mw.text.jsonEncode ====
<code style="white-space:nowrap">mw.text.jsonEncode( hodnota )</code>
<br/>
<code style="white-space:nowrap">mw.text.jsonEncode( hodnota, příznaky )</code>

Zakódujte řetězec JSON. Pokud nelze předávanou hodnotu zakódovat do JSON, dojde k chybám. <code>flags</code> jsou 0 nebo kombinace (použijte <code>+</code>) příznaků <code>mw.text.JSON_PRESERVE_KEYS</code> a <code>mw.text.JSON_PRETTY</code>.

Normálně jsou sekvenční tabulky založené na Lua jedné kódovány jako pole JSON založená na nule. Když je <code>mw.text.JSON_PRESERVE_KEYS</code> nastaveno v <code>flags</code>, nulové sekvenční tabulky jsou kódovány jako pole JSON.

Omezení:

* Prázdné tabulky jsou vždy kódovány jako prázdná pole (<code>[]</code>), nikoli prázdné objekty (<code>{}</code>).
* Sekvenční tabulky nelze kódovat jako objekty JSON bez přidání "fiktivního" prvku.
* Chcete-li vytvářet objekty nebo pole s nulovými hodnotami, je vyžadována složitá implementace metametody <code>__pairs</code>.
* Lua tabulka, která má sekvenční celočíselné klíče začínající 0, bude kódována jako pole JSON, stejně jako Lua tabulka s celočíselnými klíči začínajícími 1, pokud není použito <code>mw.text.JSON_PRESERVE_KEYS</code>.
* Když se jako klíče ve stejné tabulce použije číslo i řetězcová reprezentace tohoto čísla, chování není specifikováno.

==== mw.text.killMarkers ====
<code style="white-space:nowrap">mw.text.killMarkers( řetězec )</code>

Odebere všechny [[strip marker|značky stripu]] MediaWiki z řetězce.

==== mw.text.listToText ====
<code style="white-space:nowrap">mw.text.listToText( seznam )</code>
<br/>
<code style="white-space:nowrap">mw.text.listToText( seznam, oddělovač, spojka )</code>

Připojí se k seznamu ve stylu prózy. Jinými slovy, je to jako <code>[[#table.concat|table.concat()]]</code>, ale s jiným oddělovačem před poslední položkou.

Výchozí oddělovač je převzat z [[MediaWiki:comma-separator]] v jazyce obsahu wiki a výchozí spojka je [[MediaWiki:and]] zřetězená s [[MediaWiki:word-separator]].

Příklady s použitím výchozích hodnot pro zprávy:
<syntaxhighlight lang="lua">
 -- Vrátí prázdný řetězec
 mw.text.listToText( {} )
 
 -- Vrátí "1"
 mw.text.listToText( { 1 } )
 
 -- Vrátí "1 a 2"
 mw.text.listToText( { 1, 2 } )
 
 -- Vrátí "1, 2, 3, 4 a 5"
 mw.text.listToText( { 1, 2, 3, 4, 5 } )
 
 -- Vrátí "1; 2; 3; 4 nebo 5"
 mw.text.listToText( { 1, 2, 3, 4, 5 }, '; ', ' or ' )
</syntaxhighlight>

==== mw.text.nowiki ====
<code style="white-space:nowrap">mw.text.nowiki( řetězec )</code>

Nahradí různé znaky v řetězci [[w:HTML entities|HTML entity]], aby se zabránilo jejich interpretaci jako wikitextu. To zahrnuje:

* Následující znaky: <code>"</code>, <code>&</code>, <code>'</code>, <code><</code>, <code>=</code>, <code>></code>, <code>[</code>, <code>]</code>, <code>{</code>, <code>|</code>, <code>}</code>
* Následující znaky na začátku řetězce nebo bezprostředně za novým řádkem: <code>#</code>, <code>*</code>, <code>:</code>, <code>;</code>, space, tab (<code>\t</code>)
* Prázdné řádky budou mít jeden z přidružených znaků nového řádku nebo konce řádku
* <code>----</code> na začátku řetězce nebo bezprostředně po novém řádku budou mít první <code>-</code> escapované
* <code>__</code> bude mít jedno podtržítko unikající
* <code>://</code> bude mít dvojtečku uniklou
* Mezera následující za <code>ISBN</code>, <code>RFC</code> nebo <code>PMID</code> bude escapována

==== mw.text.split ====
<code style="white-space:nowrap">mw.text.split( řetězec, vzor, plain )</code>

Rozdělí řetězec na podřetězce na hranicích odpovídajících <code>pattern</code> [[#Ustring patterns|Ustring]]. Pokud je zadán <code>plain</code> a {{luai|true}}, bude <code>pattern</code> interpretován jako doslovný řetězec, nikoli jako vzor Lua (stejně jako u stejnojmenného parametru pro <code>[[#mw.ustring.find|mw.ustring.find()]]</code>). Vrátí tabulku obsahující podřetězce.

Například <code style="white-space:nowrap">mw.text.split( 'a b\tc\nd', '%s' )</code> vrátí tabulku <code style="white-space:nowrap">{ 'a', 'b', 'c', 'd' }</code>.

Pokud <code>pattern</code> odpovídá prázdnému řetězci, bude <code>string</code> rozdělen na jednotlivé znaky.

Všimněte si, že tato funkce může být více než 60krát pomalejší než reimplementace, která nepodporuje Unicode, jako například následující:

<syntaxhighlight lang="lua">
function split(text, pattern, plain)
    local ret = {}
    local s, l = 1, string.len( text )
    while s do
    	local e, n = string.find( text, pattern, s, plain )
    	if not e then
    		ret[#ret+1] = string.sub ( text, s )
    		s = nil
    	elseif n < e then
    		-- Empty separator!
    		ret[#ret+1] = string.sub ( text, s, e )
    		if e < l then
    			s = e + 1
    		else
    			s = nil
    		end
    	else
    		ret[#ret+1] = e > s and string.sub( text, s, e - 1 ) or ''
    		s = n + 1
    	end
    end
    return ret
end
</syntaxhighlight>

==== mw.text.gsplit ====
<code style="white-space:nowrap">mw.text.gsplit( řetězec, vzor, plain )</code>

Vrací funkci [[#iterators|iterátor]], která bude iterovat podřetězce, které by vrátilo ekvivalentní volání <code>[[#mw.text.split|mw.text.split()]]</code>.

Všimněte si, že tato funkce může být více než 60krát pomalejší než reimplementace, která nepodporuje Unicode, jako například následující:

<syntaxhighlight lang="lua">
function gsplit( text, pattern, plain )
	local s, l = 1, string.len( text )
	return function ()
		if s then
			local e, n = string.find( text, pattern, s, plain )
			local ret
			if not e then
				ret = string.sub( text, s )
				s = nil
			elseif n < e then
				-- Empty separator!
				ret = string.sub( text, s, e )
				if e < l then
					s = e + 1
				else
					s = nil
				end
			else
				ret = e > s and string.sub( text, s, e - 1 ) or ''
				s = n + 1
			end
			return ret
		end
	end, nil, nil
end
</syntaxhighlight>

==== mw.text.tag ====
<code style="white-space:nowrap">mw.text.tag( název, vlastnosti, obsah )</code>
<br/>
<code style="white-space:nowrap">mw.text.tag{ název = řetězec, vlastnosti = tabulka, obsah = řetězec|false }</code>

: ''Všimněte si použití [[#named arguments|pojmenovaných argumentů]].''

Vygeneruje značku ve stylu HTML pro <code>název</code>.

Pokud je zadáno <code>attrs</code>, musí to být tabulka s řetězcovými klíči. Řetězcové a číselné hodnoty se používají jako hodnota atributu. Boolean {{luai|true}} má za následek výstup klíče jako parametr bez hodnoty HTML5. Boolean {{luai|false}} klíč úplně přeskočí. A cokoli jiného je chyba.

Pokud není zadán <code>content</code> (nebo je nulový), vrátí se pouze úvodní značka. Pokud má <code>content</code> logickou hodnotu {{luai|false}}, vrátí se značka s automatickým uzavřením. V opačném případě to musí být řetězec nebo číslo, v takovém případě je obsah uzavřen ve vytvořeném otevíracím a uzavíracím tagu. Všimněte si, že obsah není automaticky kódován HTML. V případě potřeby použijte [[#mw.text.encode|mw.text.encode()]].

Chcete-li správně vracet značky rozšíření, jako je {{tag|ref|open}}, použijte místo toho [[#frame:extensionTag|frame:extensionTag()]].

==== mw.text.trim ====
<code style="white-space:nowrap">mw.text.trim( řetězec )</code>
<br/>
<code style="white-space:nowrap">mw.text.trim( řetězec, znaková sada )</code>

Odstraňte mezery nebo jiné znaky ze začátku a konce řetězce.

Je-li zadán <code>charset</code>, měl by to být řetězec, který se vejde do závorek ve [[#Ustring patterns|vzoru Ustring]], tj. "set" v <code>[set]</code>. Výchozí znaková sada je mezera ASCII, <code>%s</code>, což je ekvivalent <code style="white-space:nowrap">"\t\r\n\f\v "</code>.

==== mw.text.truncate ====
<code style="white-space:nowrap">mw.text.truncate( text, délka )</code>
<br/>
<code style="white-space:nowrap">mw.text.truncate( text, délka, vynechání )</code>
<br/>
<code style="white-space:nowrap">mw.text.truncate( text, délka, vynechání, upravit délku )</code>

Zkrátí <code>text</code> na zadanou délku v bodech kódu a přidá <code>ellipsis</code>, pokud bylo provedeno zkrácení. Pokud je délka kladná, bude konec řetězce zkrácen. Je-li záporná, začátek bude odstraněn. Pokud je zadáno <code>adjustLength</code> a {{luai|true}}, výsledný řetězec včetně vynechání nebude delší než zadaná délka.

Výchozí hodnota pro <code>ellipsis</code> je převzata z [[MediaWiki:ellipsis]] v jazyce obsahu wiki.

Příklady s použitím výchozího vynechání "...":

<syntaxhighlight lang="lua">
-- Vrátí "foobarbaz"
mw.text.truncate( "foobarbaz", 9 )

-- Vrátí "fooba"...
mw.text.truncate( "foobarbaz", 5 )

-- Vrátí "...arbaz"
mw.text.truncate( "foobarbaz", -5 )

-- Vrátí "foo"...
mw.text.truncate( "foobarbaz", 6, nil, true )

-- Vrátí "foobarbaz", protože je to kratší než "foobarba... "
mw.text.truncate( "foobarbaz", 8 )
</syntaxhighlight>

==== mw.text.unstripNoWiki ====
<code style="white-space:nowrap">mw.text.unstripNoWiki( řetězec )</code>

Nahrazuje MediaWiki &lt;nowiki&gt; [[strip marker|označení pruhu]] s odpovídajícím textem. Ostatní typy proužkových značek se nemění.

==== mw.text.unstrip ====
<code style="white-space:nowrap">mw.text.unstrip( řetězec )</code>

Ekvivalent <code style="white-space:nowrap">mw.text.killMarkers( mw.text.unstripNoWiki( string ))</code>.

Toto již neodhaluje HTML za speciální transkluzí stránky, tagy &lt;ref&gt; a tak dále, jako tomu bylo v dřívějších verzích Scriunto.

<span id="Title_library"></span>
=== Knihovna titulů ===

==== mw.title.equals ====
<code style="white-space:nowrap">mw.title.equals( a, b )</code>

Otestujte, zda jsou dva tituly stejné. Všimněte si, že fragmenty jsou při porovnávání ignorovány.

==== mw.title.compare ====
<code style="white-space:nowrap">mw.title.compare( a, b )</code>

Vrátí -1, 0 nebo 1 k označení, zda je titul <code>a</code> menší, rovný nebo větší než titul <code>b</code>.

To porovnává názvy podle předpony interwiki (pokud existuje) jako řetězců, poté podle čísla jmenného prostoru a poté podle textu názvu bez předpony jako řetězce. Tato porovnání řetězců používají standardní operátor Lua <code>&lt;</code>.

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

Vrátí objekt title pro aktuální stránku.

==== mw.title.new ====
<code style="white-space:nowrap">mw.title.new( text, jmenný prostor )</code>
<br/>
<code style="white-space:nowrap">mw.title.new( ID )</code>

: {{red|Tato funkce je [[Special:MyLanguage/Manual:$wgExpensiveParserFunctionLimit|náročná]], pokud je volána s ID}}

Vytvoří nový objekt titulku.

Pokud je zadáno číslo <code>ID</code>, vytvoří se objekt pro nadpis s tímto page_id. Odkazovaný titul bude považován za odkazovaný z aktuální stránky. Pokud page_id neexistuje, vrátí nulu. Počet drahých funkcí se zvýší, pokud vytvořený objekt title není pro titul, který již byl načten.

Pokud je místo toho zadán řetězec <code>text</code>, vytvoří se pro tento nadpis objekt (i když stránka neexistuje). Pokud textový řetězec neurčuje jmenný prostor, použije se <code>namespace</code> (což může být jakýkoli klíč nalezený v <code>[[#mw.site.namespaces|mw.site.namespaces]]</code>). Pokud text není platným názvem, vrátí se nula.

==== mw.title.makeTitle ====
<code style="white-space:nowrap">mw.title.makeTitle( jmenný prostor, title, fragment, interwiki )</code>

Vytvoří objekt title s title <code>title</code> ve jmenném prostoru <code>namespace</code>, volitelně se zadanou předponou <code>fragment</code> a <code>interwiki</code>. <code>namespace</code> může být jakýkoli klíč nalezený v <code>[[#mw.site.namespaces|mw.site.namespaces]]</code>. Pokud výsledný název není platný, vrátí hodnotu nula.

Všimněte si, že na rozdíl od <code>[[#mw.title.new|mw.title.new()]]</code> tato metoda vždy použije zadaný jmenný prostor. Například <code style="white-space:nowrap">mw.title.makeTitle( 'Template', 'Module:Foo' )</code> vytvoří objekt pro stránku Template:Module:Foo, zatímco <code style="white-space:nowrap">mw.title.new( 'Module:Foo', 'Template' )</code> vytvoří objekt pro stránku Module:Foo.

Všimněte si také, že funkčnost pro titulky interwiki je omezena na <code>interwiki</code> / <code>isExternal</code> / <code>isLocal</code> a metody související s URL. Jiné metody se nemusí chovat podle očekávání.

<span id="Title_objects"></span>
==== Objekty titulků ====

Objekty titulků mají řadu vlastností a metod. Většina vlastností je pouze pro čtení.

Všimněte si, že pole končící na <code>text</code> vracejí názvy jako řetězcové hodnoty, zatímco pole končící na <code>title</code> vracejí názvy objektů.

* '''id''': page_id. <code>0</code>, pokud stránka neexistuje. {{red|1=Toto [[#Expensive properties|může být náročné]]}}.
* '''interwiki''': Předpona interwiki nebo prázdný řetězec, pokud neexistuje.
* '''namespace''': Číslo jmenného prostoru.
* '''fragment''': Fragment (aka propojení sekce/kotvy) nebo prázdný řetězec. Může být přiděleno.
* '''nsText''': Text jmenného prostoru stránky.
* '''subjectNsText''': Text jmenného prostoru předmětu pro stránku.
* '''talkNsText''': Text diskusního jmenného prostoru pro stránku, nebo <code>nil</code>, pokud tento titul nemůže mít diskusní stránku. <small>(přidáno v MediaWiki 1.42.0-wmf.15, odkazy [[phab:T180911|T180911]])</small>
* '''text''': Název stránky, bez jmenného prostoru nebo interwiki předpon.
* '''prefixedText''': Název stránky se jmenným prostorem a předponami interwiki.
* '''fullText''': Název stránky se jmenným prostorem a předponami interwiki a fragmentem. Interwiki není vrácena, pokud je rovno aktuální.
* '''rootText''': Pokud se jedná o podstránku, název kořenové stránky bez předpon. Jinak stejné jako <code>title.text</code>.
* '''baseText''': Pokud se jedná o podstránku, název stránky je podstránkou bez prefixů. Jinak stejné jako <code>title.text</code>.
* '''subpageText''': Pokud se jedná o podstránku, pouze název podstránky. Jinak stejné jako <code>title.text</code>.
* '''canTalk''': Zda stránka pro tento titul může mít diskusní stránku.
* '''exists''': Zda stránka existuje. Alias pro <code>file.exists</code> pro názvy mediálního jmenného prostoru. U názvů oboru názvů souborů to kontroluje existenci stránky popisu souboru, nikoli samotného souboru. {{red|Toto [[#Expensive properties|může být náročné]]}}.
* '''file''', '''fileExists''': Viz [[#File metadata|#Metadata souboru]] níže.
* '''isContentPage''': Zda je tento titul v jmenném prostoru obsahu.
* '''isExternal''': Zda má tento název předponu interwiki.
* '''isLocal''': Zda je tento titul součástí tohoto projektu. Například na anglické Wikipedii je jakákoli jiná Wikipedie považována za "místní", zatímco Wikislovník a podobně nikoli.
* '''isRedirect''': Zda se jedná o název stránky, která je přesměrována. {{red|Toto [[#Expensive properties|může být náročné]]}}.
* '''isSpecialPage''': Zda se jedná o název možné speciální stránky (tj. stránky ve jmenném prostoru Special:).
* '''isSubpage''': Zda je tento titul podstránkou jiného titulu.
* '''isTalkPage''': Zda se jedná o název diskusní stránky.
* '''isSubpageOf( title2 )''': Zda je tento titul podstránkou daného titulu.
* '''inNamespace( ns )''': Zda je tento název v daném jmenném prostoru. Jmenné prostory mohou být specifikovány čímkoli, co je klíčem nalezeným v <code>[[#mw.site.namespaces|mw.site.namespaces]]</code>.
* '''inNamespaces( ... )''': Zda je tento název v některém z daných jmenných prostorů. Jmenné prostory mohou být specifikovány čímkoli, co je klíčem nalezeným v <code>[[#mw.site.namespaces|mw.site.namespaces]]</code>.
* '''hasSubjectNamespace( ns )''': Zda je předmětný jmenný prostor tohoto titulu v daném jmenném prostoru. Jmenné prostory mohou být specifikovány čímkoli, co je klíčem nalezeným v <code>[[#mw.site.namespaces|mw.site.namespaces]]</code>.
* '''contentModel''': Model obsahu pro tento titul jako řetězec. U stránky, která neexistuje, by tento model obsahu obdržela při vytvoření. {{red|Toto [[#Expensive properties|může být náročné]]}}.
<includeonly>* '''pageLang''': Jazyk stránky pro tento titul jako jazykový objekt podobný výchozímu vrácenému z <code>[[#mw.language.getContentLanguage|mw.language.getContentLanguage]]</code>, ale specifický pro tuto stránku. {{red|Toto [[#Expensive properties|může být máročné]]}}.</includeonly>
* '''basePageTitle''': Stejné jako <code style="white-space:nowrap">mw.title.makeTitle( title.namespace, title.baseText )</code>.
* '''rootPageTitle''': Stejné jako <code style="white-space:nowrap">mw.title.makeTitle( title.namespace, title.rootText )</code>.
* '''talkPageTitle''': Stejné jako <code style="white-space:nowrap">mw.title.makeTitle( mw.site.namespaces[title.namespace].talk.id, title.text )</code> nebo <code>nil</code>, pokud tento titul nemůže mít diskusní stránku.
* '''subjectPageTitle''': Stejné jako <code style="white-space:nowrap">mw.title.makeTitle( mw.site.namespaces[title.namespace].subject.id, title.text )</code>.
* '''redirectTarget:''' Vrátí objekt title cíle přesměrované stránky, pokud je stránka přesměrována a stránka existuje, jinak vrátí {{luai|false}}.
* '''protectionLevels''': Úrovně ochrany stránky. Toto je tabulka s klávesami odpovídajícími každé akci (např. <code>"edit"</code> a <code>"move"</code>). Hodnoty tabulky jsou pole, jejichž první položkou je řetězec obsahující úroveň ochrany. Pokud stránka není chráněna, budou buď hodnoty tabulky nebo položky pole <code>nil</code>. {{red|Toto je [[Special:MyLanguage/Manual:$wgExpensiveParserFunctionLimit|náročné]]}}.
* '''cascadingProtection''': Kaskádové ochrany použitelné pro stránku. Toto je tabulka s klíči <code>"restrictions"</code> (sama tabulka s klíči jako má <code>protectionLevels</code>) a <code>"sources"</code> (pole s názvy, kde kaskáda ochran). Pokud se na stránku nehrnou žádná ochranná kaskáda, budou <code>"restrictions"</code> a <code>"sources"</code> prázdné. {{red|Toto je [[Special:MyLanguage/Manual:$wgExpensiveParserFunctionLimit|náročné]]}}.
* '''categories''': ''(od v1.43.0-wmf.18)'' Seznam kategorií použitých na stránce. {{red|Toto je [[Special:MyLanguage/Manual:$wgExpensiveParserFunctionLimit|drahé]]}}
* '''subPageTitle( text )''': Stejné jako <code style="white-space:nowrap">mw.title.makeTitle( title.namespace, title.text .. '/' .. <var>text</var> )</code>.
* '''partialUrl()''': Vrací <code>title.text</code> zakódovaný tak, jako by byl v adrese URL.
* '''fullUrl( dotaz, proto )''': Vrátí úplnou adresu URL (s volitelnou tabulkou dotazu/řetězcem) pro tento nadpis. <var>proto</var> lze zadat pro ovládání schématu výsledné adresy URL: <code>"http"</code>, <code>"https"</code>, <code>"relative"</code> (výchozí) nebo <code>"canonical"</code>.
* '''localUrl( dotaz )''': Vrátí místní adresu URL (s volitelnou tabulkou/řetězcem dotazu) pro tento nadpis.
* '''canonicalUrl( dotaz )''': Vrátí kanonickou adresu URL (s volitelnou tabulkou/řetězcem dotazu) pro tento nadpis.
* '''content''' nebo '''getContent()''': Vrátí (neanalyzovaný) obsah stránky nebo <code>nil</code>, pokud stránka neexistuje. Stránka bude zaznamenána jako transkluze.
* '''pageLang''': [[#Language library|jazykový objekt]] pro [[Special:MyLanguage/Manual:Language#Page content language|jazyk obsahu stránky]], který je výchozím jazykem obsahu wiki. {{red|Toto je [[Special:MyLanguage/Manual:$wgExpensiveParserFunctionLimit|náročné]]}}.

Objekty titulků lze porovnávat pomocí [[#Relational operators|relačních operátorů]]. <code style="white-space:nowrap">[[#tostring|tostring]]( title )</code> vrátí <code>title.prefixedText</code>.

Všimněte si, že přístup k jakémukoli [[#Expensive properties|náročnému]] poli na objektu title zaznamená "odkaz" na stránku (jak je ukázáno například na [[Special:WhatLinksHere]]). Pomocí metody <code>getContent()</code> objektu title nebo přístupu k poli <code>redirectTarget</code> jej zaznamenáte jako pole <code>file</code> nebo <code>fileExists</code> jej zaznamená jako "{{int|isimage}}".

<span id="File_metadata"></span>
===== Metadata souboru =====

Objekty titulků představující stránku v oboru názvů File nebo Media budou mít vlastnost nazvanou <code>file</code>. {{red|Toto je [[Special:MyLanguage/Manual:$wgExpensiveParserFunctionLimit|náročné]].}} Toto je tabulka s následující strukturou:

* '''exists''' (existuje): Zda soubor existuje. Bude zaznamenáno jako použití snímku. Vlastnost <code>fileExists</code> na objektu Title existuje z důvodů zpětné kompatibility a je aliasem této vlastnosti. Pokud je {{luai|false}}, všechny ostatní vlastnosti souboru budou <code>nil</code>.
* '''width''': Šířka souboru. Pokud soubor obsahuje více stránek, jedná se o šířku první stránky.
* '''height''': Výška souboru. Pokud soubor obsahuje více stránek, jedná se o výšku první stránky.
* '''stránky''': Pokud formát souboru podporuje více stránek, jedná se o tabulku obsahující tabulky pro každou stránku souboru; jinak je <code>nil</code>. [[#Length operator|Operátor #]] lze použít k získání počtu stránek v souboru. Každá jednotlivá tabulka stránek obsahuje vlastnost width a height.
* '''size''': Velikost souboru v bajtech.
* '''mimeType''': [[w:MIME typ|Typ MIME]] souboru.
* '''length''': Délka (trvání) mediálního souboru v sekundách. Nula pro typy médií, které nepodporují délku.

<span id="Expensive_properties"></span>
===== Vlastnosti expensive =====

Vlastnosti <code>id</code>, <code>isRedirect</code>, <code>exists</code> a <code>contentModel</code> vyžadují načtení dat o titulu z databáze. Z tohoto důvodu je [[Special:MyLanguage/Manual:$wgExpensiveParserFunctionLimit|počet expensive (nákladných, náročných) funkcí]] zvýšen při prvním přístupu k jedné z nich pro jinou než aktuální stránku. Následné přístupy k jakékoli z těchto vlastností pro danou stránku znovu nezvýší počet expensive funkcí.

Ostatní vlastnosti označené jako expensive budou vždy zvyšovat počet expensive funkcí při prvním přístupu na jinou než aktuální stránku.

<span id="URI_library"></span>
=== Knihovna URI ===

==== mw.uri.encode ====
<code style="white-space:nowrap">mw.uri.encode( řetěz, enctype )</code>

[[w:Percent-encoding|Kóduje v procentech]] řetězec. Výchozí typ, <code>"QUERY"</code>, kóduje mezery pomocí '+' pro použití v řetězcích dotazů. <code>"PATH"</code> kóduje mezery jako %20. A <code>"WIKI"</code> kóduje mezery jako '_'.

Všimněte si, že formát "WIKI" není zcela reverzibilní, protože mezery i podtržítka jsou kódovány jako '_'.

==== mw.uri.decode ====
<code style="white-space:nowrap">mw.uri.decode( řetěz, enctype )</code>

[[w:Percent-encoding|Procento dekódování]] řetězce. Výchozí typ, <code>"QUERY"</code>, dekóduje '+' na mezeru. <code>"PATH"</code> neprovádí žádné další dekódování. A <code>"WIKI"</code> dekóduje '_' do prostoru.

==== mw.uri.anchorEncode ====
<code style="white-space:nowrap">mw.uri.anchorEncode( řetězec )</code>

Kóduje řetězec pro použití ve fragmentu URI MediaWiki.

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

Kóduje tabulku jako řetězec dotazu URI. Klíče by měly být řetězce. Hodnoty mohou být řetězce nebo čísla, sekvenční tabulky nebo logická nepravda.

==== mw.uri.parseQueryString ====
<code style="white-space:nowrap">mw.uri.parseQueryString( s, i, j )</code>

Dekóduje řetězec dotazu <code>s</code> do tabulky. Klíče v řetězci bez hodnot budou mít hodnotu {{luai|false}}. Klíče opakované vícekrát budou mít jako hodnoty sekvenční tabulky. A další budou mít řetězce jako hodnoty.

Volitelné číselné argumenty <code>i</code> a <code>j</code> lze použít k určení podřetězce <code>s</code>, který má být analyzován, namísto celého řetězce. <code>i</code> je pozice prvního znaku podřetězce a výchozí hodnota je 1. <code>j</code> je pozice posledního znaku podřetězce a výchozí hodnota je délka řetězce. Jak <code>i</code>, tak <code>j</code> mohou být záporné, jako v [[#string.sub|string.sub]].

==== mw.uri.canonicalUrl ====
<code style="white-space:nowrap">mw.uri.canonicalUrl( stránka, dotaz )</code>

Vrátí [[#URI object|objekt URI]] pro [[Special:MyLanguage/Help:Magic words#URL data|kanonické URL]] stránky s volitelným řetězcem dotazu/tabulkou.

==== mw.uri.fullUrl ====
<code style="white-space:nowrap">mw.uri.fullUrl( stránka, dotaz )</code>

Vrátí [[#URI object|objekt URI]] pro [[Special:MyLanguage/Help:Magic words#URL data|úplnou adresu URL]] stránky s volitelným řetězcem dotazu/tabulkou.

==== mw.uri.localUrl ====
<code style="white-space:nowrap">mw.uri.localUrl( stránka, dotaz )</code>

Vrátí [[#URI object|objekt URI]] pro [[Special:MyLanguage/Help:Magic words#URL data|místní URL]] pro stránku s volitelným řetězcem dotazu/tabulkou.

==== mw.uri.new ====
<code style="white-space:nowrap">mw.uri.new( řetězec )</code>

Vytvoří nový [[#URI object|objekt URI]] pro předaný řetězec nebo tabulku. Možná pole pro tabulku naleznete v popisu objektů URI.

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

Ověřuje předanou tabulku (nebo objekt URI). Vrátí logickou hodnotu označující, zda byla tabulka platná, a při selhání řetězec vysvětlující nalezené problémy.

<span id="URI_object"></span>
==== Objekt URI ====

Objekt URI má následující pole, z nichž některá nebo všechna mohou být nulová:

* '''protocol''': Řetězec protokolu/schématu
* '''user''': Řetězec uživatele
* '''password''': Řetězec hesla
* '''host''': Řetězec názvu hostitle
* '''port''': Celé číslo portu
* '''path''': Řetězec cesyty
* '''query''': Tabulka jako od [[#mw.uri.parseQueryString|mw.uri.parseQueryString]]
* '''fragment''': Řetezec fragmentu.

K dispozici jsou také následující vlastnosti:
* '''userInfo''': Řetězec uživatele a hesla
* '''hostPort''': Řetězec hostitele a portu
* '''authority''': Řetězec uživatele, hesla, hostitele a portu
* '''queryString''': Řetězec verze tabulky dotazu
* '''relativePath''': Řetězec cesty, řetězec dotazu a fragmentu

[[#tostring|<code>tostring()</code>]] poskytne řetězec URI.

Metody objektu URI jsou:

===== mw.uri:parse =====
<code style="white-space:nowrap">uri:parse( řetězec )</code>

Analyzuje řetězec do aktuálního objektu URI. Jakákoli pole zadaná v řetězci budou v aktuálním objektu nahrazena. Pole, která nejsou specifikována, si zachovají své staré hodnoty.

===== mw.uri:clone =====
<code>uri:clone()</code>

Vytvoří kopii objektu URI.

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

Sloučí tabulku parametrů do tabulky dotazu objektu.

<span id="Ustring_library"></span>
=== Knihovna Ustring ===

Knihovna Ustring je zamýšlena jako přímá reimplementace standardní [[#String library|String knihovny]], kromě toho, že metody pracují se znaky v řetězcích kódovaných $1 spíše než s byty.

Většina funkcí vyvolá chybu, pokud řetězec není platný UTF-8. Jsou zaznamenány výjimky.

==== mw.ustring.maxPatternLength ====
Maximální povolená délka vzoru v bajtech.

==== mw.ustring.maxStringLength ====
Maximální povolená délka řetězce v bajtech.

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

Vrátí jednotlivé bajty. Identické se [[#string.byte|string.byte()]].

==== mw.ustring.byteoffset ====
<code style="white-space:nowrap">mw.ustring.byteoffset( s, l, i )</code>

Vrátí bajtový posun znaku v řetězci. Výchozí hodnota pro <code>l</code> i <code>i</code> je 1. <code>i</code> může být záporná, v takovém případě se počítá od konce řetězce.

Znak na <code>l</code> == 1 je první znak začínající na nebo po bajtu <code>i</code>. Znak na <code>l</code> == 0 je první znak začínající na nebo před byte <code>i</code>. Všimněte si, že se může jednat o stejný znak. Větší nebo menší hodnoty <code>l</code> se vypočítávají vzhledem k těmto hodnotám.

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

Podobně jako [[#string.char|string.char()]], až na to, že celá čísla jsou kódové body Unicode, nikoli hodnoty bajtů.

<syntaxhighlight lang="lua">
local value = mw.ustring.char( 0x41f, 0x440, 0x438, 0x432, 0x435, 0x442, 0x21 ) -- hodnota je nyní 'Привет!'
</syntaxhighlight>

==== mw.ustring.codepoint ====
<code style="white-space:nowrap">mw.ustring.codepoint( s, i, j )</code>

Podobně jako [[#string.byte|string.byte()]], až na to, že návratové hodnoty jsou kódové body a offsety jsou znaky, nikoli bajty.

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

Podobně jako [[#string.find|string.find()]], až na to, že vzor je rozšířen tak, jak je popsáno ve [[#Ustring patterns|vzorech Ustring]] a offset <code>init</code> je ve znacích, nikoli v bajtech.

==== mw.ustring.format ====
<code style="white-space:nowrap">mw.ustring.format( formát, ... )</code>

Identické se [[#string.format|string.format()]]. Šířky a přesnosti řetězců jsou vyjádřeny v bajtech, nikoli v kódových bodech.

==== mw.ustring.gcodepoint ====
<code style="white-space:nowrap">mw.ustring.gcodepoint( s, i, j )</code>

Vrátí tři hodnoty pro iteraci přes kódové body v řetězci. Výchozí hodnota <code>i</code> je 1 a <code>j</code> je -1. Toto je určeno pro použití ve [[#iterators|iterátoru ve formě <code>for</code>]]:

<syntaxhighlight lang="lua">
for codepoint in mw.ustring.gcodepoint( s ) do
     -- blok
end
</syntaxhighlight>

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

Podobně jako [[#string.gmatch|string.gmatch()]], kromě toho, že vzor je rozšířen tak, jak je popsáno ve [[#Ustring patterns|vzorech Ustring]].

{{red|Known bug}} - Při použití se vzorem, který může odpovídat prázdnému řetězci, funkce uvízne v nekonečné smyčce. Například následující smyčka nikdy nekončí:

<syntaxhighlight lang="lua">
for capture in mw.ustring.gmatch( "foo bar", ".*" ) do
     -- block
end
</syntaxhighlight>

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

Podobně jako [[#string.gsub|string.gsub()]], kromě toho, že vzor je rozšířen tak, jak je popsáno ve [[#Ustring patterns|vzorech Ustring]].

{{red|Známé chyby}}: Pokud je <code>repl</code> tabulka, je možné použít čísla jako klíče místo řetězců (např. pro nahrazení instancí {{code|lang=lua|inline=1|"5"}} v řetězci by se použila hodnota v klíči {{code|lang=lua|inline=1|[5]}} nebo {{code|lang=lua|inline=1|["5"]}}). Jako takový není výstup předvídatelný, pokud mají různé (nenulové) hodnoty.
Toto není problém pro [[#string.gsub|string.gsub()]], který ignoruje jakákoli čísla jako klíče.

==== mw.ustring.isutf8 ====
<code style="white-space:nowrap">mw.ustring.isutf8( řetězec )</code>

Vrátí {{luai|true}}, pokud je řetězec platný UTF-8, a {{luai|false}}, pokud platný není.

==== mw.ustring.len ====
<code style="white-space:nowrap">mw.ustring.len( řetězec )</code>

Vrátí délku řetězce v kódových bodech nebo nulu, pokud řetězec není platný UTF-8.

Viz [[#string.len|string.len()]] pro podobnou funkci, která používá bajtovou délku spíše než kódové body.

==== mw.ustring.lower ====
<code style="white-space:nowrap">mw.ustring.lower( řetězec )</code>

Podobně jako [[#string.lower|string.lower()]], kromě toho, že všechny znaky s definicemi malých písmen na velká v Unicode jsou převedeny.

Pokud je také načtena [[#Language library|jazyková]] knihovna, místo toho se zavolá [[#mw.language:lc|lc()]] na výchozí jazykový objekt.

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

Podobně jako [[#string.match|string.match()]], až na to, že vzor je rozšířen tak, jak je popsáno v [[#Ustring patterns|Ustring vzory]] a offset <code>init</code> je ve znacích, nikoli v bajtech.

==== mw.ustring.rep ====
<code style="white-space:nowrap">mw.ustring.rep( řetězec, n )</code>

Totožné se [[#string.rep|string.rep()]].

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

Podobně jako [[#string.sub|string.sub()]], až na to, že offsety jsou spíše znaky než bajty.

==== mw.ustring.toNFC ====
<code style="white-space:nowrap">mw.ustring.toNFC( řetězec )</code>

Převede řetězec na [[:en:Normalization Form C|Normalization Form C]] (také známý jako Normalization Form Canonical Composition (Normalizační forma kanonické skladby)). Vrátí nulu, pokud řetězec není platný UTF-8.

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

Převede řetězec na [[w:Normalization Form D|Normalization Form D]] (také známý jako Normalization Form Canonical Decomposition). Vrátí nulu, pokud řetězec není platný UTF-8.

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

Převede řetězec na [[w:Normalization Form KC|Normalization Form KC]] (také známý jako Normalizační Form Compatibility Composition). Vrátí nulu, pokud řetězec není platný UTF-8.

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

Převede řetězec na [[w:Normalization Form KD|Normalization Form KD]] (také známý jako Normalization Form Compatibility Decomposition). Vrátí nulu, pokud řetězec není platný UTF-8.

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

Podobně jako [[#string.upper|string.upper()]], až na to, že všechny znaky s definicemi velkých písmen na malá v Unicode jsou převedeny.

Pokud je také načtena knihovna [[#Language library|Language library]], místo toho se na objektu výchozího jazyka zavolá [[#mw.language:uc|uc()]].

<span id="Ustring_patterns"></span>
==== Vzory Ustring ====

Vzory ve funkcích ustring používají stejnou syntaxi jako vzory knihovny [[#Patterns|String]]. Hlavním rozdílem je, že třídy znaků jsou předefinovány z hlediska [[w:Unicode character property|znakových vlastností Unicode]]:

* '''<code>%a</code>''': Představuje všechny znaky s obecnou kategorií "Letter" (písmeno).
* '''<code>%c</code>''': Představuje všechny znaky s obecnou kategorií "Control" (ovládání).
* '''<code>%d</code>''': Představuje všechny znaky s obecnou kategorií "Number, decimal digit" (číslo, desetinná číslice).
* '''<code>%l</code>''': Představuje všechny znaky s obecnou kategorií "Lowercase Letter" (malé písmeno).
* '''<code>%p</code>''': Představuje všechny znaky s obecnou kategorií "Punctuation" (interpunkce).
* '''<code>%s</code>''': Představuje všechny znaky s obecnou kategorií "Separator" (oddělovač), plus tabulátor, odřádkování, návrat vozíku, svislý tabulátor a posun formuláře.
* '''<code>%u</code>''': Představuje všechny znaky s obecnou kategorií "Uppercase Letter" (velká písmena).
* '''<code>%w</code>''': Představuje všechny znaky s obecnou kategorií "Letter" (písmeno) nebo "Decimal Number" (desetinné číslo).
* '''<code>%x</code>''': přidává verze hexadecimálních číslic s plnou šířkou.

Stejně jako ve [[#Patterns|vzorech knihovny String]] zde '''<code>%A</code>''', '''<code>%C</code>''', '''<code>%D</code>''', '''<code>%L</code>''', '''<code>%P</code>''', '''<code>%S</code>''', '''<code>%U</code>''', '''<code>%W</code>'''{{int|and}}{{int|word-separator}}'''<code>%X</code>''' představuje komplementární sadu ("všechny znaky ''bez'' dané obecné kategorie").

Ve všech případech jsou znaky interpretovány jako znaky Unicode namísto bajtů, takže rozsahy jako <code>[０-９]</code>, vzory jako <code>%b«»</code> a kvantifikátory použité na vícebajtové znaky budou fungovat správně. Prázdné zachycení zachytí pozici v bodech kódu spíše než v bajtech.

{{red|Známá omezení}}: Na rozdíl od [[#Patterns|vzorů knihovny String]] mají vzory knihovny Ustring maximální délku 10 000 bajtů. Pokud vzor překročí tuto délku, funkce Ustring vyvolá chybu. Protože knihovna String má své vlastní maximum 32 záchytů (na rozdíl od knihovny Ustring), není možné použít vzor, který překračuje oba limity, protože bude nekompatibilní s oběma knihovnami.

{{red|Poznámka}}: 9 znaků ASCII, '''<code>$</code>''', '''<code>+</code>''', '''<code>&lt;</code>''', '''<code>=</code>''', '''<code>&gt;</code>'' ', '''<code>^</code>''', '''<code>`</code>''', '''<code>|</code>''', '''<code>~</code>''', mohou odpovídat '''<code>%p</code>''' v knihovně String, ale ne v knihovně Ustring, protože Unicode je spíše klasifikuje jako symboly než interpunkci.

<span id="Loadable_libraries"></span>
== Načítatelné knihovny ==

Tyto knihovny nejsou standardně zahrnuty, ale v případě potřeby je lze načíst pomocí <code>[[#require|require()]]</code>.

=== bit32 ===

Tuto emulaci knihovny Lua 5.2 <code>bit32</code> lze načíst pomocí:

<syntaxhighlight lang="lua">
 bit32 = require( 'bit32' )
</syntaxhighlight>

Knihovna bit32 poskytuje [[w:Bitwise operation|bitové operace]] na 32bitových celých číslech bez znaménka. Vstupní čísla jsou zkrácena na celá čísla (nespecifikovaným způsobem) a redukována modulem 2<sup>32</sup>, takže hodnota je v rozsahu 0 až 2<sup>32</sup>−1. Návratové hodnoty jsou také v tomto rozsahu.

Když jsou bity číslovány (jako v [[#bit32.extract|bit32.extract()]]), 0 je nejméně významný bit (ten s hodnotou 2<sup>0</sup>) a 31 je nejvýznamnější (ten s hodnotou 2<sup>31</sup>).

==== bit32.band ====
<code style="white-space:nowrap">bit32.band( ... )</code>

Vrátí [[w:Bitwise operation#AND|bitové AND]] svých argumentů: Výsledek má bit nastavený pouze v případě, že je tento bit nastaven ve všech argumentech.

Pokud jsou zadány nulové argumenty, výsledek má nastaveny všechny bity.

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

Vrátí [[w:Bitwise operation#NOT|bitové NOT]] <code>x</code>.

==== bit32.bor ====
<code style="white-space:nowrap">bit32.bor( ... )</code>

Vrátí [[w:Bitwise operation#OR|bitové OR]] svých argumentů: Výsledek má nastavený bit, pokud je tento bit nastaven v některém z argumentů.

Pokud jsou zadány nulové argumenty, výsledek má všechny bity čisté.

==== bit32.btest ====
<code style="white-space:nowrap">bit32.btest( ... )</code>

Ekvivalent k <code style="white-space:nowrap">bit32.band( ... ) ~= 0</code>

==== bit32.bxor ====
<code style="white-space:nowrap">bit32.bxor( ... )</code>

Vrátí [[w:Bitwise operation#XOR|bitové XOR]] svých argumentů: Výsledek má nastavený bit, pokud je tento bit nastaven v lichém počtu argumentů.

Pokud jsou zadány nulové argumenty, výsledek má všechny bity prázdné.

==== bit32.extract ====
<code style="white-space:nowrap">bit32.extract( n, pole, šířka )</code>

Extrahuje bity <code>šířka</code> z <code>n</code>, počínaje bitem <code>pole</code>. Přístup k bitům mimo rozsah 0 až 31 je chyba.

Pokud není zadáno, výchozí hodnota pro <code>šířku</code> je 1.

==== bit32.replace ====
<code style="white-space:nowrap">bit32.replace( n, v, pole, šířka )</code>

Nahrazuje <code>šířku</code> bity v <code>n</code>, počínaje bitem <code>pole</code>, s nízkými bity <code>šířky</code> z <code>v</code>. Přístup k bitům mimo rozsah 0 až 31 je chyba.

Pokud není zadáno, výchozí hodnota pro <code>šířku</code> je 1.

==== bit32.lshift ====
<code style="white-space:nowrap">bit32.lshift( n, disp )</code>

Vrátí číslo <code>n</code> [[w:Bitwise operation#Bit shifts|posunutí]] o <code>disp</code> bitů doleva. Toto je [[w:Logický posun|logický posun]]: Vložené bity jsou 0. To je obecně ekvivalentní násobek 2<sup><code>disp</code></sup>.

Všimněte si, že posunutí nad 31 bude mít za následek 0.

==== bit32.rshift ====
<code style="white-space:nowrap">bit32.rshift( n, disp )</code>

Vrátí číslo <code>n</code> [[w:Bitwise operation#Bit shifts|posunutí]] o <code>disp</code> bitů doprava. Toto je [[w:Logical shift|logický posun]]: Vložené bity jsou 0. To je obecně ekvivalentní dělení 2<sup><code>disp</code></sup>.

Všimněte si, že posunutí nad 31 bude mít za následek 0.

==== bit32.arshift ====
<code style="white-space:nowrap">bit32.arshift( n, disp )</code>

Vrátí číslo <code>n</code> posunuté <code>disp</code> bitů doprava. Toto je [[w:Arithmetic shift|aritmetický posun]]: Pokud je <code>disp</code> kladné, vložené bity budou stejné jako bit 31 v původním čísle.

Všimněte si, že posunutí nad 31 bude mít za následek 0 nebo 4294967295.

==== bit32.lrotate ====
<code style="white-space:nowrap">bit32.lrotate( n, disp )</code>

Vrátí číslo <code>n</code> [[w:Bitwise operation#Rotate no carry|otočení]] <code>disp</code> bitů doleva.

Všimněte si, že rotace jsou ekvivalentní modulu 32: Rotace 32 je stejná jako rotace 0, 33 je stejná jako 1 a tak dále.

==== bit32.rrotate ====
<code style="white-space:nowrap">bit32.rrotate( n, disp )</code>

Vrátí číslo <code>n</code> [[w:Bitová operace#Rotate no carry|otočení]] o <code>disp</code> bitů doprava.

Všimněte si, že rotace jsou ekvivalentní modulu 32: Rotace 32 je stejná jako rotace 0, 33 je stejná jako 1 a tak dále.

<span id="libraryUtil"></span>
=== knihovna Util ===

Tato knihovna obsahuje metody užitečné při implementaci knihoven Scriunto. Může být načtena pomocí:

<syntaxhighlight lang="lua">
 libraryUtil = require( 'libraryUtil' )
</syntaxhighlight>

==== libraryUtil.checkType ====
<code style="white-space:nowrap">libraryUtil.checkType( název, argIdx, arg, expectType, nilOk )</code>

Vyvolá chybu, pokud <code style="white-space:nowrap">[[#type|type]]( arg )</code> neodpovídá <code>expectType</code>. Kromě toho nebude vyvolána žádná chyba, pokud je <code>arg</code> nula a <code>nilOk</code> je pravdivé.

<code>název</code> je název volající funkce a <code>argIdx</code> je pozice argumentu v seznamu argumentů. Ty se používají při formátování chybové zprávy.

==== libraryUtil.checkTypeMulti ====
<code style="white-space:nowrap">libraryUtil.checkTypeMulti( název, argIdx, arg, expectTypes )</code>

Vyvolá chybu, pokud <code style="white-space:nowrap">[[#type|type]]( arg )</code> neodpovídá žádnému z řetězců v poli <code>expectTypes</code>.

Toto je pro argumenty, které mají více než jeden platný typ.

==== libraryUtil.checkTypeForIndex ====
<code style="white-space:nowrap">libraryUtil.checkTypeForIndex( index, hodnota, expectType )</code>

Vyvolá chybu, pokud <code style="white-space:nowrap">[[#type|type]]( value )</code> neodpovídá <code>expectType</code>.

Toto je určeno pro použití při implementaci <code>__newindex</code> [[#Metatables|metametody]].

==== libraryUtil.checkTypeForNamedArg ====
<code style="white-space:nowrap">libraryUtil.checkTypeForNamedArg( název, argName, arg, expectType, nilOk )</code>

Vyvolá chybu, pokud <code style="white-space:nowrap">[[#type|type]]( arg )</code> neodpovídá <code>expectType</code>. Kromě toho nebude vyvolána žádná chyba, pokud je <code>arg</code> nula a <code>nilOk</code> je pravda.

To je určeno k použití jako ekvivalent <code>[[#libraryUtil.checkType|libraryUtil.checkType()]]</code> v metodách volaných pomocí syntaxe Lua "pojmenovaný argument", <code style="white-space:nowrap">func{ name = value }</code>.

==== libraryUtil.makeCheckSelfFunction ====
<code style="white-space:nowrap">libraryUtil.makeCheckSelfFunction( libraryName, varName, selfObj, selfObjDesc )</code>

To je určeno pro použití při implementaci "metod" na tabulkách objektů, které mají být volány se syntaxí <code>obj:method()</code>. Vrací funkci, která by měla být volána na začátku těchto metod s argumentem <code>self</code> a názvem metody, což vyvolá chybu, pokud objekt <code>self</code> není <code>selfObj</code>.

Tato funkce bude obecně použita ve funkci konstruktoru knihovny, něco takového:
<syntaxhighlight lang="lua">
 function myLibrary.new()
     local obj = {}
     local checkSelf = libraryUtil.makeCheckSelfFunction( 'myLibrary', 'obj', obj, 'myLibrary object' )
 
     function obj:method()
         checkSelf( self, 'method' )
     end
 
     function obj:method2()
         checkSelf( self, 'method2' )
     end
 
     return obj
 end
</syntaxhighlight>

=== luabit ===
Moduly knihovny [http://luaforge.net/projects/bit/ luabit] "bit" a "hex" lze načíst pomocí:

<syntaxhighlight lang="lua">
 bit = require( 'luabit.bit' )
 hex = require( 'luabit.hex' )
</syntaxhighlight>

Všimněte si, že [[#bit32|knihovna bit32]] obsahuje stejné operace jako "luabit.bit" a operace v "luabit.hex" lze provádět pomocí <code>[[#string.format|string.format()]]</code> a <code>[[#tonumber|tonumber()]]</code>.

Modul luabit "noki" není k dispozici, protože je ve Scriuntu zcela nepoužitelný. Modul luabit "utf8" také není dostupný, protože byl považován pro knihovnu [[#Ustring library|Ustring]] za nadbytečný.

=== strict ===
Knihovna ''strict'' není normální knihovna. Způsobí to vyvolání chyby, kdykoli se použije nová proměnná, která není explicitně vymezena jako lokální proměnná (např. odkazy na přiřazení globálních proměnných). Tato funkce je obvykle povolena načtením v horní části modulu pomocí:

<syntaxhighlight lang="lua">
 require( 'strict' )
</syntaxhighlight>

Na mnoha wikinách Wikimedie to bylo dříve implementováno v <code>Module:No globals</code>, který byl nahrazen pomocí [[:phab:T209310]]. Je částečně odvozen z [https://www.lua.org/extras/5.1/strict.lua strict.lua].

=== ustring ===
Čistý Lua backend do [[#Ustring library|knihovny Ustring]] lze načíst pomocí:

<syntaxhighlight lang="lua">
 ustring = require( 'ustring' )
</syntaxhighlight>

Ve všech případech by měla být místo toho použita knihovna Ustring (<code>mw.ustring</code>), která nahrazuje mnoho pomalejších a paměťově náročnějších operací zpětnými voláními do kódu PHP.

<span id="Extension_libraries"></span>
== Knihovny rozšíření ==

Některá rozšíření MediaWiki poskytují další knihovny Scriunto. Ty jsou také umístěny v tabulce <code>mw</code>, obvykle v tabulce <code>mw.ext</code>, jsou však přítomny pouze v případě, že jsou nainstalována určitá rozšíření (kromě samotného rozšíření Scriunto).

Taková rozšíření používají háčky poskytované Scriunto:
* [[:Category:ScribuntoExternalLibraries extensions|ScribuntoExternalLibraries]]
* [[:Category:ScribuntoExternalLibraryPaths extensions|ScribuntoExternalLibraryPaths]]

[[#Writing Scribunto libraries|Writing Scribunto libraries]] (psaní knihoven Scribunto) poskytuje informace o tom, jak mohou být takové knihovny vyvinuty, aby poskytovaly rozhraní Lua pro rozšíření MediaWiki.

=== mw.wikibase ===
{{ll|Extension:Wikibase Client|nsp=0}} poskytuje přístup k lokalizovatelným strukturovaným datům, zejména [[d:Special:MyLanguage/Wikidata:Main Page|Wikidata]].
Viz [[wmdoc:Wikibase/master/php/docs_topics_lua.html|docs_topics_lua.html]] a {{ll|Extension:Wikibase Client/Lua}}.

=== mw.wikibase.lexeme ===
{{ll|Extension:WikibaseLexeme|nsp=0}} poskytuje přístup k entitám Wikibase Lexeme. Toto je podporováno na stránce [[d:Special:MyLanguage/Wikidata:Lexicographical data|Wikidata:Lexikografická data]].
Viz [[wmdoc:WikibaseLexeme/master/php/md_docs_2topics_2lua.html|md_docs_2topics_2lua.html]] a {{ll|Extension:WikibaseLexeme/Lua}}.

=== mw.wikibase.mediainfo ===
{{ll|Extension:WikibaseMediaInfo|nsp=0}} poskytuje přístup k entitám Wikibase MediaInfo.
Podívejte se na stránku {{ll|Extension:WikibaseMediaInfo/Lua|nsp=0}}.
Toto je podporováno [[c:Special:MyLanguage/Commons:Structured data|Structured Data on Commons]]. Viz [[c:Special:MyLanguage/Commons:Structured data/Lua|Strukturovaná data/Lua]].

=== mw.bcmath ===
{{ll|Extension:BCmath|nsp=0}} poskytuje modulům Lua aritmetiku s libovolnou přesností. Viz dokumentace BCmath přes odkaz "LDoc" na [[Special:MyLanguage/Extension:BCmath#Usage|BCmath § Použití]].

=== mw.smw ===
{{ll|Extension:Semantic Scribunto|nsp=0}} poskytuje nativní podporu Scribunto pro rozšíření {{ll|Extension:Semantic MediaWiki|nsp=0}}.

=== mw.ext.data ===
{{ll|Extension:JsonConfig|nsp=0}} poskytuje přístup k lokalizovatelným tabulkovým a mapovým datům.
Podívejte se na stránku {{ll|Extension:JsonConfig/Tabular|nsp=0}}.
{{ll|Help:Tabular Data|nsp=0}} a GeoJSON {{ll|Help:Map Data|nsp=0}} jsou podporovány ve jmenném prostoru "[[m:DataNamespace|Data]]:" na Commons.
* <code>mw.ext.data.get( ''pagename'' )</code>

=== mw.ext.cargo ===
{{ll|Extension:Cargo|Cargo}} poskytuje prostředek k dotazování na úložiště dat z Lua.
Viz {{ll|Extension:Cargo/Other features#Lua support|Extension:Cargo/Other features#Lua support}} (Rozšíření:Náklad/Další funkce#Lua support).

=== mw.ext.cattools ===
{{ll|Extension:CategoryToolbox|CategoryToolbox}} poskytuje způsob, jak z Lua zkontrolovat, zda určitá stránka patří do kategorie.
<span class="mw-translate-fuzzy">Je experimentální a není povolen na veřejných wikinách Wikimedie. Ale pole "kategorie" [[#Title_objects|pole názvu objektu]] funguje stejně a je povoleno.</span>

=== mw.ext.FlaggedRevs ===
{{ll|Extension:FlaggedRevs|FlaggedRevs}} poskytuje prostředek pro přístup k nastavení stability stránky z Lua.

=== mw.ext.TitleBlacklist ===
{{ll|Extension:TitleBlacklist|TitleBlacklist}} poskytuje prostředek k testování a získávání informací o položkách s názvy stránek na černé listině od Lua.

=== mw.ext.translate.messageBundle ===
['''EXPERIMENTÁLNÍ'''] Část rozšíření {{ll|Extension:Translate|Translate}}. Poskytuje prostředky k dotazování překladů přítomných v {{ll|Help:Extension:Translate/Message Bundles|message bundles}}. Přečtěte si {{ll|Help:Extension:Translate/Message_Bundles/Lua_reference|module documentation}} pro více informací.

=== mw.ext.ParserFunctions ===
{{ll|Extension:ParserFunctions|ParserFunctions}} poskytuje prostředek od Lua k vyhodnocení výrazů stejným způsobem jako jeho funkce analyzátoru založená na PHP <code>{{ll|Help:Extension:ParserFunctions###expr|&#35;expr}}</code>.

=== mw.ext.proofreadPage ===
{{ll|Extension:Proofread Page|Proofread Page}} poskytuje přístup k jmenným prostorům Index a Page.
Podívejte se na stránku {{ll|Extension:Proofread Page/Lua reference}}.
Toto podporuje [[oldwikisource:Wikisource:ProofreadPage|Wikisource:ProofreadPage]].
Podívejte se na stránku {{ll|Help:Extension:ProofreadPage}}.

=== mw.ext.articlePlaceholder ===
{{ll|Extension:ArticlePlaceholder|ArticlePlaceholder}} poskytuje prostředek k přepsání výchozího vykreslování Wikibase z Lua.
Podívejte se na stránku {{ll|Extension:ArticlePlaceholder/Module:AboutTopic}}.

=== mw.ext.externalData ===
{{ll|Extension:ExternalData|ExternalData}} poskytuje prostředek k získání strukturovaných dat z internetu od Lua.
Podívejte se na stránku {{ll|Extension:External Data/Lua}}.

=== mw.ext.UnlinkedWikibase ===
Podívejte se na {{ll|Extension:UnlinkedWikibase|UnlinkedWikibase}}
* <code>mw.ext.UnlinkedWikibase.getEntity( ''id'' )</code>
* <code>mw.ext.UnlinkedWikibase.query( ''sparql'' )</code>

=== mw.ext.seo ===
[[Extension:WikiSEO|WikiSEO]] poskytuje prostředky pro nastavení SEO dat pro aktuální stránku. Viz [[Extension:WikiSEO#Usage in lua modules|Extension:WikiSEO#Usage in lua modules]].

=== mw.slots ===
{{ll|Extension:WSSlots|WSSlots}} poskytuje řadu funkcí Lua pro práci se sloty [[Special:MyLanguage/Multi-Content Revisions|MCR]]:
* <code>mw.slots.slotContent(''slotName'', ''pageName'')</code>
* <code>mw.slots.slotTemplates(''slotName'', ''pageName'')</code> (deprecated)
* <code>mw.slots.slotContentModel(''slotName'', ''pageName'')</code>
* <code>mw.slots.slotData(''slotName'', ''pageName'')</code>

<span id="Differences_from_standard_Lua"></span>
== Rozdíly od standardní Lua ==

<span id="Changed_functions"></span>
=== Změněné funkce ===

Následující funkce byly '''upraveny''':
; [https://www.lua.org/manual/5.1/manual.html#pdf-setfenv setfenv()]
; [https://www.lua.org/manual/5.1/manual.html#pdf-getfenv getfenv()]: V závislosti na konfiguraci nemusí být k dispozici. Pokud jsou k dispozici, pokusy o přístup k nadřazeným prostředím selžou.
; [https://www.lua.org/manual/5.1/manual.html#pdf-getmetatable getmetatable()]: Funguje pouze na tabulkách, aby se zabránilo neoprávněnému přístupu k nadřazeným prostředím.
; [https://www.lua.org/manual/5.1/manual.html#pdf-tostring tostring()]: Adresy ukazatelů tabulek a funkcí nejsou poskytovány. Důvodem je ztížení zneužití zranitelnosti poškození paměti.
; [https://www.lua.org/manual/5.1/manual.html#pdf-pairs pairs()]
; [https://www.lua.org/manual/5.1/manual.html#pdf-ipairs ipairs()]: Byla přidána podpora pro metametody __pairs a __ipairs (přidané v Lua 5.2).
; [https://www.lua.org/manual/5.1/manual.html#pdf-pcall pcall()]
; [https://www.lua.org/manual/5.1/manual.html#pdf-xpcall xpcall()]: Některé vnitřní chyby nelze zachytit.
; [https://www.lua.org/manual/5.1/manual.html#pdf-require require()]: Může načíst určité vestavěné moduly distribuované se Scriunto, stejně jako moduly přítomné v jmenném prostoru modulu na wiki. Chcete-li načíst moduly wiki, použijte celý název stránky včetně jmenného prostoru. Nelze přistupovat jinak k místnímu souborovému systému.


<span id="Removed_functions_and_packages"></span>
=== Odebrané funkce a balíčky ===

Následující balíčky jsou '''většinou odstraněny'''. Dostupné jsou pouze tyto funkce:
;  [https://www.lua.org/manual/5.1/manual.html#5.3 package.*]: Přístup do souborového systému a knihovny C byl odebrán. Dostupné funkce a tabulky jsou:
:; [https://www.lua.org/manual/5.1/manual.html#pdf-package.loaded package.loaded]
:; [https://www.lua.org/manual/5.1/manual.html#pdf-package.preload package.preload]
:; [https://www.lua.org/manual/5.1/manual.html#pdf-package.loaders package.loaders]: Zavaděče, které přistupují k místnímu souborovému systému nebo načítají C knihovny, nejsou přítomny. Je přidán zavaděč pro stránky jmenného prostoru modulu.
:; [https://www.lua.org/manual/5.1/manual.html#pdf-package.seeall package.seeall()]
;  [https://www.lua.org/manual/5.1/manual.html#5.8 os.*]: Jsou zde některé nezabezpečené funkce, jako je os.execute(), které nelze povolit. Dostupné funkce jsou:
:; [https://www.lua.org/manual/5.1/manual.html#pdf-os.clock os.clock()]
:; [https://www.lua.org/manual/5.1/manual.html#pdf-os.date os.date()]
:; [https://www.lua.org/manual/5.1/manual.html#pdf-os.difftime os.difftime()]
:; [https://www.lua.org/manual/5.1/manual.html#pdf-os.time os.time()]
;  [https://www.lua.org/manual/5.1/manual.html#5.9 debug.*]: Většina funkcí je nejistých. Dostupné funkce jsou:
:; [https://www.lua.org/manual/5.1/manual.html#pdf-debug.traceback debug.traceback()]

Následující funkce a balíčky '''nejsou''' dostupné:
; [https://www.lua.org/manual/5.1/manual.html#pdf-collectgarbage collectgarbage()]
; [https://www.lua.org/manual/5.1/manual.html#pdf-module module()]
; [https://www.lua.org/manual/5.1/manual.html#2.11 coroutine.*]: Není nám známa žádná aplikace, takže nebyla zkontrolována z hlediska bezpečnosti.
; [https://www.lua.org/manual/5.1/manual.html#pdf-dofile dofile()]
; [https://www.lua.org/manual/5.1/manual.html#pdf-loadfile loadfile()]
; [https://www.lua.org/manual/5.1/manual.html#5.7 io.*, file.*]: Umožňuje přístup k místnímu souborovému systému, který je nezabezpečený.
; [https://www.lua.org/manual/5.1/manual.html#pdf-load load()]
; [https://www.lua.org/manual/5.1/manual.html#pdf-loadstring loadstring()]: Tyto byly vynechány, aby bylo možné provést statickou analýzu zdrojového kódu Lua. Umožnění těchto možností by také umožnilo přidat kód Lua přímo na stránky článků a šablon, což nebylo žádoucí z důvodů použitelnosti.
; [https://www.lua.org/manual/5.1/manual.html#pdf-print print()]: Toto bylo [[mailarchive:wikitech-l/2012-April/059995.html|diskutováno na wikitech-l]] a bylo rozhodnuto, že by to mělo být vynecháno ve prospěch návratových hodnot, aby se zlepšila kvalita kódu. V případě potřeby lze použít mw.log() k výstupu informací do ladicí konzoly.
; [https://www.lua.org/manual/5.1/manual.html#pdf-string.dump string.dump()]: Může odhalit soukromá data z nadřazených prostředí.


<span id="Additional_caveats"></span>
=== Další upozornění ===

; Referenční datové struktury: Kruhové datové struktury a datové struktury, kde může být stejný uzel dosažen více než jednou cestou, nelze správně odeslat do PHP. Pokus o to způsobí nedefinované chování. To zahrnuje (ale není omezeno na) vracení takových datových struktur z modulu volaného <code><nowiki>{{#invoke:}}</nowiki></code> a předávání takových datových struktur jako parametrů funkcím knihovny Scriunto, které jsou implementovány jako zpětná volání do PHP. <br />Takové datové struktury lze v rámci Lua volně používat, včetně návratových hodnot modulů načtených pomocí <code>[[#mw.loadData|mw.loadData()]]</code>.


<span id="Writing_Scribunto_libraries"></span>
== Psaní knihovny Scribunto ==

Tyto informace jsou užitečné pro vývojáře píšící další knihovny Scriunto, ať už pro zahrnutí do samotného Scriunta nebo pro poskytování rozhraní pro jejich vlastní rozšíření.

Knihovna Scriunto se bude obecně skládat z pěti částí:

* Část knihovny PHP.
* Část knihovny Lua.
* Část testovacích případů PHP.
* Část testovacích případů Lua.
* Dokumentace.

Jako dobrý příklad slouží stávající knihovny.

<span id="Library"></span>
=== Knihovna ===

PHP část knihovny je třída, která musí rozšířit <code>Scribunto_LuaLibraryBase</code>. Podrobnosti o implementaci najdete v dokumentaci pro danou třídu. V rozšíření Scribunto by měl být tento soubor umístěn do <code>engines/LuaCommon/''Name''Library.php</code> a mapování by mělo být přidáno do <code>Scribunto_LuaEngine::$libraryClasses</code>. Ostatní rozšíření by měla používat háček [[Extension:Scribunto/Hooks/ScribuntoExternalLibraries|ScribuntoExternalLibraries]]. V obou případech by se měl klíč shodovat s názvem modulu Lua ("mw.''name''" pro knihovny v Scribunto nebo "mw.ext.''name''" pro knihovny rozšíření).

Část knihovny Lua nastavuje tabulku obsahující funkce, které lze volat z modulů Lua. V příponě Scriunto by měl být soubor umístěn v <code>engines/LuaCommon/lualib/mw.''name''.lua</code>. Tento soubor by měl obecně obsahovat základní popis něco takového:

<syntaxhighlight lang=lua>
local object = {}
local php

function object.setupInterface( options )
    -- Odebrání funkce nastavení
    object.setupInterface = nil

    -- Zkopírujte zpětná volání PHP do místní proměnné a odstraňte globální
    php = mw_interface
    mw_interface = nil

    -- Zde proveďte jakákoli jiná nastavení

    -- Nainstalujte do mw global
    mw = mw or {}
    mw.ext = mw.ext or {}
    mw.ext.NAME = object

    -- Označte, že jsme nabiti
    package.loaded['mw.ext.NAME'] = object
end

return object
</syntaxhighlight>

Modul v <code>engines/LuaCommon/lualib/libraryUtil.lua</code> (načtěte jej pomocí <code>local util = require 'libraryUtil'</code>) obsahuje některé funkce, které mohou být užitečné.

Ujistěte se, že testovací případy Scriunto spouštíte s načtenou knihovnou, i když vaše knihovna sama žádné testovací případy neposkytuje. Standardní testovací případy zahrnují testy věcí, jako jsou knihovny přidávající neočekávané globální proměnné. Také, pokud je knihovna načtena s PHP, žádné vyšší hodnoty, které mají její funkce Lua, nebudou resetovány mezi #invoke. Je třeba dbát na to, aby to moduly nemohly zneužít k přenosu informací mezi #invoke.

<span id="Test_cases"></span>
=== Testovací případy ===
Rozšíření Scriunto obsahuje základní třídu pro testovací případy, <code>Scribunto_LuaEngineTestBase</code>, která bude spouštět testy proti enginu {{ll|LuaSandbox}} a {{ll|Extension:Scribunto#LuaStandalone|LuaStandalone}}.
Testovací případ knihovny by měl tuto třídu rozšířit a neměl by přepsat <code>static function suite()</code>.
V rozšíření Scribunto by měl být testovací případ v <code>tests/engines/LuaCommon/''Name''LibraryTest.php</code> a přidán do pole v {{phpi|ScribuntoHooks::unitTestsList()}} (v <code>common/Hooks.php</code>). Rozšíření by měla přidat testovací případ do své vlastní funkce háčku <code>{{ll|Manual:Hooks/UnitTestsList|UnitTestsList}}</code>, pravděpodobně podmíněné tím, zda je nastaveno <code>$wgAutoloadClasses['Scribunto_LuaEngineTestBase']</code>.

K vytvoření testovacího případu je většinou potřeba toto:

 class ''ClassName''Test extends Scribunto_LuaEngineTestBase {
     protected static $moduleName = '<i>ClassName</i>Test';
 
     function getTestModules() {
          return parent::getTestModules() + array(
              '<i>ClassName</i>Test' => __DIR__ . '/<i>ClassName</i>Tests.lua';
          );
     }
 }

Tím se načte soubor <code>''ClassName''Tests.lua</code>, jako by to byla stránka "Module:''ClassName''Tests", přičemž se očekává, že vrátí objekt s následujícími vlastnostmi:

* '''count''': Celé číslo, počet testů
* '''provide( n )''': Funkce, která vrací tři hodnoty: <code>n</code>, název testu <code>n</code> a řetězec, který je očekávaným výstupem pro test <code>n</code>.
* '''run( n )''': Funkce, která spustí test <code>n</code> a vrátí jeden řetězec.

Pokud je <code>getTestModules()</code> deklarováno jako na obrázku, je k dispozici "Module:TestFramework", který poskytuje mnoho užitečných pomocných metod. Pokud se použije toto, <code>''ClassName''Tests.lua</code> bude vypadat nějak takto:

 local testframework = require 'Module:TestFramework'
 
 return testframework.getTestProvider( {
     -- Zde jsou testy
 } )

Každý test je sám o sobě tabulkou s následujícími vlastnostmi:

* '''name''': Název testu.
* '''func''': Funkce, která se má provést.
* '''args''': Volitelná tabulka argumentů, které se mají předat funkci.
* '''expect''': Očekávané výsledky.
* '''type''': Volitelný "typ" testu, výchozí je "Normal".
Typ řídí formát <code>expect</code> a jak se nazývá <code>func</code>. Zahrnuté typy jsou:

* '''Normal''': <code>expect</code> je tabulka návratových hodnot nebo řetězec, pokud by test měl vyvolat chybu. <code>func</code> se nazývá jednoduše.
* '''Iterator''': <code>expect</code> je tabulka tabulek návratových hodnot. <code>func</code> se volá jako u [[#iterators|iterované ''pro'' smyčku]] a návratové hodnoty každé iterace se akumulují.
* '''ToString''': Jako "Normal", s tím rozdílem, že každá návratová hodnota je předána přes <code>[[#tostring|tostring()]]</code>.

<span id="Test_cases_in_another_extension"></span>
==== Testovací případy v jiném rozšíření ====

Existují (alespoň) dva způsoby, jak spustit testy PHPUnit:

# Spusťte PHPUnit proti jádru, což umožní tests/phpunit/suites/ExtensionsTestSuite.php najít s pomocí {{ll|Manual:Hooks/UnitTestsList|UnitTestsList}} háčku testy rozšíření. Pokud všechny názvy testovacích tříd vašeho rozšíření obsahují jedinečnou komponentu (např. název rozšíření), možnost <code>--filter</code> lze použít ke spuštění pouze testů vašeho rozšíření.
# Spusťte PHPUnit proti adresáři rozšíření, kde vybere jakýkoli soubor končící na "Test.php".

Obojí bude fungovat dobře, pokud je Scriunto načteno v LocalSettings.php. A je snadné, aby metoda #1 fungovala, pokud není načteno Scriunto, protože háček UnitTestsList lze snadno zapsat, aby se zabránilo vracení testu Scribunto, když není nastaveno {{phpi|$wgAutoloadClasses[ 'Scribunto_LuaEngineTestBase' ]}}.

Ale [[Jenkins]] používá metodu #2. Aby Jenkins správně spustil testy, budete muset přidat Scriunto jako závislost pro vaše rozšíření. Viz {{gerrit|56570}} pro příklad, jak se to dělá.

Pokud z nějakého důvodu potřebujete, aby bylo možné testy spustit pomocí metody #2 bez načteného Scriunto, jedním řešením je přidat tuto kontrolu na začátek souboru testu jednotky:

<syntaxhighlight lang="php">
 if ( !isset( $GLOBALS['wgAutoloadClasses']['Scribunto_LuaEngineTestBase'] ) ) {
     return;
 }
</syntaxhighlight>


<span id="Documentation"></span>
=== Dokumentace ===

Moduly zahrnuté ve Scribunto by měly obsahovat dokumentaci v sekci [[#Scribunto libraries|Knihovny Scribunto]] výše. Knihovny rozšíření by měly obsahovat dokumentaci na podstránce své vlastní stránky rozšíření a odkaz na tuto dokumentaci z podsekce [[#Knihovny rozšíření|Knihovny rozšíření]] výše.

<span id="See_also"></span>
== Související odkazy ==

*[[w:Lua (programming language)|Lua (programovací jazyk)]]

<span id="License"></span>
== Licence ==

Tato příručka je odvozena z [https://www.lua.org/manual/5.1/index.html referenční příručky Lua 5.1], která je dostupná pod [https://www.lua.org/license.html licencí MIT].

{{mbox
| type = notice
| image = none
| text =
Autorská práva © 1994-2012 Lua.org, PUC-Rio.

Tímto se bezplatně uděluje oprávnění jakékoli osobě, která získá kopii tohoto softwaru a souvisejících souborů dokumentace (dále jen "Software"), nakládat se softwarem bez omezení, včetně, bez omezení, práv používat, kopírovat, upravovat, slučovat, publikovat, distribuovat, udělovat sublicence a nebo prodávat kopie softwaru a umožnit osobám, kterým je software poskytnut, aby tak činily, za následujících podmínek:

Výše uvedené upozornění na autorská práva a toto upozornění na povolení budou součástí všech kopií nebo podstatných částí Softwaru.

{{uc:Software je poskytován "tak, jak je", bez záruky jakéhokoli druhu, výslovné nebo předpokládané, včetně, ale bez omezení na záruky prodejnosti, vhodnosti pro konkrétní účel a neporušení práv. Autoři nebo držitelé autorských práv v žádném případě nenesou odpovědnost za jakékoli nároky, škody nebo jinou odpovědnost, ať už v případě smluvního jednání, deliktu nebo jinak, vyplývající ze softwaru nebo v souvislosti se softwarem nebo používáním či jiným jednáním se softwarem.}}

Tato odvozená příručka může být také kopírována za podmínek stejné licence.
}}

[[Category:Lua{{#translation:}}]]