# Extension:Scribunto/Lua リファレンス マニュアル

This page is a translated version of the page Extension:Scribunto/Lua reference manual and the translation is 21% complete.
Other languages:
Bahasa Indonesia • ‎Deutsch • ‎English • ‎Esperanto • ‎Tiếng Việt • ‎Türkçe • ‎asturianu • ‎català • ‎español • ‎français • ‎italiano • ‎magyar • ‎polski • ‎português do Brasil • ‎русский • ‎українська • ‎עברית • ‎ဖၠုံလိက် • ‎မြန်မာဘာသာ • ‎中文 • ‎日本語 • ‎한국어
ショートカット:
Lua manual
LUAREF

このマニュアルでは、MediaWiki の Scribunto 拡張機能で使用される Lua について解説しています。 このマニュアルの一部は、MIT license のもとで利用できる Lua 5.1 reference manual に基づいています。

## はじめに

### さあ、はじめましょう

Scribunto が有効化された MediaWiki で、例えば "Module:Bananas" のような、タイトルが "Module:" で始まるページを作成します。 その新しいページに、以下のテキストをコピーします。

local p = {} --p はパッケージの p です。この変数名は何でも構いません。

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

return p


これを保存した後、（モジュールでない）他のページで次のように記述します。

{{#invoke:Bananas|hello}}


ただし「Bananas」の部分はあなたがつけたモジュール名（記事の名前）に置き換えてください。このコードはモジュールからエクスポートされた hello() 関数を呼び出します。{{#invoke:Bananas|hello}} が、関数から返される文字列、この場合は「Hello, world!」に置き換えられます。

Lua のコードをウィキマークアップのテンプレートの形式で呼び出すのは良いことです。というのは、ウィキペディアのソースという観点からすると、ソース中で使われている各テンプレートが Lua で作らているのかウィキマークアップで作られているのかを意識する必要がないからです。また、Lua のコードがテンプレートの形となっていると、ウィキペディアの名前空間に新たに複雑な仕組みを導入する必要はありません。

### モジュール構造

モジュール{{#invoke:}} で呼び出すことのできる関数を保持するテーブルデータを返さなければなりません。一般的には、上述の通り、まずテーブルデータを保持する変数を宣言し、そのテーブルデータに関数を追加し、最後にモジュールの最後でこのテーブルデータを返すようなコードになります。

このテーブルに追加されなかった関数は。局所関数であれ大域関数であれ、{{#invoke:}} を使って呼び出すことはできませんが、大域変数については、require() 関数を使うことで他のモジュールから参照することができます。ですから、他のモジュールから参照されることを意図していないのであれば、全ての関数や変数は局所性のものとして宣言するのが良いことです。

### ウィキマークアップから与えられた値の参照

Functions called by {{#invoke:}} will be passed a single parameter, that being a frame object. To access the parameters passed to the {{#invoke:}}, code will typically use the args table of that frame object. It's also possible to access the parameters passed to the template containing the {{#invoke:}} by using frame:getParent() and accessing that frame's args.

このフレーム・オブジェクトは、パーサー関数の呼び出し、テンプレート展開、任意個数のウィキマークアップ文字列の展開など、ウィキマークアップ・パーサーの文脈に特化したものを参照するのにも使えます。

### テキストを返す

モジュール中のたいていの関数は単一の文字列データを返さなければなりません。いずれにしても関数から返された値はどんなデータ型であれ tostring() に通されて文字列になり、{{#invoke:～}} の処理結果ウィキマークアップに取り込まれます。

この時点では、ウィキマークアップ処理系は、パーサ関数や拡張タグやページの保存前に行う変換処理（署名を表すチルダ --~~~~ やパイプトリック）を処理したりしている段階です。そのため Lua 側の関数が返す文字列にこれらのウィキマークアップに該当する部分文字列があると、それらもウィキマークアップとして処理されることになります。例えば Lua 側の関数が「"こんにちは、[[赤ちゃん]]。私が{{ママ}}よ。"」という文字列を返したとすると、ウィキペディアの記事としての表示は「こんにちは、赤ちゃん。私が{{ママ}}よ。」となります。

### モジュールの解説

Scribunto ではモジュールにウィキマークアップで書かれた解説文書を関連付けられます。この解説文書の関連付けは自動的に行われます。既定では「/doc」という下位ページが解説文書として使われます。この下位ページはモジュールのソースコードのページを表示した時に、ページの冒頭に取り込まれたような形で表示されます。

This can be configured using the following MediaWiki-namespace messages:

• scribunto-doc-page-name: Sets the name of the page used for documentation. The name of the module (without the Module: prefix) is passed as $1. If in the module namespace, the pages specified here will be interpreted as wikitext rather than Lua source and may not be used with {{#invoke:}}. The default is "Module:$1/doc", i.e. the /doc subpage of the module. Note that parser functions and other brace expansion may not be used in this message.
• scribunto-doc-page-does-not-exist: Message displayed when the doc page does not exist. The name of the page is passed as $1. The default is empty. • scribunto-doc-page-show: Message displayed when the doc page does exist. The name of the page is passed as $1. The default is to transclude the documentation page.
• scribunto-doc-page-header: Header displayed when viewing the documentation page itself. The name of the module (with Module: prefix) being documented is passed as $1. The default simply displays a short explanation in italics. モジュールのページにカテゴリタグやウィキ間リンクを直接追加することはできませんが、解説ページに<includeonly>...</includeonly>タグの間に追加すれば、モジュールのページに自動的に呼び出される時に適用されます。 ## Lua 言語 ### トークン Lua言語における名前（または識別子）とは数字以外ではじまる文字列で、アルファベット、数字、アンダースコアで構成されます。名前は大文字と小文字を区別します。fooFooFOO は、それぞれ別の名前です。 以下のキーワードは予約されており、名前として使用できません。 • and • break • do • else • elseif • end • false • for • function • if • in • local • nil • not • or • repeat • return • then • true • until • while アンダースコアと大文字ではじまる名前は Lua 内部の大域変数として予約されています。 その他のトークン: • # • % • ( • ) • * • + • , • - • . • .. • ... • / • : • ; • < • <= • = • == • > • >= • [ • ] • ^ • { • } • ~= ### コメント 注釈文は文字列の外側ならどこででも「--」で始まります。「--」の直後に開き長かっこがあれば、対応する閉じ長かっこまでがコメントです。そうでなければ行末までが注釈文となります。 -- {{lang|pt|Lua}} 言語の注釈文は「--」で始まり、その行の行末で終わります。 --[[ 複数行に渡る文字列や注釈文は 二つの角括弧で括ります。]] --[=[このような形の注釈文は--[[他の注釈文]]を入れ子にすることができます。]=] --[==[このような形の注釈文は他の --[===[何重にも --[=[入れ子された]=] --長い ]===] コメントを入れることができます。 --[[長い括弧の対応が取れていなくても構いません。]===] ]==]  ### データ型 Lua は動的型付け言語です。変数や関数の引数は型を持たず、代入される値だけを持ちます。値は型を保持します。 Lua には8つの基本的なデータ型がありますが、Scribunto 拡張機能に関係するのはそのうちの6つだけです。type() 関数は値の型を返します。 tostring() 関数は値を文字列へ変換します。tonumber() 関数は可能なら値を数値へ変換し、変換できないなら nil を返します。その他のデータ型へ変換する明示的な関数はありません。 数値は、文字列が期待される場所では自動的に文字列へ変換されます。たとえば文字列連結演算子で。文字列が算術演算子に使用される場合、tonumber() によって数値へ変換されます。真偽値が期待される場所では、nil 以外の全ての値は true として扱われます。 #### nil nil は値がないことを表すための特殊な値です。 nil はテーブルのキーとして使用されることはなく、キーが未割り当であることと、キーとして nil が割り当てられていることは、同じことです。 文字列へ変換される場合、結果は "nil" です。真偽値へ変換される場合、nilfalse とみなされます。 #### 真偽値 真偽値は true または false です。 文字列へ変換される場合は "true" または "false" となります。 他の言語と違って、真偽値が直接数値へ変換されることはありません。また、falsenil だけが偽値と見なされ、数値のゼロや空の文字列は真値とみなされます。 #### 文字列 Lua 言語で文字列は8ビット幅のバイト列として扱われており、特定の文字コードとして扱うかどうかはアプリケーション・プログラムに任されています。 文字列リテラルはシングルクォートかダブルクォート (' または ") で区切られます。この2つに違いは無いという点で JavaScript とは同様であり、PHP とは異なります。以下のエスケープ表現が有効です。 エスケープ表現 名前 ASCIIコードポイント \a ベル文字 7 \b バックスペース 8 \t 水平タブ 9 \n 改行 10 \v 垂直タブ 11 \f フォームフィード 12 \r キャリッジリターン 13 \" ダブルクォート 34 \' シングルクォート 39 \\ バックスラッシュ 92 文字列中で改行の直前にバックスラッシュ文字「\」があればそこは文字列データ中でも改行として含まれることになります。また文字列中に「\数字列」（数字列0255 ）の形式の記述があれば、そこには、数字列 が表現するところのバイトデータになります。Unicode文字列をエスケープ表現で記述する場合は、UTF-8文字符号化方式でのバイトの並びを入れる必要があります。 文字列リテラルは長括弧によって表現することもできます。 開き長括弧は、開き角括弧で始まり、その後に0個以上の等号が続き、その後に開き角括弧で終わるものです。例えば次のものはすべて開き長括弧です: • [[ • [=[ • [=====[ 開き長括弧はそれと対応する閉じ長括弧によって閉められなければなりません。対応する閉じ長括弧とは、開き長括弧の開き角括弧「[」を閉じ角括弧「]」に置換したものです。例えば次のものはすべて閉じ長括弧です。 • ]] • ]=] • ]=====]. 特別な場合として、開き長括弧の直後が改行になっているものについては、その改行は文字列データには含まれません。しかし閉じ長括弧の直前の改行は文字列データに含まれます。 長括弧で括られた文字列中ではエスケープ表現は特別な意味を持たず書かれてある通りの文字列データになります。 -- 長括弧で括られたこの文字列 foo = [[ bar\tbaz ]] -- は、以下のものと等価です。 foo = 'bar\\tbaz\n'  長さ 0 の文字列を含めて、全ての文字列データは真偽値としては真値として解釈されます。 #### 数値 Lua には数値型は一つしかなく、通常は倍精度浮動小数点数として内部的に表現されます。この形式で厳密に表現できる整数の範囲は -90071992547409929007199254740992 の間であり、これを超える数値は丸め誤差が発生する可能性があります。 数値は小数の区切りとして「.」を使用して 123456.78 のように記述します。指数表記を使用して 1.23e-10123.45e20 あるいは 1.23E5 のように表現することも出来ます。整数は 0x を使用した16進数記法で、0x3A のようにも記述できます。 非数および正負の無限大は正しく保持し扱うことができますが、Lua はこれらに対応するリテラルを提供していません。定数 math.huge は正の無限大であり、1/0 のような除算も同様です。また、手っ取り早く非数を生成する方法として 0/0 が使われる場合があります。 すべての数値は、真偽値へ変換される場合、真とみなされることに注意してください。これは 0 が偽とみなされるような他言語とは異なる点です。文字列へ変換される場合、有限の数値は小数で、可能なら指数表記で表現されます。非数は "nan" または "-nan"、無限大は "inf" または "-inf" となります。 #### テーブル Lua のテーブルは、PHP の配列や JavaScript のオブジェクトによく似た連想配列です。 テーブルは波括弧を使って作成します。空のテーブルは {} です。作成時にフィールドにデータを入れるには、コンマかセミコロン、あるいはその両方で区切られたフィールド指示子のリストで記述します。次のようないくつかの形式をとります。 表記 意味 [expression1] = expression2 expression1 の (1番目の) 値がキーとして使われ、expression2 の (1番目の) 値が値として使われます。 name = expression ["name"] = expression と同等です。 expression これは [i] = expression と大体同じです。i1 から始まり、この形式のフィールド指示ごとに1ずつ増えていく整数です。もしこれが最後のフィールド指示子で、複数の値を持った式であるなら、そのすべての値が使用されます。それ以外の場合は1番目の値だけが保持されます。 テーブルデータ中にあるフィールド（項目）は「テーブル[キー]」という形で読み書きできます。これはブラケット記法と呼ばれます。 キーが文字列で、その文字列が Lua の識別子としても妥当であるものであれば、「テーブル.キー」という形でも読み書きできます。これはドット記法と呼ばれます。 テーブル中のフィールドの値が関数で、なおかつフィールドのキーが文字列でそのキーがLua の識別子としても妥当である場合、「テーブル:キー()」という形でその関数を呼び出すことができます。これはコロン記法と呼ばれます。これは「テーブル['キー'](テーブル, …)」や「テーブル.キー(テーブル, …)」と等価です。 シーケンスというのは次のすべての性質を満たすテーブルのことです。 • キーが正の整数である。 • キー範囲1～Nでは値が nil でない値である。 • N+1以上のキー範囲では値が nil である。 多くの Lua の関数はシーケンスを扱い、非正の整数のキーを無視します。 nil と非数を除く全ての値はテーブルのキーとして使うことができます。どのようなキーも型変換されることはありません。これらすべての値は妥当であり他の値とは異なるものとして扱われます。 -- テーブルの作成 t = {} t["foo"] = "foo" t.bar = "bar" t[1] = "one" t[2] = "two" t[3] = "three" t[12] = "the number twelve" t["12"] = "文字列12" t[true] = "true" t[tonumber] = "yes, even functions may be table keys" t[t] = "yes, a table may be a table key too. Even in itself." -- 次のコードは上のテーブルとおおよそ同等なテーブルを作るものです。 t2 = { foo = "foo", bar = "bar", "one", "two", [12] = "the number twelve", ["12"] = "文字列12"、 "three", [true] = "true", [tonumber] = "yes, even functions may be table keys", } t2[t2] = "yes, a table may be a table key too. Even in itself."  同様に、nil 以外のどんな値でもテーブルの値として入れることができます。nil を表に入れるというのは、対応するキーを削除するのと同じことです。また、それまでに何も値を設定されていないキーの値を参照すると nil が返されます。 Lua言語ではテーブルは暗黙に複製がつくられることはありません。例えばある関数が引数としてテーブルデータを受け取って、その関数がそのテーブルデータに対して何らかの変更を加えるとすれば、その変更はそのまま関数を呼び出し側からも見えてしまうということです。 テーブルデータを文字列に変換すると既定では "table" という文字列になるだけですが、__tostring メタメソッドをオーバラーライド（上書き）することで、この結果を変えることができます。中身が空のテーブルを含めてすべてのテーブルデータは真偽値としては真値として扱われます。 #### 関数 Lua における関数は第一級の値です。関数は匿名のものとして作られたり、引数として渡されたり、変数に代入されたりします。 関数は function キーワードを使って作成され、括弧を使って呼び出されます。名前付き関数、ローカル関数、テーブルのメンバー関数として振る舞う関数に対しては構文糖衣が利用できます。詳しくは関数定義関数呼出しを参照してください。 Lua の関数はクロージャ（関数閉包）です。つまり、関数は自身が定義された場所のスコープへの参照を保持し、その関数が実際に評価される場所がどこであるかに関係なく、定義された場所のスコープにある変数に対してアクセスしたり操作することが出来ます。 暗黙的に複製されることのないテーブルと同じように、関数オブジェクトも、たとえ異なる変数に代入されるとしても、また、他の関数に引数として渡されるとしても、もとの関数オブジェクトから何も変わることはありません。 関数オブジェクトは文字列へ変換されると、結果は "function" になります。 #### 操作できないデータ型 ユーザーデータ型は、Lua を拡張するために他の言語で書かれた不明な値を保持する型として使用されます。例えばユーザーデータは C 言語のポインタや構造体を保持するのに使われる場合があります。カスタムコンパイルされたコードが許可されないホスティング環境で Scribunto を利用可能にするため、このような拡張は一切使用されません。 スレッド型はコルーチンのハンドラを表し、Scribunto のサンドボックス内では利用できません。 ### メタテーブル すべてのテーブルはメタテーブルと呼ばれるテーブルと関連付けられています。メタテーブルが保持する各フィールドは、演算子や関数によって参照され、テーブル同士の差分を求めたり、そのテーブルに対するコールバック動作をする目的で使われます。テーブルに関連付けられたメタテーブルを取得するには getmetatable() 関数が使われ、メタテーブルを変更するには$setmetatbale 関数が使われます。

メタの機能にアクセスがあった場合、メタテーブルのフィールドはrawget()があるようにアクセスを処理します。

テーブル自体に影響するメタテーブルのフィールドは次のものです。

__index
これは テーブル[キー]nil を返す場合に使われます。 もしこのフィールドの値がテーブルデータであれば、__index[キー] というように同じ操作がそのテーブルに対しても繰り返されます（そのテーブルのメタテーブルの __index が呼ばれます）。 もしもこのフィールドの値が関数であれば、その関数が __index(テーブル, キー) で呼び出されます。 rawget() 関数を使えばこのメタメソッドの仕組みを回避してデータの取得をすることができます。
__newindex
これはテーブルデータに対して新規に値を設定するときに使われます。コードで言えば rawget(テーブル, キー)nil である時に テーブル[キー] = 値 を実行する時に使われます。 もしこのフィールドの値がテーブルデータであれば、__newindex[キー] というように同じ操作がそのテーブルに対しても繰り返されます（そのテーブルのメタテーブルの __newindex が呼ばれます）。 もしもこのフィールドの値が関数であれば、その関数が __index(テーブル, キー, 値) で呼び出されます。 rawset() 関数を使えばこのメタメソッドの仕組みを回避してデータの取得をすることができます。
__call
これはテーブルに対して関数呼び出しの形（テーブル(～)）が用いられた場合に使われます。 この場合、フィールドの値は関数で __call(テーブル, ～) の形で呼び出すことができるものでなければなりません。
__mode
これは弱い参照を保持するテーブルを作る場合に使われます。 フィールドの値は文字列でなければなりません。 普通のテーブルの場合、キーも値もガベージコレクションの対象にはなりません。 しかし、このフィールドの値に文字「k」が含まれている場合、弱い参照でないものが含まれいなければ、キーはガベージコレクションの対象になります。またこのフィールドの値に文字「v」が含まれている場合、対応するキーと値の両方がテーブルから削除されます。 テーブルがメタテーブルとして使われた後にこのフィールドが変更された場合の挙動については定義されていません。

メタテーブルの他のフィールドには以下のものがあります。

* __メタテーブルは getmetatable()setmetatable() に影響

### 式

というのは何かの値を持つもののことを言います。

• リテラル（数値型、文字列型、truefalsenil
• 無名関数宣言
• テーブルのコンストラクター
• 変数の参照
• 関数呼び出し
• vararg
• 何かの式が () で括られたもの
• 何かの式に単項演算子が付されたもの
• 二つの式が二項演算子で繋げられたもの

ほとんどの演算子は一つの値を持ちます。関数呼び出しと vararg 式については不特定個数の値を持ちます。関数呼び出しや vararg 式を () で括った式の場合、最初の値を除く全ての値が失われます。

#### 算術演算子

Lua には普通の算術演算子があります。加算、減算、乗算、除算、剰余算、べき乗、反数です。

どれかの値がテーブル型データで、なおかつ適切なメタメソッドが伴っていれば、そのメタメソッドが呼ばれます。

+ 加算 a + b __add
- 減算 a - b __sub
* 乗算 a * b __mul
/ 除算 a / b __div 0で割ってもエラーにはなりません、NaNかinfinityを返します
% 剰余 a % b __mod a % b == a - math.floor( a / b ) * b として定義
^ べき乗 a ^ b __pow 指数は整数でなければなりません。
- 反数 -a __unm

#### 関係演算子

Lua 言語の関係演算子は==~=<>k<=>=です。関係演算子の評価結果はどんな場合も真偽値です。

== 演算子はまず両辺のデータ型を比較して型が不一致であれば false を返します。さもなくばこの演算子は両辺の値を比較します。nilブール値（false/true）、数値、文字列はそれぞれの方法で比較されます。両辺が関数であれば、二つが完全に同一の実体であるかどうかが見られます。そのため function() end == function() end という比較の場合、両者は機能としては同じでも実体としては異なるため、結果は false となります。既定の動作ではテーブルもこれと同じやり方で比較されますが、比較の仕方は __eq メタメソッドを使って変更することができます。

~= 演算子は単純な論理否定です。

• a < b で処理系は __lt を使います。
• a <= b では利用可能であれば処理系はまず __le を使い、__lt が利用可能であれば not (b < a) を評価します。
• a > bb < a として処理されます。
• a >= bb <= a として処理されます。

#### 論理演算子

Lua言語の論理演算子は andornot です。これらの演算子は nilfalse を偽値として扱い、それ以外のすべてのデータを真値として扱います。

and 演算子は、まず左側の値を評価しこれが偽値であれば左側の値を返します（短絡評価）。左側の値が偽値でなれば右側の値をそのまま返します。

or 演算子は、まず左側の値を評価しこれが真値であれば左側の値を返します（短絡評価）。左側の値が真値でなれば右側の値をそのまま返します。

not 演算子が返すのは、true または false のどちらかあり、他の値は返しません。

and 演算子、or 演算子は短絡評価しますから、例えば、foo() or bar() というコードの場合、bar() が評価されるのは foo()falsenil を返す場合に限られます。

#### 結合演算子

Lua の文字列はイミュータブル（書き換えが出来ないもの）であり、Lua にはいわゆる「文字列ビルダー」は存在しないため、while 文などの繰り返し中に a = a .. b とゆうようなコードがある場合、繰り返しの都度、中間的な文字列が生成されてはガベージコレクションによって回収されるという無駄が生じることになります。たくさんの文字列を一つに連結しなければならない場合は、string.format 関数を使うとか、または個々の部分文字列をシーケンスに追加しておいて最後に table.concat() を使う方が高速です。

#### 長さ演算子

a がシーケンスでないテーブルなら、#aa[N]nil でなく a[N+1]nil であるようなあらゆる値 N を返す可能性があります。

-- a[3] が nil で a[4] が非 nil なので、これはシーケンスではありません。
a = { 1, 2, nil, 4 }

-- これは 2 あるいは 4 どちらも出力し得る。
-- また、テーブルが修正されていなくてもこの結果は変わり得る。
mw.log( #a )


#### 演算子の優先順位

Lua の演算子の優先順位は、高いものから低いものへ次のようになります。

1. ^
2. not # - (算術否定)
3. * / %
4. + - (減算)
5. ..
6. < > <= >= ~= ==
7. and
8. or

#### 関数呼び出し

Luaの関数呼び出しは、多くの他言語と似ています。名前の後に括弧で囲まれた引数のリストが続きます。

func( 式リスト )


Luaの式リストでは通常、リスト内の最後の式に複数の引数値を指定することができます。

If the function is called with fewer values in the expression list than there are arguments in the function definition, the extra arguments will have a nil value. If the expression list contains more values than there are arguments, the excess values are discarded. It is also possible for a function to take a variable number of arguments; see Function declarations for details.

Luaでは、関数の戻り値、つまりfunc()()を直接呼び出すこともできます。呼び出される関数を決定するために変数アクセスよりも複雑な式が必要な場合は、変数アクセスの代わりに括弧で囲まれた式を使用することができます。

Luaには、2つの一般的なケースを想定したシンタックスシュガーがあります。1つ目は、テーブルをオブジェクトとして使用している場合で、関数をオブジェクト上のメソッドとして呼び出す場合です。構文的には

table:name( 式リスト )


は、以下と同等です

table.name( table, 式リスト )


2つ目の一般的なケースは、名前と値のマッピングを含むテーブルを関数の唯一の位置引数として渡すことで名前付き引数を実装するLuaの方法です。この場合、引数リストの周囲の括弧は省略することができます。これは、関数が単一のリテラル文字列を渡す場合にも機能します。例えば

func{ arg1 = exp, arg2 = exp }
func"string"

は、以下と同等です

func( { arg1 = exp, arg2 = exp } )
func( "string" )

これらは組み合わせることができます。次の呼び出しは同等です:

table:name{ arg1 = exp, arg2 = exp }
table.name( table, { arg1 = exp, arg2 = exp } )

#### 関数宣言

function ( var-list )
block
end

var-list内のすべての変数は関数のローカル変数であり、関数呼び出し内の式リストから値が代入されます。追加のローカル変数はブロック内で宣言することができます。

Lua関数はlexical closuresです。一般的なイディオムは、関数が宣言されているスコープで"private static"変数をローカルとして宣言することです。例えば、

-- これは、引数に数値を追加する関数を返します
return function( x )
-- 外部スコープからの変数nは、ここでxに追加することができます。
return x + n
end
end

-- prints 11


var-listの最後の項目として...を指定することにより、関数は可変数の引数を受け入れるように宣言できます:

function ( var-list, ... )
block
end

ブロック内では、可変引数式...を使用でき、その結果、関数呼び出しのすべての追加値が得られます。例えば、

local join = function ( separator, ... )
-- 追加の引数をテーブルとして取得します
local args = { ... }
-- 追加引数の数を正しく取得します
local n = select( '#', ... )
return table.concat( args, separator, 1, n )
end

join( ', ', 'foo', 'bar', 'baz' )
-- 文字列"foo, bar, baz"を返します


select()関数は、可変引数式で機能するように設計されています。 特に、{ ... }sequenceではない可能性があるため、可変引数式の値の数をカウントするには、#{ ... }の代わりにselect( '#', ... )を使用する必要があります。

Luaは、関数宣言と変数への代入を組み合わせるための糖衣構文を提供します。詳細はFunction declaration statementsを参照してください。

local factorial = function ( n )
if n <= 2 then
return n
else
return n * factorial( n - 1 )
end
end


### 文

statementは実行の基本単位です。1つの割り当て、制御構造、関数呼び出し、変数宣言などです。

chunkとは、セミコロンで区切られた一連のステートメントのことです。チャンクは基本的に無名関数の本体とみなされ、ローカル変数の宣言、引数の受け取り、値を返すことができます。

A block is also a sequence of statements, just like a chunk. A block can be delimited to create a single statement: do block end. These may be used to limit the scope of local variables, or to add a return or break in the middle of another block.

#### Assignments

variable-list = 式リスト

The variable-list is a comma-separated list of variables; the expression-list is a comma-separated list of one or more expressions. All expressions are evaluated before any assignments are performed, so a, b = b, a will swap the values of a and b.

#### 局所変数の宣言

local variable-list

local variable-list = 式リスト

Local variables may be declared anywhere within a block or chunk. The first form, without an expression list, declares the variables but does not assign a value so all variables have nil as a value. The second form assigns values to the local variables, as described in Assignments above.

Note that visibility of the local variable begins with the statement after the local variable declaration. So a declaration like local x = x declares a local variable x and assigns it the value of x from the outer scope. The local variable remains in scope until the end of the innermost block containing the local variable declaration.

#### 制御構造

while exp do ブロック end

The while statement repeats a block as long as an expression evaluates to a true value.

repeat ブロック until exp

The repeat statement repeats a block until an expression evaluates to a true value. Local variables declared inside the block may be accessed in the expression.

for name = exp1, exp2, exp3 do ブロック end
for name = exp1, exp2 do ブロック end

This first form of the for loop will declare a local variable, and repeat the block for values from exp1 to exp2 adding exp3 on each iteration. Note that exp3 may be omitted entirely, in which case 1 is used, but non-numeric values such as nil and false are an error. All expressions are evaluated once before the loop is started.

This form of the for loop is roughly equivalent to

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


except that the variables var, limit, and step are not accessible anywhere else. Note that the variable name is local to the block; to use the value after the loop, it must be copied to a variable declared outside the loop.

for var-list in 式リスト do block end

The second form of the for loop works with iterator functions. As in the first form, the expression-list is evaluated only once before beginning the loop.

This form of the for loop is roughly equivalent to

do
local func, static, var = expression-list
while true do
local var-list = func( static, var )
var = var1  -- ''var1'' is the first variable in ''var-list''
if var == nil then
break
end
block
end
end


except that again the variables func, static, and var are not accessible anywhere else. Note that the variables in var-list are local to the block; to use them after the loop, they must be copied to variables declared outside the loop.

Often the expression-list is a single function call that returns the three values. If the iterator function can be written so it only depends on the parameters passed into it, that would be the most efficient. If not, Programming in Lua suggests that a closure be preferred to returning a table as the static variable and updating its members on each iteration.

if exp1 then block1 elseif exp2 then block2 else block3 end

Executes block1 if exp1 returns true, otherwise executes block2 if exp2 returns true, and block3 otherwise. The else block3 portion may be omitted, and the elseif exp2 then block2 portion may be repeated or omitted as necessary.

return 式リスト

The return statement is used to return values from a function or a chunk (which is just a function). The expression-list is a comma-separated list of zero or more expressions.

Lua implements tail calls: if expression-list consists of exactly one expression which is a function call, the current stack frame will be reused for the call to that function. This has implication for functions that deal with the call stack, such as getfenv() and debug.traceback().

The return statement must be the last statement in its block. If for some reason a return is needed in the middle of a block, an explicit block do return end may be used.

break

The break statement is used to terminate the execution of a while, repeat, or for loop, skipping to the next statement after the loop.

The break statement must be the last statement in its block. If for some reason a break is needed in the middle of a block, an explicit block do break end may be used.

#### Function calls as statements

A function call may be used as a statement; in this case, the function is being called only for any side effects it may have (e.g. mw.log() logs values) and any return values are discarded.

#### 関数宣言文

Lua provides syntactic sugar to make declaring a function and assigning it to a variable more natural. The following pairs of declarations are equivalent

-- Basic declaration
function func( var-list ) block end
func = function ( var-list ) block end
-- Local function
local function func( var-list ) block end
local func; func = function ( var-list ) block end
-- Function as a field in a table
function table.func( var-list ) block end
table.func = function ( var-list ) block end
-- Function as a method in a table
function table:func( var-list ) block end
table.func = function ( self, var-list ) block end

Note the colon notation here parallels the colon notation for function calls, adding an implicit argument named "self" at the beginning of the arguments list.

### エラーハンドリング

Errors may be "thrown" using the error() and assert() functions. To "catch" errors, use pcall() or xpcall(). Note that certain internal Scribunto errors cannot be caught in Lua code.

### ガーベージコレクション

Lua performs automatic memory management. This means that you have to worry neither about allocating memory for new objects nor about freeing it when the objects are no longer needed. Lua manages memory automatically by running a garbage collector from time to time to collect all dead objects (that is, objects that are no longer accessible from Lua) and objects that are only reachable via weak references. All memory used by Lua is subject to automatic management: tables, functions, strings, etc.

Garbage collection happens automatically, and cannot be configured from within Scribunto.

## 標準ライブラリ

The standard Lua libraries provide essential services and performance-critical functions to Lua. Only those portions of the standard libraries that are available in Scribunto are documented here.

### Basic functions

#### _G

This variable holds a reference to the current global variable table; the global variable foo may also be accessed as _G.foo. Note, however, that there is nothing special about _G itself; it may be reassigned in the same manner as any other variable:

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


The global variable table may be used just like any other table. For example,

-- Call a function whose name is stored in a variable
_G[var]()

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

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


#### assert

assert( v, message, ... )

もしv が nil または false の場合、エラーを通知します。その場合、エラー文として message を採用します。もし nil (あるいは特定しない場合) の場合、エラー文は「assertion failed!」です。文字列もしくは数値の場合、文はその値です。その他の場合、それ自体が問題の原因だと断定します。

If v is any other value, assert returns all arguments including v and message.

A somewhat common idiom in Lua is for a function to return a "true" value in normal operation, and on failure return nil or false as the first value and an error message as the second value. Easy error checking can then be implemented by wrapping the call in a call to assert:

-- This doesn't check for errors
local result1, result2, etc = func( ... )

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


#### error

error( message, level )

Issues an error, with text message.

error normally adds some information about the location of the error. If level is 1 or omitted, that information is the location of the call to error itself; 2 uses the location of the call of the function that called error; and so on. Passing 0 omits inclusion of the location information.

#### getfenv

getfenv( f )

Note this function may not be available, depending on allowEnvFuncs in the engine configuration.

Returns an environment (global variable table), as specified by f:

• If 1, nil, or omitted, returns the environment of the function calling getfenv. Often this will be the same as _G.
• Integers 2–10 return the environment of functions higher in the call stack. For example, 2 returns the environment for the function that called the current function, 3 returns the environment for the function calling that function, and so on. An error will be raised if the value is higher than the number of function calls in the stack, or if the targeted stack level returned with a tail call.
• Passing a function returns the environment that will be used when that function is called.

The environments used by all standard library functions and Scribunto library functions are protected. Attempting to access these environments using getfenv will return nil instead.

#### getmetatable

getmetatable( table )

Returns the metatable of a table. Any other type will return nil.

If the metatable has a __metatable field, that value will be returned instead of the actual metatable.

#### ipairs

ipairs( t )

Returns three values: an iterator function, the table t, and 0. This is intended for use in the iterator form of for:

for i, v in ipairs( t ) do
-- process each index-value pair
end


This will iterate over the pairs ( 1, t[1] ), ( 2, t[2] ), and so on, stopping when t[i] would be nil.

The standard behavior may be overridden by providing an __ipairs metamethod. If that metamethod exists, the call to ipairs will return the three values returned by __ipairs( t ) instead.

#### next

next( table, key )

This allows for iterating over the keys in a table. If key is nil or unspecified, returns the "first" key in the table and its value; otherwise, it returns the "next" key and its value. When no more keys are available, returns nil. It is possible to check whether a table is empty using the expression next( t ) == nil.

Note that the order in which the keys are returned is not specified, even for tables with numeric indexes. To traverse a table in numerical order, use a numerical for or ipairs.

Behavior is undefined if, when using next for traversal, any non-existing key is assigned a value. Assigning a new value (including nil) to an existing field is allowed.

#### pairs

pairs( t )

Returns three values: an iterator function (next or a work-alike), the table t, and nil. This is intended for use in the iterator form of for:

for k, v in pairs( t ) do
-- process each key-value pair
end


This will iterate over the key-value pairs in t just as next would; see the documentation for next for restrictions on modifying the table during traversal.

The standard behavior may be overridden by providing a __pairs metamethod. If that metamethod exists, the call to pairs will return the three values returned by __pairs( t ) instead.

#### pcall

pcall( f, ... )

Calls the function f with the given arguments in protected mode. This means that if an error is raised during the call to f, pcall will return false and the error message raised. If no error occurs, pcall will return true and all values returned by the call.

In pseudocode, pcall might be defined something like this:

function pcall( f, ... )
try
return true, f( ... )
catch ( message )
return false, message
end
end


#### rawequal

rawequal( a, b )

This is equivalent to a == b except that it ignores any __eq metamethod.

#### rawget

rawget( table, k )

This is equivalent to table[k] except that it ignores any __index metamethod.

#### rawset

rawset( table, k, v )

This is equivalent to table[k] = v except that it ignores any __newindex metamethod.

#### select

select( index, ... )

もし index が数値の場合、... はその検索後、すべての議論を返します。もし index が文字列 '#' の場合、... において議論数を返します。

In other words, select is something roughly like the following except that it will work correctly even when ... contains nil values (see documentation for # and unpack for the problem with nils).

function select( index, ... )
local t = { ... }
if index == '#' then
return #t
else
return unpack( t, index )
end
end


#### setmetatable

setmetatable( table, metatable )

Sets the metatable of a table. metatable may be nil, but must be explicitly provided.

If the current metatable has a __metatable field, setmetatable will throw an error.

#### tonumber

tonumber( value, base )

value を数値に変換しようと試みます。それが数値もしくは文字列で数値に変換可能な場合、tonumber 箱の数値を返します。それ以外は nil を返します。

The optional base (default 10) specifies the base to interpret the numeral. The base may be any integer between 2 and 36, inclusive. In bases above 10, the letter 'A' (in either upper or lower case) represents 10, 'B' represents 11, and so forth, with 'Z' representing 35.

In base 10, the value may have a decimal part, be expressed in E notation, and may have a leading "0x" to indicate base 16. In other bases, only unsigned integers are accepted.

#### tostring

tostring( value )

Converts value to a string. See Data types above for details on how each type is converted.

The standard behavior for tables may be overridden by providing a __tostring metamethod. If that metamethod exists, the call to tostring will return the single value returned by __tostring( value ) instead.

#### type

type( value )

Returns the type of value as a string: "nil", "number", "string", "boolean", "table", or "function".

#### unpack

unpack( table, i, j )

Returns values from the given table, something like table[i], table[i+1], ···, table[j] would do if written out manually. If nil or not given, i defaults to 1 and j defaults to #table.

Note that results are not deterministic if table is not a sequence and j is nil or unspecified; see Length operator for details.

#### xpcall

xpcall( f, errhandler )

This is much like pcall, except that the error message is passed to the function errhandler before being returned.

In pseudocode, xpcall might be defined something like this:

function xpcall( f, errhandler )
try
return true, f()
catch ( message )
message = errhandler( message )
return false, message
end
end


### Debug library

#### debug.traceback

debug.traceback( message, level )

Returns a string with a traceback of the call stack. An optional message string is appended at the beginning of the traceback. An optional level number tells at which stack level to start the traceback.

### Math library

#### math.abs

math.abs( x )

Returns the absolute value of x.

#### math.acos

math.acos( x )

Returns the arc cosine of x (given in radians).

#### math.asin

math.asin( x )

Returns the arc sine of x (given in radians).

#### math.atan

math.atan( x )

Returns the arc tangent of x (given in radians).

#### math.atan2

math.atan2( y, x )

Returns the arc tangent of y/x (given in radians), using the signs of both parameters to find the quadrant of the result.

#### math.ceil

math.ceil( x )

Returns the smallest integer larger than or equal to x.

#### math.cos

math.cos( x )

Returns the cosine of x (given in radians).

#### math.cosh

math.cosh( x )

Returns the hyperbolic cosine of x.

#### math.deg

math.deg( x )

Returns the angle x (given in radians) in degrees.

#### math.exp

math.exp( x )

Returns the value ${\displaystyle e^{x}}$ .

#### math.floor

math.floor( x )

Returns the largest integer smaller than or equal to x.

#### math.fmod

math.fmod( x, y )

Returns the remainder of the division of x by y that rounds the quotient towards zero. For example, math.fmod( 10, 3 ) yields 1.

#### math.frexp

math.frexp( x )

Returns two values m and e such that:

• If x is finite and non-zero: ${\displaystyle x=m\times 2^{e}}$ , e is an integer, and the absolute value of m is in the range ${\displaystyle [0.5,1)}$
• If x is zero: m and e are 0
• If x is NaN or infinite: m is x and e is not specified

#### math.huge

The value representing positive infinity; larger than or equal to any other numerical value.

#### math.ldexp

math.ldexp( m, e )

Returns ${\displaystyle m\times 2^{e}}$  (e should be an integer).

#### math.log

math.log( x )

Returns the natural logarithm of x.

#### math.log10

math.log10( x )

Returns the base-10 logarithm of x.

#### math.max

math.max( x, ... )

Returns the maximum value among its arguments.

Behavior with NaNs is not specified. With the current implementation, NaN will be returned if x is NaN, but any other NaNs will be ignored.

#### math.min

math.min( x, ... )

Returns the minimum value among its arguments.

Behavior with NaNs is not specified. With the current implementation, NaN will be returned if x is NaN, but any other NaNs will be ignored.

#### math.modf

math.modf( x )

Returns two numbers, the integral part of x and the fractional part of x. For example, math.modf( 1.25 ) yields 1, 0.25.

#### math.pi

The value of ${\displaystyle \pi }$ .

#### math.pow

math.pow( x, y )

Equivalent to x^y.

math.rad( x )

Returns the angle x (given in degrees) in radians.

#### math.random

math.random( m, n )

Returns a pseudo-random number.

The arguments m and n may be omitted, but if specified must be convertible to integers.

• With no arguments, returns a real number in the range ${\displaystyle [0,1)}$
• With one argument, returns an integer in the range ${\displaystyle [1,m]}$
• With two arguments, returns an integer in the range ${\displaystyle [m,n]}$

#### math.randomseed

math.randomseed( x )

Sets x as the seed for the pseudo-random generator.

Note that using the same seed will cause math.random to output the same sequence of numbers.

#### math.sin

math.sin( x )

Returns the sine of x (given in radians).

#### math.sinh

math.sinh( x )

Returns the hyperbolic sine of x.

#### math.sqrt

math.sqrt( x )

Returns the square root of x. Equivalent to x^0.5.

#### math.tan

math.tan( x )

Returns the tangent of x (given in radians).

#### math.tanh

math.tanh( x )

Returns the hyperbolic tangent of x.

### Operating system library

#### os.clock

os.clock()

Returns an approximation of the amount in seconds of CPU time used by the program.

#### os.date

os.date( format, time )

Language library's formatDate may be used for more comprehensive date formatting

If time is given, it is the time to be formatted (see os.time()). Otherwise the current time is used.

もしformatの1文字目が '!' の場合、データはサーバのローカルの時間ではなく UTC rでフォーマットします。このオプションの文字に続いてフォーマットが文字列「*t」の場合、日付は以下のフィールドのあるテーブルを返します。

• year (full)
• month (1–12)
• day (1–31)
• hour (0–23)
• min (0–59)
• sec (0–60)
• wday (weekday, Sunday is 1)
• yday (day of the year)
• isdst (daylight saving flag, a boolean; may be absent if the information is not available)

If format is not "*t", then date returns the date as a string, formatted according to the same rules as the C function strftime.

#### os.difftime

os.difftime( t2, t1 )

Returns the number of seconds from t1 to t2.

#### os.time

os.time( table )

Returns a number representing the current time.

When called without arguments, returns the current time. If passed a table, the time encoded in the table will be parsed. The table must have the fields "year", "month", and "day", and may also include "hour" (default 12), "min" (default 0), "sec" (default 0), and "isdst".

### Package library

#### require

require( modulename )

First, it looks in package.loaded[modulename] to see if the module is already loaded. If so, returns package.loaded[modulename].

Otherwise, it calls each loader in the package.loaders sequence to attempt to find a loader for the module. If a loader is found, that loader is called. The value returned by the loader is stored into package.loaded[modulename] and is returned.

See the documentation for package.loaders for information on the loaders available.

For example, if you have a module "Module:Giving" containing the following:

local p = {}

p.someDataValue = 'Hello!'

return p


You can load this in another module with code such as this:

local giving = require( "Module:Giving" )

local value = giving.someDataValue -- value is now 'Hello!'


This table holds the loaded modules. The keys are the module names, and the values are the values returned when the module was loaded.

This table holds the sequence of searcher functions to use when loading modules. Each searcher function is called with a single argument, the name of the module to load. If the module is found, the searcher must return a function that will actually load the module and return the value to be returned by require. Otherwise, it must return nil.

Scribunto provides two searchers:

1. Look in package.preload[modulename] for the loader function
2. Look in the modules provided with Scribunto for the module name, and if that fails look in the Module: namespace. The "Module:" prefix must be provided.

Note that the standard Lua loaders are not included.

This table holds loader functions, used by the first searcher Scribunto includes in package.loaders.

#### package.seeall

package.seeall( table )

Sets the __index metamethod for table to _G.

### 文字列ライブラリ

すべての文字列関数では1文字目は C、PHP、JavaScript の position 0 ではなく position 1 です。索引はマイナスとなる場合があり、その場合は文字列末から数えます。文字列末尾は position -1 となり、-2 が末尾から2番目のように続きます。

Warning: The string library assumes one-byte character encodings. It cannot handle Unicode characters. To operate on Unicode strings, use the corresponding methods in the Scribunto Ustring library.

#### string.byte

string.byte( s, i, j )

If the string is considered as an array of bytes, returns the byte values for s[i], s[i+1], ···, s[j]. The default value for i is 1; the default value for j is i. Identical to mw.ustring.byte().

#### string.char

string.char( ... )

Receives zero or more integers. Returns a string with length equal to the number of arguments, in which each character has the byte value equal to its corresponding argument.

local value = string.char( 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21 ) --value is now 'Hello!'


See mw.ustring.char() for a similar function that uses Unicode codepoints rather than byte values.

#### string.find

string.find( s, pattern, init, plain )

Looks for the first match of pattern in the string s. If it finds a match, then find returns the offsets in s where this occurrence starts and ends; otherwise, it returns nil. If the pattern has captures, then in a successful match the captured values are also returned after the two indices.

A third, optional numerical argument init specifies where to start the search; its default value is 1 and can be negative. A value of true as a fourth, optional argument plain turns off the pattern matching facilities, so the function does a plain "find substring" operation, with no characters in pattern being considered "magic".

Note that if plain is given, then init must be given as well.

See mw.ustring.find() for a similar function extended as described in Ustring patterns and where the init offset is in characters rather than bytes.

#### string.format

string.format( formatstring, ... )

Returns a formatted version of its variable number of arguments following the description given in its first argument (which must be a string).

The format string uses a limited subset of the printf format specifiers:

• Recognized flags are '-', '+', ' ', '#', and '0'.
• Integer field widths up to 99 are supported. '*' is not supported.
• Integer precisions up to 99 are supported. '*' is not supported.
• Length modifiers are not supported.
• Recognized conversion specifiers are 'c', 'd', 'i', 'o', 'u', 'x', 'X', 'e', 'E', 'f', 'g', 'G', 's', '%', and the non-standard 'q'.
• Positional specifiers (e.g. "%2$s") are not supported. The conversion specifier 'q' is like 's', but formats the string in a form suitable to be safely read back by the Lua interpreter: the string is written between double quotes, and all double quotes, newlines, embedded zeros, and backslashes in the string are correctly escaped when written. Conversion between strings and numbers is performed as specified in Data types; other types are not automatically converted to strings. Strings containing NUL characters (byte value 0) are not properly handled. Identical to mw.ustring.format(). #### string.gmatch string.gmatch( s, pattern ) Returns an iterator function that, each time it is called, returns the next captures from pattern over string s. If pattern specifies no captures, then the whole match is produced in each call. For this function, a '^' at the start of a pattern is not magic, as this would prevent the iteration. It is treated as a literal character. See mw.ustring.gmatch() for a similar function for which the pattern is extended as described in Ustring patterns. #### string.gsub string.gsub( s, pattern, repl, n ) Returns a copy of s in which all (or the first n, if given) occurrences of the pattern have been replaced by a replacement string specified by repl, which can be a string, a table, or a function. gsub also returns, as its second value, the total number of matches that occurred. If repl is a string, then its value is used for replacement. The character % works as an escape character: any sequence in repl of the form %n, with n between 1 and 9, stands for the value of the n-th captured substring. The sequence %0 stands for the whole match, and the sequence %% stands for a single %. If repl is a table, then the table is queried for every match, using the first capture as the key; if the pattern specifies no captures, then the whole match is used as the key. If repl is a function, then this function is called every time a match occurs, with all captured substrings passed as arguments, in order; if the pattern specifies no captures, then the whole match is passed as a sole argument. If the value returned by the table query or by the function call is a string or a number, then it is used as the replacement string; otherwise, if it is false or nil, then there is no replacement (that is, the original match is kept in the string). See mw.ustring.gsub() for a similar function in which the pattern is extended as described in Ustring patterns. #### string.len string.len( s ) Returns the length of the string, in bytes. Is not confused by ASCII NUL characters. Equivalent to #s. See mw.ustring.len() for a similar function using Unicode codepoints rather than bytes. #### string.lower string.lower( s ) Returns a copy of this string with all ASCII uppercase letters changed to lowercase. All other characters are left unchanged. See mw.ustring.lower() for a similar function in which all characters with uppercase to lowercase definitions in Unicode are converted. #### string.match string.match( s, pattern, init ) Looks for the first match of pattern in the string. If it finds one, then match returns the captures from the pattern; otherwise it returns nil. If pattern specifies no captures, then the whole match is returned. A third, optional numerical argument init specifies where to start the search; its default value is 1 and can be negative. See mw.ustring.match() for a similar function in which the pattern is extended as described in Ustring patterns and the init offset is in characters rather than bytes. #### string.rep string.rep( s, n ) Returns a string that is the concatenation of n copies of the string s. Identical to mw.ustring.rep(). #### string.reverse string.reverse( s ) Returns a string that is the string s reversed (bytewise). #### string.sub string.sub( s, i, j ) Returns the substring of s that starts at i and continues until j; i and j can be negative. If j is nil or omitted, it will continue until the end of the string. Note that a string in Lua begins at index 1. Also, when using this function, the indices at both ends are inclusive. In particular, the call string.sub(s,1,j) returns a prefix of s with length j, and string.sub(s, -i) returns a suffix of s with length i. See mw.ustring.sub() for a similar function in which the offsets are characters rather than bytes. #### string.upper string.upper( s ) Returns a copy of this string with all ASCII lowercase letters changed to uppercase. All other characters are left unchanged. See mw.ustring.upper() for a similar function in which all characters with lowercase to uppercase definitions in Unicode are converted. #### Patterns Note that Lua's patterns are similar to regular expressions, but are not identical. In particular, note the following differences from regular expressions and PCRE: • The quoting character is percent (%), not backslash (\). • Dot (.) always matches all characters, including newlines. • No case-insensitive mode. • No alternation (the | operator). • Quantifiers (*, +, ?, and -) may only be applied to individual characters or character classes, not to capture groups. • The only non-greedy quantifier is -, which is equivalent to PCRE's *? quantifier. • No generalized finite quantifier (e.g. the {n,m} quantifier in PCRE). • The only zero-width assertions are ^, $, and the %f[set] "frontier" pattern; assertions such as PCRE's \b or (?=···) are not present.
• Patterns themselves do not recognize character escapes such as '\ddd'. However, since patterns are strings these sort of escapes may be used in the string literals used to create the pattern-string.

Also note that a pattern cannot contain embedded zero bytes (ASCII NUL, "\0"). Use %z instead.

Also see Ustring patterns for a similar pattern-matching scheme using Unicode characters.

##### Character class

A character class is used to represent a set of characters. The following combinations are allowed in describing a character class:

#### mw.isSubsting

mw.isSubsting()

Returns true if the current #invoke is being substed, false otherwise. See Returning text above for discussion on differences when substing versus not substing.

mw.loadData( module )

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

mw.loadData works like require(), with the following differences:

• The loaded module is evaluated only once per page, rather than once per {{#invoke:}} call.
• The loaded module is not recorded in package.loaded.
• The value returned from the loaded module must be a table. Other data types are not supported.
• The returned table (and all subtables) may contain only booleans, numbers, strings, and other tables. Other data types, particularly functions, are not allowed.
• The returned table (and all subtables) may not have a metatable.
• All table keys must be booleans, numbers, or strings.
• The table actually returned by mw.loadData() has metamethods that provide read-only access to the table returned by the module. Since it does not contain the data directly, pairs() and ipairs() will work but other methods, including #value, next(), and the functions in the Table library, will not work correctly.

The hypothetical unit-conversion module mentioned above might store its code in "Module:Convert" and its data in "Module:Convert/data", and "Module:Convert" would use local data = mw.loadData( 'Module:Convert/data' ) to efficiently load the data.

#### mw.dumpObject

mw.dumpObject( object )

Serializes object to a human-readable representation, then returns the resulting string.

#### mw.log

mw.log( ... )

Passes the arguments to mw.allToString(), then appends the resulting string to the log buffer.

In the debug console, the function print() is an alias for this function.

#### mw.logObject

mw.logObject( object )
mw.logObject( object, prefix )

Calls mw.dumpObject() and appends the resulting string to the log buffer. If prefix is given, it will be added to the log buffer followed by an equals sign before the serialized string is appended (i.e. the logged text will be "prefix = object-string").

### Frame object

The frame object is the interface to the parameters passed to {{#invoke:}}, and to the parser.

Note that there is no frame library, and there is no global variable named frame. A frame object is typically obtained by being passed as a parameter to the function called by {{#invoke:}}, and can also be obtained from mw.getCurrentFrame().

#### frame.args

A table for accessing the arguments passed to the frame. For example, if a module is called from wikitext with

{{#invoke:module|function|arg1|arg2|name=arg3}}


then frame.args[1] will return "arg1", frame.args[2] will return "arg2", and frame.args['name'] (or frame.args.name) will return "arg3". It is also possible to iterate over arguments using pairs( frame.args ) or ipairs( frame.args ). However, due to how Lua implements table iterators, iterating over arguments will return them in an unspecified order, and there's no way to know the original order as they appear in wikitext.

Note that values in this table are always strings; tonumber() may be used to convert them to numbers, if necessary. Keys, however, are numbers even if explicitly supplied in the invocation: {{#invoke:module|function|1|2=2}} gives string values "1" and "2" indexed by numeric keys 1 and 2.

As in MediaWiki template invocations, named arguments will have leading and trailing whitespace removed from both the name and the value before they are passed to Lua, whereas unnamed arguments will not have whitespace stripped.

For performance reasons, frame.args uses a metatable, rather than directly containing the arguments. Argument values are requested from MediaWiki on demand. This means that most other table methods will not work correctly, including #frame.args, next( frame.args ), and the functions in the Table library.

If preprocessor syntax such as template invocations and triple-brace arguments are included within an argument to #invoke, they will not be expanded, after being passed to Lua, until their values are being requested in Lua. If certain special tags written in XML notation, such as <pre>, <nowiki>, <gallery> and <ref>, are included as arguments to #invoke, then these tags will be converted to "strip markers" — special strings which begin with a delete character (ASCII 127), to be replaced with HTML after they are returned from #invoke.

#### frame:callParserFunction

frame:callParserFunction( name, args )
frame:callParserFunction( name, ... )
frame:callParserFunction{ name = string, args = table }

Note the use of named arguments.

Call a parser function, returning an appropriate string. Whenever possible, native Lua functions or Scribunto library functions should be preferred to this interface.

The following calls are approximately equivalent to the indicated wikitext:

-- {{ns:0}}
frame:callParserFunction{ name = 'ns', args = 0 }

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

-- {{#tag:ref|some text|name=foo|group=bar}}
frame:callParserFunction{ name = '#tag:ref', args = {
'some text', name = 'foo', group = 'bar'
} }


Note that, as with frame:expandTemplate(), the function name and arguments are not preprocessed before being passed to the parser function.

#### frame:expandTemplate

frame:expandTemplate{ title = title, args = table }

Note the use of named arguments.

This is transclusion. The call

frame:expandTemplate{ title = 'template', args = { 'arg1', 'arg2', name = 'arg3' } }


does roughly the same thing from Lua that {{template|arg1|arg2|name=arg3}} does in wikitext. As in transclusion, if the passed title does not contain a namespace prefix it will be assumed to be in the Template: namespace.

Note that the title and arguments are not preprocessed before being passed into the template:

-- This is roughly equivalent to wikitext like {{template|{{!}}}}
frame:expandTemplate{ title = 'template', args = { '|' } }

-- This is roughly equivalent to wikitext like {{template|{{((}}!{{))}}}}
frame:expandTemplate{ title = 'template', args = { '{{!}}' } }


#### frame:extensionTag

frame:extensionTag( name, content, args )
frame:extensionTag{ name = string, content = string, args = table_or_string }

This is equivalent to a call to frame:callParserFunction() with function name '#tag:' .. name and with content prepended to args.

-- These are equivalent
frame:extensionTag{ name = 'ref', content = 'some text', args = { name = 'foo', group = 'bar' } }
frame:extensionTag( 'ref', 'some text', { name = 'foo', group = 'bar' } )

frame:callParserFunction{ name = '#tag:ref', args = {
'some text', name = 'foo', group = 'bar'
} }

-- These are equivalent
frame:extensionTag{ name = 'ref', content = 'some text', args = 'some other text' }
frame:callParserFunction{ name = '#tag:ref', args = {
'some text', 'some other text'
} }


#### frame:getParent

frame:getParent()

Called on the frame created by {{#invoke:}}, returns the frame for the page that called {{#invoke:}}. Called on that frame, returns nil.

For instance, if the template {{Example}} contains the code {{#invoke:ModuleName}}, and a page transcludes that template and supplies arguments to it ({{Example|arg1|arg2}}), calling mw.getCurrentFrame():getParent().args[1], mw.getCurrentFrame():getParent().args[2] in Module:ModuleName will return "arg1", "arg2".

#### frame:getTitle

frame:getTitle()

Returns the title associated with the frame as a string. For the frame created by {{#invoke:}}, this is the title of the module invoked.

#### frame:newChild

frame:newChild{ title = title, args = table }

Note the use of named arguments.

Create a new Frame object that is a child of the current frame, with optional arguments and title.

This is mainly intended for use in the debug console for testing functions that would normally be called by {{#invoke:}}. The number of frames that may be created at any one time is limited.

#### frame:preprocess

frame:preprocess( string )
frame:preprocess{ text = string }

This expands wikitext in the context of the frame, i.e. templates, parser functions, and parameters such as {{{1}}} are expanded. Certain special tags written in XML-style notation, such as <pre>, <nowiki>, <gallery> and <ref>, will be replaced with "strip markers" — special strings which begin with a delete character (ASCII 127), to be replaced with HTML after they are returned from #invoke.

If you are expanding a single template, use frame:expandTemplate instead of trying to construct a wikitext string to pass to this method. It's faster and less prone to error if the arguments contain pipe characters or other wikimarkup.

If you are expanding a single parser function, use frame:callParserFunction for the same reasons.

#### frame:getArgument

frame:getArgument( arg )
frame:getArgument{ name = arg }

Gets an object for the specified argument, or nil if the argument is not provided.

The returned object has one method, object:expand(), that returns the expanded wikitext for the argument.

#### frame:newParserValue

frame:newParserValue( text )
frame:newParserValue{ text = text }

Returns an object with one method, object:expand(), that returns the result of frame:preprocess( text ).

#### frame:newTemplateParserValue

frame:newTemplateParserValue{ title = title, args = table }

Note the use of named arguments.

Returns an object with one method, object:expand(), that returns the result of frame:expandTemplate called with the given arguments.

#### frame:argumentPairs

frame:argumentPairs()

Same as pairs( frame.args ). Included for backwards compatibility.

### Hash library

#### mw.hash.hashValue

mw.hash.hashValue( algo, value )

Hashes a string value with the specified algorithm. Valid algorithms may be fetched using mw.hash.listAlgorithms().

#### mw.hash.listAlgorithms

mw.hash.listAlgorithms()

Returns a list of supported hashing algorithms, for use in mw.hash.hashValue().

### HTML library

mw.html is a fluent interface for building complex HTML from Lua. A mw.html object can be created using mw.html.create.

Functions documented as mw.html.name are available on the global mw.html table; functions documented as mw.html:name and html:name are methods of an mw.html object (see mw.html.create).

A basic example could look like this:

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


#### mw.html.create

mw.html.create( tagName, args )

Creates a new mw.html object containing a tagName html element. You can also pass an empty string or nil as tagName in order to create an empty mw.html object.

args can be a table with the following keys:

• args.selfClosing: Force the current tag to be self-closing, even if mw.html doesn't recognize it as self-closing
• args.parent: Parent of the current mw.html instance (intended for internal usage)

#### mw.html:node

html:node( builder )

Appends a child mw.html (builder) node to the current mw.html instance. If a nil parameter is passed, this is a no-op. A (builder) node is a string representation of an html element.

#### mw.html:wikitext

html:wikitext( ... )

Appends an undetermined number of wikitext strings to the mw.html object.

Note that this stops at the first nil item.

#### mw.html:newline

html:newline()

Appends a newline to the mw.html object.

#### mw.html:tag

html:tag( tagName, args )

Appends a new child node with the given tagName to the builder, and returns a mw.html instance representing that new node. The args parameter is identical to that of mw.html.create

#### mw.html:attr

html:attr( name, value )
html:attr( table )

Set an HTML attribute with the given name and value on the node. Alternatively a table holding name->value pairs of attributes to set can be passed. In the first form, a value of nil causes any attribute with the given name to be unset if it was previously set.

#### mw.html:getAttr

html:getAttr( name )

Get the value of a html attribute previously set using html:attr() with the given name.

html:addClass( class )

Adds a class name to the node's class attribute. If a nil parameter is passed, this is a no-op.

#### mw.html:css

html:css( name, value )
html:css( table )

Set a CSS property with the given name and value on the node. Alternatively a table holding name->value pairs of properties to set can be passed. In the first form, a value of nil causes any property with the given name to be unset if it was previously set.

#### mw.html:cssText

html:cssText( css )

Add some raw css to the node's style attribute. If a nil parameter is passed, this is a no-op.

#### mw.html:done

html:done()

Returns the parent node under which the current node was created. Like jQuery.end, this is a convenience function to allow the construction of several child nodes to be chained together into a single statement.

#### mw.html:allDone

html:allDone()

Like html:done(), but traverses all the way to the root node of the tree and returns it.

### Language library

Language codes are described at language code. Many of MediaWiki's language codes are similar to IETF language tags, but not all MediaWiki language codes are valid IETF tags or vice versa.

Functions documented as mw.language.name are available on the global mw.language table; functions documented as mw.language:name and lang:name are methods of a language object (see mw.language.new or mw.language.getContentLanguage).

#### mw.language.fetchLanguageName

mw.language.fetchLanguageName( code, inLanguage )

The full name of the language for the given language code: native name (language autonym) by default, name translated in target language if a value is given for inLanguage.

#### mw.language.fetchLanguageNames

mw.language.fetchLanguageNames()
mw.language.fetchLanguageNames( inLanguage )
mw.language.fetchLanguageNames( inLanguage, include )

Fetch the list of languages known to MediaWiki, returning a table mapping language code to language name.

By default the name returned is the language autonym; passing a language code for inLanguage returns all names in that language.

By default, only language names known to MediaWiki are returned; passing 'all' for include will return all available languages (e.g. from Extension:CLDR), while passing 'mwfile' will include only languages having customized messages included with MediaWiki core or enabled extensions. To explicitly select the default, 'mw' may be passed.

#### mw.language.getContentLanguage

mw.language.getContentLanguage()
mw.getContentLanguage()

Returns a new language object for the wiki's default content language.

#### mw.language.getFallbacksFor

Fallback chains

mw.language.getFallbacksFor( code )

Returns a list of MediaWiki's fallback language codes for the specified code.

#### mw.language.isKnownLanguageTag

mw.language.isKnownLanguageTag( code )

Returns true if a language code is known to MediaWiki.

A language code is "known" if it is a "valid built-in code" (i.e. it returns true for mw.language.isValidBuiltInCode) and returns a non-empty string for mw.language.fetchLanguageName.

#### mw.language.isSupportedLanguage

mw.language.isSupportedLanguage( code )

Checks whether any localisation is available for that language code in MediaWiki.

A language code is "supported" if it is a "valid" code (returns true for mw.language.isValidCode), contains no uppercase letters, and has a message file in the currently-running version of MediaWiki.

It is possible for a language code to be "supported" but not "known" (i.e. returning true for mw.language.isKnownLanguageTag). Also note that certain codes are "supported" despite mw.language.isValidBuiltInCode returning false.

#### mw.language.isValidBuiltInCode

mw.language.isValidBuiltInCode( code )

Returns true if a language code is of a valid form for the purposes of internal customisation of MediaWiki.

The code may not actually correspond to any known language.

A language code is a "valid built-in code" if it is a "valid" code (i.e. it returns true for mw.language.isValidCode); consists of only ASCII letters, numbers, and hyphens; and is at least two characters long.

Note that some codes are "supported" (i.e. returning true from mw.language.isSupportedLanguage) even though this function returns false.

#### mw.language.isValidCode

mw.language.isValidCode( code )

Returns true if a language code string is of a valid form, whether or not it exists. This includes codes which are used solely for customisation via the MediaWiki namespace.

The code may not actually correspond to any known language.

A language code is valid if it does not contain certain unsafe characters (colons, single- or double-quotes, slashs, backslashs, angle brackets, ampersands, or ASCII NULs) and is otherwise allowed in a page title.

#### mw.language.new

mw.language.new( code )
mw.getLanguage( code )

Creates a new language object. Language objects do not have any publicly accessible properties, but they do have several methods, which are documented below.

There is a limit on the number of distinct language codes that may be used on a page. Exceeding this limit will result in errors.

#### mw.language:getCode

lang:getCode()

Returns the language code for this language object.

#### mw.language:getFallbackLanguages

lang:getFallbackLanguages()

Returns a list of MediaWiki's fallback language codes for this language object. Equivalent to mw.language.getFallbacksFor( lang:getCode() ).

#### mw.language:isRTL

lang:isRTL()

Returns true if the language is written right-to-left, false if it is written left-to-right.

#### mw.language:lc

lang:lc( s )

Converts the string to lowercase, honoring any special rules for the given language.

When the Ustring library is loaded, the mw.ustring.lower() function is implemented as a call to mw.language.getContentLanguage():lc( s ).

#### mw.language:lcfirst

lang:lcfirst( s )

Converts the first character of the string to lowercase, as with lang:lc().

#### mw.language:uc

lang:uc( s )

Converts the string to uppercase, honoring any special rules for the given language.

When the Ustring library is loaded, the mw.ustring.upper() function is implemented as a call to mw.language.getContentLanguage():uc( s ).

#### mw.language:ucfirst

lang:ucfirst( s )

Converts the first character of the string to uppercase, as with lang:uc().

#### mw.language:caseFold

lang:caseFold( s )

Converts the string to a representation appropriate for case-insensitive comparison. Note that the result may not make any sense when displayed.

#### mw.language:formatNum

lang:formatNum( n )
lang:formatNum( n, options )

Formats a number with grouping and decimal separators appropriate for the given language. Given 123456.78, this may produce "123,456.78", "123.456,78", or even something like "١٢٣٬٤٥٦٫٧٨" depending on the language and wiki configuration.

The options is a table of options, which can be:

• noCommafy: Set true to omit grouping separators and use a dot (.) as the decimal separator.

Digit transformation may still occur, which may include transforming the decimal separator.

#### mw.language:formatDate

lang:formatDate( format, timestamp, local )

Formats a date according to the given format string. If timestamp is omitted, the default is the current time. The value for local must be a boolean or nil; if true, the time is formatted in the wiki's local time rather than in UTC.

The format string and supported values for timestamp are identical to those for the #time parser function from Extension:ParserFunctions. Note however that backslashes may need to be doubled in a Lua string literal, since Lua also uses backslash as an escape character while wikitext does not:

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

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

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


#### mw.language:formatDuration

lang:formatDuration( seconds )
lang:formatDuration( seconds, allowedIntervals )

Breaks a duration in seconds into more human-readable units, e.g. 12345 to 3 hours, 25 minutes and 45 seconds, returning the result as a string.

allowedIntervals, if given, is a table with values naming the interval units to use in the response. These include 'millennia', 'centuries', 'decades', 'years', 'weeks', 'days', 'hours', 'minutes', and 'seconds'.

#### mw.language:parseFormattedNumber

lang:parseFormattedNumber( s )

This takes a number as formatted by lang:formatNum() and returns the actual number. In other words, this is basically a language-aware version of tonumber().

#### mw.language:convertPlural

lang:convertPlural( n, ... )
lang:convertPlural( n, forms )
lang:plural( n, ... )
lang:plural( n, forms )

This chooses the appropriate grammatical form from forms (which must be a sequence table) or ... based on the number n. For example, in English you might use n .. ' ' .. lang:plural( n, 'sock', 'socks' ) or n .. ' ' .. lang:plural( n, { 'sock', 'socks' } ) to generate grammatically-correct text whether there is only 1 sock or 200 socks.

The necessary values for the sequence are language-dependent, see localization of magic words and translatewiki's FAQ on PLURAL for some details.

#### mw.language:convertGrammar

lang:convertGrammar( word, case )
lang:grammar( case, word )

Note the different parameter order between the two aliases. convertGrammar matches the order of the method of the same name on MediaWiki's Language object, while grammar matches the order of the parser function of the same name, documented at Special:MyLanguage/Help:Magic words#Localisation.

This chooses the appropriate inflected form of word for the given inflection code case.

The possible values for word and case are language-dependent, see Special:MyLanguage/Help:Magic words#Localisation and translatewiki:Grammar for some details.

#### mw.language:gender

lang:gender( what, masculine, feminine, neutral )
lang:gender( what, { masculine, feminine, neutral } )

Chooses the string corresponding to the gender of what, which may be "male", "female", or a registered user name.

#### mw.language:getArrow

lang:getArrow( direction )

Returns a Unicode arrow character corresponding to direction:

• forwards: Either "→" or "←" depending on the directionality of the language.
• backwards: Either "←" or "→" depending on the directionality of the language.
• left: "←"
• right: "→"
• up: "↑"
• down: "↓"

#### mw.language:getDir

lang:getDir()

Returns "ltr" or "rtl", depending on the directionality of the language.

#### mw.language:getDirMark

lang:getDirMark( opposite )

Returns a string containing either U+200E (the left-to-right mark) or U+200F (the right-to-left mark), depending on the directionality of the language and whether opposite is a true or false value.

#### mw.language:getDirMarkEntity

lang:getDirMarkEntity( opposite )

Returns "&lrm;" or "&rlm;", depending on the directionality of the language and whether opposite is a true or false value.

#### mw.language:getDurationIntervals

lang:getDurationIntervals( seconds )
lang:getDurationIntervals( seconds, allowedIntervals )

Breaks a duration in seconds into more human-readable units, e.g. 12345 to 3 hours, 25 minutes and 45 seconds, returning the result as a table mapping unit names to numbers.

For example,

{ ['hours'] = 3, ['minutes'] = 25, ['seconds'] = 45 }

allowedIntervals, if given, is a table with values naming the interval units to use in the response. These include 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', and 'seconds'.

The unit names in allowedIntervals may be specified in any order (currently in English only, indendantly of the language object used, and with their plural unabbreviated form only like in the returned table, where unit names are symbolic but still not translated and not grammatically changed according to their assigned value). If the input table contains only unsupported unit names, the returned table will be empty. If the input table is not specified, is nil, or is empty, a static table for any supported units (including 'seconds' for the shortest unit) will be used by default.

The specified duration in seconds is first rounded down to an integer number of the shortest desired unit. The number of members in the returned array is variable, and only unit names mapped to a non-zero value are kept in the returned table if the rounded number of seconds is strictly positive. Otherwise only the member for the shortest desired unit name ('seconds' by default) will be set to the rounded down duration.

### Message library

This library is an interface to the localisation messages and the MediaWiki: namespace.

Functions documented as mw.message.name are available on the global mw.message table; functions documented as mw.message:name and msg:name are methods of a message object (see mw.message.new).

#### mw.message.new

mw.message.new( key, ... )

Creates a new message object for the given message key. The remaining parameters are passed to the new object's params() method.

The message object has no properties, but has several methods documented below.

#### mw.message.newFallbackSequence

mw.message.newFallbackSequence( ... )

Creates a new message object for the given messages (the first one that exists will be used).

The message object has no properties, but has several methods documented below.

#### mw.message.newRawMessage

mw.message.newRawMessage( msg, ... )

Creates a new message object, using the given text directly rather than looking up an internationalized message. The remaining parameters are passed to the new object's params() method.

The message object has no properties, but has several methods documented below.

#### mw.message.rawParam

mw.message.rawParam( value )

Wraps the value so that it will not be parsed as wikitext by msg:parse().

#### mw.message.numParam

mw.message.numParam( value )

Wraps the value so that it will automatically be formatted as by lang:formatNum(). Note this does not depend on the Language library actually being available.

#### mw.message.getDefaultLanguage

mw.message.getDefaultLanguage()

Returns a Language object for the default language.

#### mw.message:params

msg:params( ... )
msg:params( params )

Add parameters to the message, which may be passed as individual arguments or as a sequence table. Parameters must be numbers, strings, or the special values returned by mw.message.numParam() or mw.message.rawParam(). If a sequence table is used, parameters must be directly present in the table; references using the __index metamethod will not work.

Returns the msg object, to allow for call chaining.

#### mw.message:rawParams

msg:rawParams( ... )
msg:rawParams( params )

Like :params(), but has the effect of passing all the parameters through mw.message.rawParam() first.

Returns the msg object, to allow for call chaining.

#### mw.message:numParams

msg:numParams( ... )
msg:numParams( params )

Like :params(), but has the effect of passing all the parameters through mw.message.numParam() first.

Returns the msg object, to allow for call chaining.

#### mw.message:inLanguage

msg:inLanguage( lang )

Specifies the language to use when processing the message. lang may be a string or a table with a getCode() method (i.e. a Language object).

The default language is the one returned by mw.message.getDefaultLanguage().

Returns the msg object, to allow for call chaining.

#### mw.message:useDatabase

msg:useDatabase( bool )

Specifies whether to look up messages in the MediaWiki: namespace (i.e. look in the database), or just use the default messages distributed with MediaWiki.

The default is true.

Returns the msg object, to allow for call chaining.

#### mw.message:plain

msg:plain()

Substitutes the parameters and returns the message wikitext as-is. Template calls and parser functions are intact.

#### mw.message:exists

msg:exists()

Returns a boolean indicating whether the message key exists.

#### mw.message:isBlank

msg:isBlank()

Returns a boolean indicating whether the message key has content. Returns true if the message key does not exist or the message is the empty string.

#### mw.message:isDisabled

msg:isDisabled()

Returns a boolean indicating whether the message key is disabled. Returns true if the message key does not exist or if the message is the empty string or the string "-".

### Site library

#### mw.site.currentVersion

A string holding the current version of MediaWiki.

#### mw.site.namespaces

Table holding data for all namespaces, indexed by number.

The data available is:

• id: Namespace number.
• name: Local namespace name.
• canonicalName: Canonical namespace name.
• displayName: Set on namespace 0, the name to be used for display (since the name is often the empty string).
• hasSubpages: Whether subpages are enabled for the namespace.
• hasGenderDistinction: Whether the namespace has different aliases for different genders.
• isCapitalized: Whether the first letter of pages in the namespace is capitalized.
• isContent: Whether this is a content namespace.
• isIncludable: Whether pages in the namespace can be transcluded.
• isMovable: Whether pages in the namespace can be moved.
• isSubject: Whether this is a subject namespace.
• isTalk: Whether this is a talk namespace.
• defaultContentModel: The default content model for the namespace, as a string.
• aliases: List of aliases for the namespace.
• subject: Reference to the corresponding subject namespace's data.
• talk: Reference to the corresponding talk namespace's data.
• associated: Reference to the associated namespace's data.

A metatable is also set that allows for looking up namespaces by name (localized or canonical). For example, both mw.site.namespaces[4] and mw.site.namespaces.Project will return information about the Project namespace.

#### mw.site.contentNamespaces

Table holding just the content namespaces, indexed by number. See mw.site.namespaces for details.

#### mw.site.subjectNamespaces

Table holding just the subject namespaces, indexed by number. See mw.site.namespaces for details.

#### mw.site.talkNamespaces

Table holding just the talk namespaces, indexed by number. See mw.site.namespaces for details.

#### mw.site.stats

Table holding site statistics. Available statistics are:

• pages: Number of pages in the wiki.
• articles: Number of articles in the wiki.
• files: Number of files in the wiki.
• edits: Number of edits in the wiki.
• users: Number of users in the wiki.
• activeUsers: Number of active users in the wiki.
• admins: Number of users in group 'sysop' in the wiki.

#### mw.site.stats.pagesInCategory

mw.site.stats.pagesInCategory( category, which )

This function is expensive

Gets statistics about the category. If which is unspecified, nil, or "*", returns a table with the following properties:

• all: Total pages, files, and subcategories.
• subcats: Number of subcategories.
• files: Number of files.
• pages: Number of pages.

If which is one of the above keys, just the corresponding value is returned instead.

Each new category queried will increment the expensive function count.

#### mw.site.stats.pagesInNamespace

mw.site.stats.pagesInNamespace( ns )

Returns the number of pages in the given namespace (specify by number).

#### mw.site.stats.usersInGroup

mw.site.stats.usersInGroup( group )

Returns the number of users in the given group.

#### mw.site.interwikiMap

mw.site.interwikiMap( filter )

Returns a table holding data about available interwiki prefixes. If filter is the string "local", then only data for local interwiki prefixes is returned. If filter is the string "!local", then only data for non-local prefixes is returned. If no filter is specified, data for all prefixes is returned. A "local" prefix in this context is one that is for the same project. For example, on the English Wikipedia, other-language Wikipedias are considered local, while Wiktionary and such are not.

Keys in the table returned by this function are interwiki prefixes, and the values are subtables with the following properties:

• prefix - the interwiki prefix.
• url - the URL that the interwiki points to. The page name is represented by the parameter $1. • isProtocolRelative - a boolean showing whether the URL is protocol-relative. • isLocal - whether the URL is for a site in the current project. • isCurrentWiki - whether the URL is for the current wiki. • isTranscludable - whether pages using this interwiki prefix are transcludable. This requires scary transclusion, which is disabled on Wikimedia wikis. • isExtraLanguageLink - whether the interwiki is listed in $wgExtraInterlanguageLinkPrefixes.
• displayText - for links listed in $wgExtraInterlanguageLinkPrefixes, this is the display text shown for the interlanguage link. Nil if not specified. • tooltip - for links listed in$wgExtraInterlanguageLinkPrefixes, this is the tooltip text shown when users hover over the interlanguage link. Nil if not specified.

### Text library

The text library provides some common text processing functions missing from the String library and the Ustring library. These functions are safe for use with UTF-8 strings.

#### mw.text.decode

mw.text.decode( s )
mw.text.decode( s, decodeNamedEntities )

Replaces HTML entities in the string with the corresponding characters.

If boolean decodeNamedEntities is omitted or false, the only named entities recognized are '&lt;', '&gt;', '&amp;', '&quot;', and '&nbsp;'. Otherwise, the list of HTML5 named entities to recognize is loaded from PHP's get_html_translation_table function.

#### mw.text.encode

mw.text.encode( s )
mw.text.encode( s, charset )

Replaces characters in a string with HTML entities. Characters '<', '>', '&', '"', and the non-breaking space are replaced with the appropriate named entities; all others are replaced with numeric entities.

If charset is supplied, it should be a string as appropriate to go inside brackets in a Ustring pattern, i.e. the "set" in [set]. The default charset is '<>&"\' ' (the space at the end is the non-breaking space, U+00A0).

#### mw.text.jsonDecode

mw.text.jsonDecode( s )
mw.text.jsonDecode( s, flags )

Decodes a JSON string. flags is 0 or a combination (use +) of the flags mw.text.JSON_PRESERVE_KEYS and mw.text.JSON_TRY_FIXING.

Normally JSON's zero-based arrays are renumbered to Lua one-based sequence tables; to prevent this, pass mw.text.JSON_PRESERVE_KEYS.

To relax certain requirements in JSON, such as no terminal comma in arrays or objects, pass mw.text.JSON_TRY_FIXING. This is not recommended.

Limitations:

• Decoded JSON arrays may not be Lua sequences if the array contains null values.
• JSON objects will drop keys having null values.
• It is not possible to directly tell whether the input was a JSON array or a JSON object with sequential integer keys.
• A JSON object having sequential integer keys beginning with 1 will decode to the same table structure as a JSON array with the same values, despite these not being at all equivalent, unless mw.text.JSON_PRESERVE_KEYS is used.

#### mw.text.jsonEncode

mw.text.jsonEncode( value )
mw.text.jsonEncode( value, flags )

Encode a JSON string. Errors are raised if the passed value cannot be encoded in JSON. flags is 0 or a combination (use +) of the flags mw.text.JSON_PRESERVE_KEYS and mw.text.JSON_PRETTY.

Normally Lua one-based sequence tables are encoded as JSON zero-based arrays; when mw.text.JSON_PRESERVE_KEYS is set in flags, zero-based sequence tables are encoded as JSON arrays.

Limitations:

• Empty tables are always encoded as empty arrays ([]), not empty objects ({}).
• Sequence tables cannot be encoded as JSON objects without adding a "dummy" element.
• To produce objects or arrays with nil values, a tricky implementation of the __pairs metamethod is required.
• A Lua table having sequential integer keys beginning with 0 will encode as a JSON array, the same as a Lua table having integer keys beginning with 1, unless mw.text.JSON_PRESERVE_KEYS is used.
• When both a number and the string representation of that number are used as keys in the same table, behavior is unspecified.

#### mw.text.killMarkers

mw.text.killMarkers( s )

Removes all MediaWiki strip markers from a string.

#### mw.text.listToText

mw.text.listToText( list )
mw.text.listToText( list, separator, conjunction )

Joins a list, prose-style. In other words, it's like table.concat() but with a different separator before the final item.

The default separator is taken from MediaWiki:comma-separator in the wiki's content language, and the default conjunction is MediaWiki:and concatenated with MediaWiki:word-separator.

Examples, using the default values for the messages:

 -- Returns the empty string
mw.text.listToText( {} )

-- Returns "1"
mw.text.listToText( { 1 } )

-- Returns "1 and 2"
mw.text.listToText( { 1, 2 } )

-- Returns "1, 2, 3, 4 and 5"
mw.text.listToText( { 1, 2, 3, 4, 5 } )

-- Returns "1; 2; 3; 4 or 5"
mw.text.listToText( { 1, 2, 3, 4, 5 }, '; ', ' or ' )


#### mw.text.nowiki

mw.text.nowiki( s )

Replaces various characters in the string with HTML entities to prevent their interpretation as wikitext. This includes:

• The following characters: '"', '&', "'", '<', '=', '>', '[', ']', '{', '|', '}'
• The following characters at the start of the string or immediately after a newline: '#', '*', ':', ';', space, tab ('\t')
• Blank lines will have one of the associated newline or carriage return characters escaped
• "----" at the start of the string or immediately after a newline will have the first '-' escaped
• "__" will have one underscore escaped
• "://" will have the colon escaped
• A whitespace character following "ISBN", "RFC", or "PMID" will be escaped

#### mw.text.split

mw.text.split( s, pattern, plain )

Splits the string into substrings at boundaries matching the Ustring pattern pattern. If plain is specified and true, pattern will be interpreted as a literal string rather than as a Lua pattern (just as with the parameter of the same name for mw.ustring.find()). Returns a table containing the substrings.

For example, mw.text.split( 'a b\tc\nd', '%s' ) would return a table { 'a', 'b', 'c', 'd' }.

If pattern matches the empty string, s will be split into individual characters.

#### mw.text.gsplit

mw.text.gsplit( s, pattern, plain )

Returns an iterator function that will iterate over the substrings that would be returned by the equivalent call to mw.text.split().

#### mw.text.tag

mw.text.tag( name, attrs, content )
mw.text.tag{ name = string, attrs = table, content = string|false }

Note the use of named arguments.

Generates an HTML-style tag for name.

If attrs is given, it must be a table with string keys. String and number values are used as the value of the attribute; boolean true results in the key being output as an HTML5 valueless parameter; boolean false skips the key entirely; and anything else is an error.

If content is not given (or is nil), only the opening tag is returned. If content is boolean false, a self-closed tag is returned. Otherwise it must be a string or number, in which case that content is enclosed in the constructed opening and closing tag. Note the content is not automatically HTML-encoded; use mw.text.encode() if needed.

For properly returning extension tags such as <ref>, use frame:extensionTag() instead.

#### mw.text.trim

mw.text.trim( s )
mw.text.trim( s, charset )

Remove whitespace or other characters from the beginning and end of a string.

If charset is supplied, it should be a string as appropriate to go inside brackets in a Ustring pattern, i.e. the "set" in [set]. The default charset is ASCII whitespace, "\t\r\n\f ".

#### mw.text.truncate

mw.text.truncate( text, length )
mw.text.truncate( text, length, ellipsis )
mw.text.truncate( text, length, ellipsis, adjustLength )

Truncates text to the specified length, adding ellipsis if truncation was performed. If length is positive, the end of the string will be truncated; if negative, the beginning will be removed. If adjustLength is given and true, the resulting string including ellipsis will not be longer than the specified length.

The default value for ellipsis is taken from MediaWiki:ellipsis in the wiki's content language.

Examples, using the default "..." ellipsis:

-- Returns "foobarbaz"
mw.text.truncate( "foobarbaz", 9 )

-- Returns "fooba..."
mw.text.truncate( "foobarbaz", 5 )

-- Returns "...arbaz"
mw.text.truncate( "foobarbaz", -5 )

-- Returns "foo..."
mw.text.truncate( "foobarbaz", 6, nil, true )

-- Returns "foobarbaz", because that's shorter than "foobarba..."
mw.text.truncate( "foobarbaz", 8 )


#### mw.text.unstripNoWiki

mw.text.unstripNoWiki( s )

Replaces MediaWiki <nowiki> strip markers with the corresponding text. Other types of strip markers are not changed.

#### mw.text.unstrip

mw.text.unstrip( s )

Equivalent to mw.text.killMarkers( mw.text.unstripNoWiki( s ) ).

This no longer reveals the HTML behind special page transclusion, <ref> tags, and so on as it did in earlier versions of Scribunto.

### Title library

#### mw.title.equals

mw.title.equals( a, b )

Test for whether two titles are equal. Note that fragments are ignored in the comparison.

#### mw.title.compare

mw.title.compare( a, b )

Returns -1, 0, or 1 to indicate whether the title a is less than, equal to, or greater than title b.

This compares titles by interwiki prefix (if any) as strings, then by namespace number, then by the unprefixed title text as a string. These string comparisons use Lua's standard < operator.

#### mw.title.getCurrentTitle

mw.title.getCurrentTitle()

Returns the title object for the current page.

#### mw.title.new

mw.title.new( text, namespace )
mw.title.new( id )

This function is expensive when called with an ID

Creates a new title object.

If a number id is given, an object is created for the title with that page_id. The title referenced will be counted as linked from the current page. If the page_id does not exist, returns nil. The expensive function count will be incremented if the title object created is not for a title that has already been loaded.

If a string text is given instead, an object is created for that title (even if the page does not exist). If the text string does not specify a namespace, namespace (which may be any key found in mw.site.namespaces) will be used. If the text is not a valid title, nil is returned.

#### mw.title.makeTitle

mw.title.makeTitle( namespace, title, fragment, interwiki )

Creates a title object with title title in namespace namespace, optionally with the specified fragment and interwiki prefix. namespace may be any key found in mw.site.namespaces. If the resulting title is not valid, returns nil.

Note that, unlike mw.title.new(), this method will always apply the specified namespace. For example, mw.title.makeTitle( 'Template', 'Module:Foo' ) will create an object for the page Template:Module:Foo, while mw.title.new( 'Module:Foo', 'Template' ) will create an object for the page Module:Foo.

#### Title objects

A title object has a number of properties and methods. Most of the properties are read-only.

Note that fields ending with text return titles as string values whereas the fields ending with title return title objects.

• id: The page_id. 0 if the page does not exist. This may be expensive.
• interwiki: The interwiki prefix, or the empty string if none.
• namespace: The namespace number.
• fragment: The fragment, or the empty string. May be assigned.
• nsText: The text of the namespace for the page.
• subjectNsText: The text of the subject namespace for the page.
• text: The title of the page, without the namespace or interwiki prefixes.
• prefixedText: The title of the page, with the namespace and interwiki prefixes.
• fullText: The title of the page, with the namespace and interwiki prefixes and the fragment. Interwiki is not returned if equal to the current.
• rootText: If this is a subpage, the title of the root page without prefixes. Otherwise, the same as title.text.
• baseText: If this is a subpage, the title of the page it is a subpage of without prefixes. Otherwise, the same as title.text.
• subpageText: If this is a subpage, just the subpage name. Otherwise, the same as title.text.
• canTalk: Whether the page for this title could have a talk page.
• exists: Whether the page exists. Alias for file.exists for Media-namespace titles. For File-namespace titles this checks the existence of the file description page, not the file itself. This may be expensive.
• file, fileExists: See #File metadata below.
• isContentPage: Whether this title is in a content namespace.
• isExternal: Whether this title has an interwiki prefix.
• isLocal: Whether this title is in this project. For example, on the English Wikipedia, any other Wikipedia is considered "local" while Wiktionary and such are not.
• isRedirect: Whether this is the title for a page that is a redirect. This may be expensive.
• isSpecialPage: Whether this is the title for a possible special page (i.e. a page in the Special: namespace).
• isSubpage: Whether this title is a subpage of some other title.
• isTalkPage: Whether this is a title for a talk page.
• isSubpageOf( title2 ): Whether this title is a subpage of the given title.
• inNamespace( ns ): Whether this title is in the given namespace. Namespaces may be specified by anything that is a key found in mw.site.namespaces.
• inNamespaces( ... ): Whether this title is in any of the given namespaces. Namespaces may be specified by anything that is a key found in mw.site.namespaces.
• hasSubjectNamespace( ns ): Whether this title's subject namespace is in the given namespace. Namespaces may be specified by anything that is a key found in mw.site.namespaces.
• contentModel: The content model for this title, as a string. This may be expensive.
• basePageTitle: The same as mw.title.makeTitle( title.namespace, title.baseText ).
• rootPageTitle: The same as mw.title.makeTitle( title.namespace, title.rootText ).
• talkPageTitle: The same as mw.title.makeTitle( mw.site.namespaces[title.namespace].talk.id, title.text ), or nil if this title cannot have a talk page.
• subjectPageTitle: The same as mw.title.makeTitle( mw.site.namespaces[title.namespace].subject.id, title.text ).
• redirectTarget: Returns a title object of the target of the redirect page if the page is a redirect and the page exists, returns false otherwise.
• protectionLevels: The page's protection levels. This is a table with keys corresponding to each action (e.g., "edit" and "move"). The table values are arrays, the first item of which is a string containing the protection level. If the page is unprotected, either the table values or the array items will be nil. This is expensive.
• cascadingProtection: The cascading protections applicable to the page. This is a table with keys "restrictions" (itself a table with keys like protectionLevels has) and "sources" (an array listing titles where the protections cascade from). If no protections cascade to the page, "restrictions" and "sources" will be empty. This is expensive.
• subPageTitle( text ): The same as mw.title.makeTitle( title.namespace, title.text .. '/' .. text ).
• partialUrl(): Returns title.text encoded as it would be in a URL.
• fullUrl( query, proto ): Returns the full URL (with optional query table/string) for this title. proto may be specified to control the scheme of the resulting url: "http", "https", "relative" (the default), or "canonical".
• localUrl( query ): Returns the local URL (with optional query table/string) for this title.
• canonicalUrl( query ): Returns the canonical URL (with optional query table/string) for this title.
• getContent(): Returns the (unparsed) content of the page, or nil if there is no page. The page will be recorded as a transclusion.

Title objects may be compared using relational operators. tostring( title ) will return title.prefixedText.

Since people find the fact surprising, note that accessing any expensive field on a title object records a "link" to the page (as shown on Special:WhatLinksHere, for example). Using the title object's getContent() method or accessing the redirectTarget field records it as a "参照読み込み", and accessing the title object's file or fileExists fields records it as a "ファイルへのリンク".

Title objects representing a page in the File or Media namespace will have a property called file. This is expensive. This is a table, structured as follows:

• exists: Whether the file exists. It will be recorded as an image usage. The fileExists property on a Title object exists for backwards compatibility reasons and is an alias for this property. If this is false, all other file properties will be nil.
• width: The width of the file. If the file contains multiple pages, this is the width of the first page.
• height: The height of the file. If the file contains multiple pages, this is the height of the first page.
• pages: If the file format supports multiple pages, this is a table containing tables for each page of the file; otherwise, it is nil. The # operator can be used to get the number of pages in the file. Each individual page table contains a width and height property.
• size: The size of the file in bytes.
• mimeType: The MIME type of the file.
##### Expensive properties

The properties id, isRedirect, exists, and contentModel require fetching data about the title from the database. For this reason, the expensive function count is incremented the first time one of them is accessed for a page other than the current page. Subsequent accesses of any of these properties for that page will not increment the expensive function count again.

Other properties marked as expensive will always increment the expensive function count the first time they are accessed for a page other than the current page.

### URI library

#### mw.uri.encode

mw.uri.encode( s, enctype )

Percent-encodes the string. The default type, "QUERY", encodes spaces using '+' for use in query strings; "PATH" encodes spaces as %20; and "WIKI" encodes spaces as '_'.

Note that the "WIKI" format is not entirely reversible, as both spaces and underscores are encoded as '_'.

#### mw.uri.decode

mw.uri.decode( s, enctype )

Percent-decodes the string. The default type, "QUERY", decodes '+' to space; "PATH" does not perform any extra decoding; and "WIKI" decodes '_' to space.

#### mw.uri.anchorEncode

mw.uri.anchorEncode( s )

Encodes a string for use in a MediaWiki URI fragment.

#### mw.uri.buildQueryString

mw.uri.buildQueryString( table )

Encodes a table as a URI query string. Keys should be strings; values may be strings or numbers, sequence tables, or boolean false.

#### mw.uri.parseQueryString

mw.uri.parseQueryString( s, i, j )

Decodes the query string s to a table. Keys in the string without values will have a value of false; keys repeated multiple times will have sequence tables as values; and others will have strings as values.

The optional numerical arguments i and j can be used to specify a substring of s to be parsed, rather than the entire string. i is the position of the first character of the substring, and defaults to 1. j is the position of the last character of the substring, and defaults to the length of the string. Both i and j can be negative, as in string.sub.

#### mw.uri.canonicalUrl

mw.uri.canonicalUrl( page, query )

Returns a URI object for the canonical URL for a page, with optional query string/table.

#### mw.uri.fullUrl

mw.uri.fullUrl( page, query )

Returns a URI object for the full URL for a page, with optional query string/table.

#### mw.uri.localUrl

mw.uri.localUrl( page, query )

Returns a URI object for the local URL for a page, with optional query string/table.

#### mw.uri.new

mw.uri.new( s )

Constructs a new URI object for the passed string or table. See the description of URI objects for the possible fields for the table.

#### mw.uri.validate

mw.uri.validate( table )

Validates the passed table (or URI object). Returns a boolean indicating whether the table was valid, and on failure a string explaining what problems were found.

#### URI object

The URI object has the following fields, some or all of which may be nil:

• protocol: String protocol/scheme
• user: String user
• host: String host name
• port: Integer port
• path: String path
• query: A table, as from mw.uri.parseQueryString
• fragment: String fragment.

The following properties are also available:

• userInfo: String user and password
• hostPort: String host and port
• authority: String user, password, host, and port
• queryString: String version of the query table
• relativePath: String path, query string, and fragment

tostring() will give the URI string.

Methods of the URI object are:

##### mw.uri:parse

uri:parse( s )

Parses a string into the current URI object. Any fields specified in the string will be replaced in the current object; fields not specified will keep their old values.

##### mw.uri:clone

uri:clone()

Makes a copy of the URI object.

##### mw.uri:extend

uri:extend( parameters )

Merges the parameters table into the object's query table.

### Ustring library

The ustring library is intended to be a direct reimplementation of the standard String library, except that the methods operate on characters in UTF-8 encoded strings rather than bytes.

Most functions will raise an error if the string is not valid UTF-8; exceptions are noted.

#### mw.ustring.maxPatternLength

The maximum allowed length of a pattern, in bytes.

#### mw.ustring.maxStringLength

The maximum allowed length of a string, in bytes.

#### mw.ustring.byte

mw.ustring.byte( s, i, j )

Returns individual bytes; identical to string.byte().

#### mw.ustring.byteoffset

mw.ustring.byteoffset( s, l, i )

Returns the byte offset of a character in the string. The default for both l and i is 1. i may be negative, in which case it counts from the end of the string.

The character at l == 1 is the first character starting at or after byte i; the character at l == 0 is the first character starting at or before byte i. Note this may be the same character. Greater or lesser values of l are calculated relative to these.

#### mw.ustring.char

mw.ustring.char( ... )

Much like string.char(), except that the integers are Unicode codepoints rather than byte values.

local value = mw.ustring.char( 0x41f, 0x440, 0x438, 0x432, 0x435, 0x442, 0x21 ) -- value is now 'Привет!'


#### mw.ustring.codepoint

mw.ustring.codepoint( s, i, j )

Much like string.byte(), except that the return values are codepoints and the offsets are characters rather than bytes.

#### mw.ustring.find

mw.ustring.find( s, pattern, init, plain )

Much like string.find(), except that the pattern is extended as described in Ustring patterns and the init offset is in characters rather than bytes.

#### mw.ustring.format

mw.ustring.format( format, ... )

Identical to string.format(). Widths and precisions for strings are expressed in bytes, not codepoints.

#### mw.ustring.gcodepoint

mw.ustring.gcodepoint( s, i, j )

Returns three values for iterating over the codepoints in the string. i defaults to 1, and j to -1. This is intended for use in the iterator form of for:

for codepoint in mw.ustring.gcodepoint( s ) do
-- block
end


#### mw.ustring.gmatch

mw.ustring.gmatch( s, pattern )

Much like string.gmatch(), except that the pattern is extended as described in Ustring patterns.

#### mw.ustring.gsub

mw.ustring.gsub( s, pattern, repl, n )

Much like string.gsub(), except that the pattern is extended as described in Ustring patterns.

#### mw.ustring.isutf8

mw.ustring.isutf8( s )

Returns true if the string is valid UTF-8, false if not.

#### mw.ustring.len

mw.ustring.len( s )

Returns the length of the string in codepoints, or nil if the string is not valid UTF-8.

See string.len() for a similar function that uses byte length rather than codepoints.

#### mw.ustring.lower

mw.ustring.lower( s )

Much like string.lower(), except that all characters with lowercase to uppercase definitions in Unicode are converted.

If the Language library is also loaded, this will instead call lc() on the default language object.

#### mw.ustring.match

mw.ustring.match( s, pattern, init )

Much like string.match(), except that the pattern is extended as described in Ustring patterns and the init offset is in characters rather than bytes.

#### mw.ustring.rep

mw.ustring.rep( s, n )

Identical to string.rep().

#### mw.ustring.sub

mw.ustring.sub( s, i, j )

Much like string.sub(), except that the offsets are characters rather than bytes.

#### mw.ustring.toNFC

mw.ustring.toNFC( s )

Converts the string to Normalization Form C. Returns nil if the string is not valid UTF-8.

#### mw.ustring.toNFD

mw.ustring.toNFD( s )

Converts the string to Normalization Form D. Returns nil if the string is not valid UTF-8.

#### mw.ustring.upper

mw.ustring.upper( s )

Much like string.upper(), except that all characters with uppercase to lowercase definitions in Unicode are converted.

If the Language library is also loaded, this will instead call uc() on the default language object.

#### Ustring patterns

Patterns in the ustring functions use the same syntax as the String library patterns. The major difference is that the character classes are redefined in terms of Unicode character properties:

• %a: represents all characters with General Category "Letter".
• %c: represents all characters with General Category "Control".
• %d: represents all characters with General Category "Number, decimal digit".
• %l: represents all characters with General Category "Lowercase Letter".
• %p: represents all characters with General Category "Punctuation".
• %s: represents all characters with General Category "Separator", plus tab, linefeed, carriage return, vertical tab, and form feed.
• %u: represents all characters with General Category "Uppercase Letter".
• %w: represents all characters with General Category "Letter" or "Decimal Number".
• %x: adds fullwidth character versions of the hex digits.

Like in String library patterns, %A, %C, %D, %L, %P, %S, %U および %W here represent the complementary set ("all characters without given General Category").

In all cases, characters are interpreted as Unicode characters instead of bytes, so ranges such as [０-９], patterns such as %b«», and quantifiers applied to multibyte characters will work correctly. Empty captures will capture the position in code points rather than bytes.

These libraries are not included by default, but if needed may be loaded using require().

### bit32

This emulation of the Lua 5.2 bit32 library may be loaded using

bit32 = require( 'bit32' )


The bit32 library provides bitwise operations on unsigned 32-bit integers. Input numbers are truncated to integers (in an unspecified manner) and reduced modulo 232 so the value is in the range 0 to 232−1; return values are also in this range.

When bits are numbered (as in bit32.extract()), 0 is the least-significant bit (the one with value 20) and 31 is the most-significant (the one with value 231).

#### bit32.band

bit32.band( ... )

Returns the bitwise AND of its arguments: the result has a bit set only if that bit is set in all of the arguments.

If given zero arguments, the result has all bits set.

#### bit32.bnot

bit32.bnot( x )

Returns the bitwise complement of x.

#### bit32.bor

bit32.bor( ... )

Returns the bitwise OR of its arguments: the result has a bit set if that bit is set in any of the arguments.

If given zero arguments, the result has all bits clear.

#### bit32.btest

bit32.btest( ... )

Equivalent to bit32.band( ... ) ~= 0

#### bit32.bxor

bit32.bxor( ... )

Returns the bitwise XOR of its arguments: the result has a bit set if that bit is set in an odd number of the arguments.

If given zero arguments, the result has all bits clear.

#### bit32.extract

bit32.extract( n, field, width )

Extracts width bits from n, starting with bit field. Accessing bits outside of the range 0 to 31 is an error.

If not specified, the default for width is 1.

#### bit32.replace

bit32.replace( n, v, field, width )

Replaces width bits in n, starting with bit field, with the low width bits from v. Accessing bits outside of the range 0 to 31 is an error.

If not specified, the default for width is 1.

#### bit32.lshift

bit32.lshift( n, disp )

Returns the number n shifted disp bits to the left. This is a logical shift: inserted bits are 0. This is generally equivalent to multiplying by 2disp.

Note that a displacement over 31 will result in 0.

#### bit32.rshift

bit32.rshift( n, disp )

Returns the number n shifted disp bits to the right. This is a logical shift: inserted bits are 0. This is generally equivalent to dividing by 2disp.

Note that a displacement over 31 will result in 0.

#### bit32.arshift

bit32.arshift( n, disp )

Returns the number n shifted disp bits to the right. This is an arithmetic shift: if disp is positive, the inserted bits will be the same as bit 31 in the original number.

Note that a displacement over 31 will result in 0 or 4294967295.

#### bit32.lrotate

bit32.lrotate( n, disp )

Returns the number n rotated disp bits to the left.

Note that rotations are equivalent modulo 32: a rotation of 32 is the same as a rotation of 0, 33 is the same as 1, and so on.

#### bit32.rrotate

bit32.rrotate( n, disp )

Returns the number n rotated disp bits to the right.

Note that rotations are equivalent modulo 32: a rotation of 32 is the same as a rotation of 0, 33 is the same as 1, and so on.

### libraryUtil

This library contains methods useful when implementing Scribunto libraries. It may be loaded using

libraryUtil = require( 'libraryUtil' )


#### libraryUtil.checkType

libraryUtil.checkType( name, argIdx, arg, expectType, nilOk )

Raises an error if type( arg ) does not match expectType. In addition, no error will be raised if arg is nil and nilOk is true.

name is the name of the calling function, and argIdx is the position of the argument in the argument list. These are used in formatting the error message.

#### libraryUtil.checkTypeMulti

libraryUtil.checkTypeMulti( name, argIdx, arg, expectTypes )

Raises an error if type( arg ) does not match any of the strings in the array expectTypes.

This is for arguments that have more than one valid type.

#### libraryUtil.checkTypeForIndex

libraryUtil.checkTypeForIndex( index, value, expectType )

Raises an error if type( value ) does not match expectType.

This is intended for use in implementing a __newindex metamethod.

#### libraryUtil.checkTypeForNamedArg

libraryUtil.checkTypeForNamedArg( name, argName, arg, expectType, nilOk )

Raises an error if type( arg ) does not match expectType. In addition, no error will be raised if arg is nil and nilOk is true.

This is intended to be used as an equivalent to libraryUtil.checkType() in methods called using Lua's "named argument" syntax, func{ name = value }.

#### libraryUtil.makeCheckSelfFunction

libraryUtil.makeCheckSelfFunction( libraryName, varName, selfObj, selfObjDesc )

This is intended for use in implementing "methods" on object tables that are intended to be called with the obj:method() syntax. It returns a function that should be called at the top of these methods with the self argument and the method name, which will raise an error if that self object is not selfObj.

This function will generally be used in a library's constructor function, something like this:

 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


### luabit

The luabit library modules "bit" and "hex" may be loaded using

bit = require( 'luabit.bit' )
hex = require( 'luabit.hex' )


Note that the bit32 library contains the same operations as "luabit.bit", and the operations in "luabit.hex" may be performed using string.format() and tonumber().

The luabit module "noki" is not available, as it is entirely useless in Scribunto. The luabit module "utf8" is also not available, as it was considered redundant to the Ustring library.

### ustring

The pure-Lua backend to the Ustring library may be loaded using

ustring = require( 'ustring' )


In all cases the Ustring library (mw.ustring) should be used instead, as that replaces many of the slower and more memory-intensive operations with callbacks into PHP code.

## 拡張機能ライブラリ

Some MediaWiki extensions provide additional Scribunto libraries. These are also located in the table mw, usually in the table mw.ext, however, they are only present when certain extensions are installed (in addition to the Scribunto extension itself).

Such extensions use Scribunto provided hooks:

Writing Scribunto libraries provides information on how such libraries can be developed to provide Lua interfaces for MediaWiki extensions.

The following libraries are planned, or are in Gerrit pending review.

• (none at this time)

### mw.wikibase

Wikibase Client provides access to localizable structured data. See Extension:Wikibase Client/Lua. This is supported by Wikidata.

### mw.wikibase.lexeme

WikibaseLexeme provides access to Wikibase Lexeme entities. This is supported by Wikidata:Lexicographical data.

### mw.wikibase.mediainfo

WikibaseMediaInfo provides access to Wikibase MediaInfo entities. See Extension:WikibaseMediaInfo/Lua. This is supported by Structured Data on Commons. See Commons:Structured data/Lua.

### mw.bcmath

BCmath provides arbitrary-precision arithmetic to Lua modules. See BCmath documentation via "LDoc" link at Extension:BCmath#Usage.

### mw.smw

Semantic Scribunto provides native support for the Scribunto extension to Semantic MediaWiki extension.

### mw.ext.data

JsonConfig provides access to localizable tabular and map data. See Extension:JsonConfig/Tabular. Tabular Data and GeoJSON Map Data is supported in Commons "Data:" namespace.

### mw.ext.cargo

Cargo provides a means to query its data store from Lua. See Extension:Cargo/Other features#Lua support.

### mw.ext.cattools

CategoryToolbox provides a means to check from Lua if a certain page belongs to a category

### mw.ext.FlaggedRevs

FlaggedRevs provides a means to access the stability settings of a page from Lua.

### mw.ext.TitleBlacklist

TitleBlacklist provides a means to test and obtain information about blacklisted page naming entries from Lua.

### mw.ext.ParserFunctions

ParserFunctions provides a means to evaluate a parser function expressions from Lua.

### mw.ext.articlePlaceholder

ArticlePlaceholder provides a means to override default Wikibase renderings from Lua. See Extension:ArticlePlaceholder/Module:AboutTopic.

### mw.ext.externalData

ExternalData provides a means to get structured data from Internet from Lua. See Extension:External Data#Scribunto/Lua.

## 標準のLuaとの差分

### 変更された関数

setfenv()
getfenv()
May not be available, depending on the configuration. If available, attempts to access parent environments will fail.
getmetatable()
tostring()
Pointer addresses of tables and functions are not provided. This is to make memory corruption vulnerabilities more difficult to exploit.
pairs()
ipairs()
Support for the __pairs and __ipairs metamethods (added in Lua 5.2) has been added.
pcall()
xpcall()
Certain internal errors cannot be intercepted.
require()
Can fetch certain built-in modules distributed with Scribunto, as well as modules present in the Module namespace of the wiki. To fetch wiki modules, use the full page name including the namespace. Cannot otherwise access the local filesystem.

### 削除された関数とパッケージ

package.*
Filesystem and C library access has been removed. Available functions and tables are:
package.seeall()
os.*
There are some insecure functions in here, such as os.execute(), which can't be allowed. Available functions are:
os.clock()
os.date()
os.difftime()
os.time()
debug.*
Most of the functions are insecure. Available functions are:
debug.traceback()

collectgarbage()
module()
coroutine.*
No application is known for us, so it has not been reviewed for security.
dofile()
io.*, file.*
Allows local filesystem access, which is insecure.
These were omitted to allow for static analysis of the Lua source code. Also, allowing these would allow Lua code to be added directly to article and template pages, which was not desired for usability reasons.
print()
This was discussed on wikitech-l and it was decided that it should be omitted in favour of return values, to improve code quality. If necessary, mw.log() may be used to output information to the debug console.
string.dump()
May expose private data from parent environments.

Referential data structures
Circular data structures and data structures where the same node may be reached by more than one path cannot be correctly sent to PHP. Attempting to do so will cause undefined behavior. This includes (but is not limited to) returning such data structures from the module called by {{#invoke:}} and passing such data structures as parameters to Scribunto library functions that are implemented as callbacks into PHP.

Such data structures may be used freely within Lua, including as the return values of modules loaded with mw.loadData().

## Writing Scribunto libraries

This information is useful to developers writing additional Scribunto libraries, whether for inclusion in Scribunto itself or for providing an interface for their own extensions.

A Scribunto library will generally consist of five parts:

• The PHP portion of the library.
• The Lua portion of the library.
• The PHP portion of the test cases.
• The Lua portion of the test cases.
• The documentation.

Existing libraries serve as a good example.

The PHP portion of the library is a class that must extend Scribunto_LuaLibraryBase. See the documentation for that class for implementation details. In the Scribunto extension, this file should be placed in engines/LuaCommon/NameLibrary.php, and a mapping added to Scribunto_LuaEngine::$libraryClasses. Other extensions should use the ScribuntoExternalLibraries hook. In either case, the key should match the Lua module name ("mw.name" for libraries in Scribunto, or "mw.ext.name" for extension libraries). The Lua portion of the library sets up the table containing the functions that can be called from Lua modules. In the Scribunto extension, the file should be placed in engines/LuaCommon/lualib/mw.name.lua. This file should generally include boilerplate something like this: local object = {} local php function object.setupInterface( options ) -- Remove setup function object.setupInterface = nil -- Copy the PHP callbacks to a local variable, and remove the global php = mw_interface mw_interface = nil -- Do any other setup here -- Install into the mw global mw = mw or {} mw.ext = mw.ext or {} mw.ext.NAME = object -- Indicate that we're loaded package.loaded['mw.ext.NAME'] = object end return object  The module in engines/LuaCommon/lualib/libraryUtil.lua (load this with local util = require 'libraryUtil') contains some functions that may be helpful. Be sure to run the Scribunto test cases with your library loaded, even if your library doesn't itself provide any test cases. The standard test cases include tests for things like libraries adding unexpected global variables. Also, if the library is loaded with PHP, any upvalues that its Lua functions have will not be reset between #invoke's. Care must be taken to ensure that modules can't abuse this to transfer information between #invoke's. ### Test cases The Scribunto extension includes a base class for test cases, Scribunto_LuaEngineTestBase, which will run the tests against both the LuaSandbox and LuaStandalone engines. The library's test case should extend this class, and should not override static function suite(). In the Scribunto extension, the test case should be in tests/engines/LuaCommon/NameLibraryTest.php and added to the array in ScribuntoHooks::unitTestsList() (in common/Hooks.php); extensions should add the test case in their own UnitTestsList hook function, probably conditional on whether $wgAutoloadClasses['Scribunto_LuaEngineTestBase'] is set.

Most of the time, all that is needed to make the test case is this:

class ClassNameTest extends Scribunto_LuaEngineTestBase {
protected static $moduleName = 'ClassNameTest'; function getTestModules() { return parent::getTestModules() + array( 'ClassNameTest' => __DIR__ . '/ClassNameTests.lua'; ); } }  This will load the file ClassNameTests.lua as if it were the page "Module:ClassNameTests", expecting it to return an object with the following properties: • count: Integer, number of tests • provide( n ): Function that returns three values: n, the name of test n, and a string that is the expected output for test n. • run( n ): Function that runs test n and returns one string. If getTestModules() is declared as shown, "Module:TestFramework" is available which provides many useful helper methods. If this is used, ClassNameTests.lua would look something like this: local testframework = require 'Module:TestFramework' return testframework.getTestProvider( { -- Tests go here } )  Each test is itself a table, with the following properties: • name: The name of the test. • func: The function to execute. • args: Optional table of arguments to pass to the function. • expect: Results to expect. • type: Optional "type" of the test, default is "Normal". The type controls the format of expect and how func is called. Included types are: • Normal: expect is a table of return values, or a string if the test should raise an error. func is simply called. • Iterator: expect is a table of tables of return values. func is called as with an iterated for loop, and each iteration's return values are accumulated. • ToString: Like "Normal", except each return value is passed through tostring(). #### Test cases in another extension There are (at least) two ways to run PHPUnit tests: 1. Run phpunit against core, allowing the tests/phpunit/suites/ExtensionsTestSuite.php to find the extension's tests using the UnitTestsList hook. If your extension's test class names all contain a unique component (e.g. the extension's name), the --filter option may be used to run only your extension's tests. 1. Run phpunit against the extension directory, where it will pick up any file ending in "Test.php". Either of these will work fine if Scribunto is loaded in LocalSettings.php. And it is easy for method #1 to work if Scribunto is not loaded, as the UnitTestsList hook can easily be written to avoid returning the Scribunto test when $wgAutoloadClasses['Scribunto_LuaEngineTestBase'] is not set.

But Jenkins uses method #2. For Jenkins to properly run the tests, you will need to add Scribunto as a dependency for your extension. See Gerrit change 56570 for an example of how this is done.

If for some reason you need the tests to be able to run using method #2 without Scribunto loaded, one workaround is to add this check to the top of your unit test file:

 if ( !isset( \$GLOBALS['wgAutoloadClasses']['Scribunto_LuaEngineTestBase'] ) ) {
return;
}


### 説明文書

Modules included in Scribunto should include documentation in the Scribunto libraries section above. Extension libraries should include documentation in a subpage of their own extension page, and link to that documentation from the Extension libraries subsection above.

## ライセンス

このマニュアルはMITライセンスの下で利用可能なLua 5.1 reference manualから派生したものです。

この派生マニュアルは同ライセンスの使用条件に基いて複製することが可能です。