Extension:Scribunto/Lua reference manual/ja

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

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

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

ただし "Bananas" を自分の Module の名前に置き換えてください. このコードは Module からエクスポートされた "hello" 関数を呼び出します. は、関数が返したテキスト（この場合は"Hello, world!"）に置き換えられます.

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

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

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

ウィキマークアップから与えられた値の参照
で呼び出された関数には、frame objectという1つのパラメータが渡されます. に渡されたパラメータにアクセスするために、コードは通常、そのフレームオブジェクトの テーブルを使用します. また、 を使ってそのフレームの にアクセスすることで、 を含むテンプレートに渡されたパラメータにアクセスすることも可能です.

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

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

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

他方、ウィキマークアップ  については処理動作のより早い段階で扱われるため、  に対しては   処理による代入動作だけが影響を持ちます. 処理が失敗した部分についてはウィキマークアップ上に残されることになっているので、それらは次回の「ソースを編集」の時に修正対応さることになるでしょうが、このような事態は避けるべきです.

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

これは、次のMediaWiki-namespace messagesを使用して構成できます:


 * —ドキュメントに使用されるページの名前を設定します. モジュールの名前（Module: prefixなし）は として渡されます.  モジュール名前空間内にある場合、ここで指定されたページはLuaソースではなくwikitextとして解釈され、 と一緒に使用することはできません.  既定では "Module:$1/doc"、つまりモジュールの /doc 下位ページが表示されます.  このメッセージでは、パーサー関数およびその他のブレース拡張を使用できない場合があることに注意してください.
 * — docページが存在しない場合に表示されるメッセージ. ページの名前は として渡されます.  既定値は空です.
 * — docページが存在する場合に表示されるメッセージです. ページの名前は として渡されます.  既定では、説明文書ページを参照読み込みします.
 * — ドキュメントページ自体を表示するときに表示されるヘッダー. ドキュメントを作成するモジュール（Module: prefix付き）の名前は、 として渡されます.  デフォルトでは、簡単な説明が斜体で表示されます.

モジュールのページにカテゴリタグやウィキ間リンクを直接追加することはできませんが、解説ページに$1タグの間に追加すれば、モジュールのページに自動的に呼び出される時に適用されます. これらは、ドキュメントページのタグ内に配置することができ、ドキュメントページがmoduleページにトランスクルードされたときに、moduleに適用されます.

トークン
Lua言語における名前（または識別子）とは数字以外ではじまる文字列で、アルファベット、数字、アンダースコアで構成されます. 名前は大文字と小文字を区別します. 、 、 は、それぞれ別の名前です.

以下のキーワードは予約されており、名前として使用できません.



アンダースコアと大文字ではじまる名前は Lua 内部の大域変数として予約されています.

その他のトークン:



コメント
注釈文は文字列の外側ならどこででも で始まります. の直後に開き長かっこがあれば、対応する閉じ長かっこまでがコメントです. そうでなければ行末までが注釈文となります.

データ型
Lua は動的型付け言語です. 変数や関数の引数は型を持たず、代入される値だけを持ちます. 値は型を保持します.

Lua には8つの基本的なデータ型がありますが、Scribunto 拡張機能に関係するのはそのうちの6つだけです. 関数は値の型を返します.

関数は値を文字列へ変換します. 関数は可能なら値を数値へ変換し、変換できないなら  を返します. その他のデータ型へ変換する明示的な関数はありません.

数値は、文字列が期待される場所では自動的に文字列へ変換されます. たとえば文字列連結演算子で. 文字列が算術演算子に使用される場合、 によって数値へ変換されます. 真偽値が期待される場所では、 以外の全ての値は   として扱われます.

nil
は値がないことを表すための特殊な値です.

はテーブルのキーとして使用されることはなく、キーが未割り当であることと、キーとして  が割り当てられていることは、同じことです.

文字列へ変換される場合、結果は  です. 真偽値へ変換される場合、 は   とみなされます.

真偽値
真偽値は  または   です.

文字列へ変換される場合は  または   となります.

他の言語と違って、真偽値が直接数値へ変換されることはありません. また、 と   だけが偽値と見なされ、数値のゼロや空の文字列は真値とみなされます.

文字列
Lua 言語で文字列は8ビット幅のバイト列として扱われており、特定の文字コードとして扱うかどうかはアプリケーション・プログラムに任されています.

文字列リテラルはシングルクォートかダブルクォート ( または  ) で区切られます. この2つに違いは無いという点で JavaScript とは同様であり、PHP とは異なります. 以下のエスケープ表現が有効です.

文字列中で改行の直前にバックスラッシュ文字「 」があればそこは文字列データ中でも改行として含まれることになります. また文字列中に「 」（ 数字列 は ～   ）の形式の記述があれば、そこには、 数字列 が表現するところのバイトデータになります. Unicode文字列をエスケープ表現で記述する場合は、UTF-8文字符号化方式でのバイトの並びを入れる必要があります.

文字列リテラルは長括弧によって表現することもできます. 開き長括弧は、開き角括弧で始まり、その後に0個以上の等号が続き、その後に開き角括弧で終わるものです. 例えば次のものはすべて開き長括弧です:

開き長括弧はそれと対応する閉じ長括弧によって閉められなければなりません. 対応する閉じ長括弧とは、開き長括弧の開き角括弧「 」を閉じ角括弧「 」に置換したものです. 例えば次のものはすべて閉じ長括弧です.

特別な場合として、開き長括弧の直後が改行になっているものについては、その改行は文字列データには含まれません. しかし閉じ長括弧の直前の改行は文字列データに含まれます. 長括弧で括られた文字列中ではエスケープ表現は特別な意味を持たず書かれてある通りの文字列データになります.

長さ 0 の文字列を含めて、全ての文字列データは真偽値としては真値として解釈されます.

数値
Lua には数値型は一つしかなく、通常は倍精度浮動小数点数として内部的に表現されます. この形式で厳密に表現できる整数の範囲は  と   の間であり、これを超える数値は丸め誤差が発生する可能性があります.

数値は小数の区切りとして「 」を使用して  のように記述します. 指数表記を使用して 、  あるいは   のように表現することも出来ます. 整数は  を使用した16進数記法で、  のようにも記述できます.

非数および正負の無限大は正しく保持し扱うことができますが、Lua はこれらに対応するリテラルを提供していません. 定数  は正の無限大であり、  のような除算も同様です. また、手っ取り早く非数を生成する方法として  が使われる場合があります.

すべての数値は、真偽値へ変換される場合、真とみなされることに注意してください. これは  が偽とみなされるような他言語とは異なる点です. 文字列へ変換される場合、有限の数値は小数で、可能なら指数表記で表現されます. 非数は  または  、無限大は   または   となります.

テーブル
Lua のテーブルは、PHP の配列や JavaScript のオブジェクトによく似た連想配列です.

テーブルは波括弧を使って作成します. 空のテーブルは  です. 作成時にフィールドにデータを入れるには、コンマかセミコロン、あるいはその両方で区切られたフィールド指示子のリストで記述します. 次のようないくつかの形式をとります.

テーブルデータ中にあるフィールド（項目）は「 」という形で読み書きできます. これはブラケット記法と呼ばれます.

キーが文字列で、その文字列が Lua の識別子としても妥当であるものであれば、「 」という形でも読み書きできます. これはドット記法と呼ばれます.

テーブル中のフィールドの値が関数で、なおかつフィールドのキーが文字列でそのキーがLua の識別子としても妥当である場合、「 」という形でその関数を呼び出すことができます. これはコロン記法と呼ばれます. これは「 」や「 」と等価です.

シーケンスというのは次のすべての性質を満たすテーブルのことです. 多くの Lua の関数はシーケンスを扱い、非正の整数のキーを無視します.
 * キーが正の整数である.
 * キー範囲1～Nでは値が  でない値である.
 * N+1以上のキー範囲では値が  である.

と非数を除く全ての値はテーブルのキーとして使うことができます. どのようなキーも型変換されることはありません. これらすべての値は妥当であり他の値とは異なるものとして扱われます.

同様に、 以外のどんな値でもテーブルの値として入れることができます. を表に入れるというのは、対応するキーを削除するのと同じことです. また、それまでに何も値を設定されていないキーの値を参照すると  が返されます.

Lua言語ではテーブルは暗黙に複製がつくられることはありません. 例えばある関数が引数としてテーブルデータを受け取って、その関数がそのテーブルデータに対して何らかの変更を加えるとすれば、その変更はそのまま関数を呼び出し側からも見えてしまうということです.

テーブルデータを文字列に変換すると既定では  という文字列になるだけですが、  メタメソッドをオーバラーライド（上書き）することで、この結果を変えることができます. 中身が空のテーブルを含めてすべてのテーブルデータは真偽値としては真値として扱われます.

関数
Lua における関数は第一級の値です. 関数は匿名のものとして作られたり、引数として渡されたり、変数に代入されたりします.

関数は  キーワードを使って作成され、括弧を使って呼び出されます. 名前付き関数、ローカル関数、テーブルのメンバー関数として振る舞う関数に対しては構文糖衣が利用できます. 詳しくは関数定義や関数呼出しを参照してください.

Lua の関数はクロージャ（関数閉包）です. つまり、関数は自身が定義された場所のスコープへの参照を保持し、その関数が実際に評価される場所がどこであるかに関係なく、定義された場所のスコープにある変数に対してアクセスしたり操作することが出来ます.

暗黙的に複製されることのないテーブルと同じように、関数オブジェクトも、たとえ異なる変数に代入されるとしても、また、他の関数に引数として渡されるとしても、もとの関数オブジェクトから何も変わることはありません.

関数オブジェクトは文字列へ変換されると、結果は  になります.

操作できないデータ型
ユーザーデータ型は、Lua を拡張するために他の言語で書かれた不明な値を保持する型として使用されます. 例えばユーザーデータは C 言語のポインタや構造体を保持するのに使われる場合があります. カスタムコンパイルされたコードが許可されないホスティング環境で Scribunto を利用可能にするため、このような拡張は一切使用されません.

スレッド型はコルーチンのハンドラを表し、Scribunto のサンドボックス内では利用できません.

メタテーブル
すべてのテーブルはメタテーブルと呼ばれるテーブルと関連付けられています. メタテーブルが保持する各フィールドは、演算子や関数によって参照され、テーブル同士の差分を求めたり、そのテーブルに対するコールバック動作をする目的で使われます. テーブルに関連付けられたメタテーブルを取得するには getmetatable 関数が使われ、メタテーブルを変更するには $setmetatbale 関数が使われます.

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

テーブル自体に影響するメタテーブルのフィールドは次のものです.
 * __index
 * これは  が   を返す場合に使われます.  もしこのフィールドの値がテーブルデータであれば、  というように同じ操作がそのテーブルに対しても繰り返されます（そのテーブルのメタテーブルの   が呼ばれます）.  もしもこのフィールドの値が関数であれば、その関数が   で呼び出されます.  rawget 関数を使えばこのメタメソッドの仕組みを回避してデータの取得をすることができます.


 * __newindex
 * これはテーブルデータに対して新規に値を設定するときに使われます. コードで言えば  が   である時に   を実行する時に使われます.  もしこのフィールドの値がテーブルデータであれば、  というように同じ操作がそのテーブルに対しても繰り返されます（そのテーブルのメタテーブルの   が呼ばれます）.  もしもこのフィールドの値が関数であれば、その関数が   で呼び出されます.  rawset 関数を使えばこのメタメソッドの仕組みを回避してデータの取得をすることができます.


 * __call
 * これはテーブルに対して関数呼び出しの形（ ）が用いられた場合に使われます. この場合、フィールドの値は関数で   の形で呼び出すことができるものでなければなりません.


 * __mode
 * これは弱い参照を保持するテーブルを作る場合に使われます. フィールドの値は文字列でなければなりません.  普通のテーブルの場合、キーも値もガベージコレクションの対象にはなりません.  しかし、このフィールドの値に文字「 」が含まれている場合、弱い参照でないものが含まれいなければ、キーはガベージコレクションの対象になります. またこのフィールドの値に文字「 」が含まれている場合、対応するキーと値の両方がテーブルから削除されます.  テーブルがメタテーブルとして使われた後にこのフィールドが変更された場合の挙動については定義されていません.

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


 * __add†
 * __sub†
 * __mul†
 * __div†
 * __mod†
 * __pow†
 * __unm
 * __concat†
 * __eq‡
 * __lt‡
 * __le‡
 * __pairs
 * __ipairs
 * __metatable*
 * __tostring

† 二項演算子の場合、Lua はまず使うべきメタメソッドとして左の項を見てそれから右の項をみます. ‡ 関係演算子の場合、メタメソッドは、両方の引数のメタテーブルで同じ関数が指定されている場合にのみ使用されます. ボディとクロージャが同じであっても、異なる無名関数は同じとは見なされない場合があります. * __メタテーブルは getmetatable と setmetatable に影響

注意：Lua ではすべての文字列が共有する同一のメタテーブルにおいて、 は   テーブルを参照します. このメタテーブル、あるいは参照する  テーブルは Scribunto からアクセスできません. モジュールが参照する文字列テーブルは複製です.

変数
変数とは値を格納する場所です. Lua では3種類の変数が有ります. 大域変数、局所変数、テーブルのフィールドの三つです.

名前（または識別子）は大域変数や局所変数（関数の引数を含む）を表します. キーワード「 」を使って明示的に宣言されていない変数はすべて大域変数であるとみなされます. 値を代入されていない変数は  で初期化されたのと同じ振る舞いをします.

大域変数は「環境」と呼ばれるLua 標準のテーブルに保存されます. この変数は「 」としてアクセス可能であり、しばしば使われます. この変数にメタテーブルを設定することもできます. この変数のメタメソッド  と   は、同変数のフィールドの値を参照したりフィールドに値を設定する時だけでなく、大域変数の値を参照したり大域変数に値を代入する時にも呼ばれます.

関数についの情報を収めた環境は、 関数で取得でき、  関数で変更することができます. Scribunto では、これら二つの関数が利用可能であるかどうかについては厳しく制限されています.

局所変数とは構文スコープを持つ変数のことです. 詳しくは局所変数宣言を御覧ください.

式
式というのは何かの値を持つもののことを言います.
 * リテラル（数値型、文字列型、 、 、 ）
 * 無名関数宣言
 * テーブルのコンストラクター
 * 変数の参照
 * 関数呼び出し
 * 式
 * 何かの式が  と   で括られたもの
 * 何かの式に単項演算子が付されたもの
 * 二つの式が二項演算子で繋げられたもの

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

式リストというのは複数の式がカンマで区切られたものを言います. カンマで区切られた最後の式以外のすべての値は式リストの値としては使われません. 最後の式が持つすべての値は式リスト全体の値として使われます.

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

与えられた値が数値型または文字列型のどちらかであって、それを  に通した結果が非   であれば、これらの演算子は適切に機能します.

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

関係演算子
Lua 言語の関係演算子は 、 、 、 k 、 です. 関係演算子の評価結果はどんな場合も真偽値です.

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

演算子は単純な論理否定です.

関係演算子は、両辺とも数値型であるかまたは両者とも文字列型であれば直接的に比較し、その結果が  であればメタメソッドによって比較します.


 * で処理系は  を使います.
 * では利用可能であれば処理系はまず  を使い、  が利用可能であれば   を評価します.
 * は  として処理されます.
 * は  として処理されます.

必要とするメタメソッドが存在しない場合はエラーが投げられます.

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

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

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

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

演算子、 演算子は短絡評価しますから、例えば、  というコードの場合、  が評価されるのは   が   か   を返す場合に限られます.

結合演算子
結合演算子は「 」であり、「 」のような形で使われます. と  のふたつの値が共に数値型または文字列型である場合は両者の文字列表現を連結したものが返されます. そうでない場合、 メタメソッドが利用可能であればそれが使われます. それもできない場合はエラーが投げられます.

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

長さ演算子
長さ演算子は  で、  のように使用します. もし  が文字列ならバイト長が返されます. もし  がシーケンステーブルならシーケンスの長さが返されます.

がシーケンスではないテーブルの場合は、たとえ上位の添字に nil ではない値があったとしても、 は 0 または a[N] が nil でなく a[N+1] が nil であるような任意の値 N を返す可能性があります. 例:

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


 * 1) not # - (算術否定)
 * 2) + - (減算)
 * 3) and
 * or
 * 1) and
 * or
 * 1) and
 * or

同じ優先順位内では、ほとんどの2項演算子は左結合で、例えば は  と評価されます. べき乗と結合演算子は右結合で、例えば は と評価されます.

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

func ( 式リスト )

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

式リストの値が関数定義の引数の数よりも少ない状態で関数が呼び出された場合、余分な引数にはnilの値が入ります. 式リストに引数よりも多くの値が含まれている場合、余分な値は破棄されます. 関数が可変数の引数を取ることも可能です. 詳細はFunction declarationsを参照してください.

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

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 nameoptional ( var-listoptional ) ブロック end

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

関数が呼び出されると、var-listに対応するローカル変数が作成され、値が代入された後、block内の文が実行されます. もしreturn文に達した場合はブロックを終了し、関数呼び出し式の値はreturn文で与えられた値となります. return文に遭遇することなく関数ブロックの最後まで実行された場合、関数呼び出し式の結果はゼロの値はゼロになります.

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

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

function nameoptional ( var-list, ... ) ブロック end -- or function nameoptional ( ... ) ブロック end

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

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

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

次に示すコードは動作しません:

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

関数宣言はローカル変数の代入文が完了する前に処理されるので、関数本体内の"factorial"は外部スコープ内のその名前の(おそらく未定義の)変数を参照します. この問題は、最初にローカル変数を宣言してから後続の文で代入するか、function declaration statement構文を使用することで回避できます.

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

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

blockは、chunkと同じように、一連のステートメントです. blockを区切ることで、1つのステートメントにすることができます. となります. これらは、ローカル変数のスコープを制限したり、他のブロックの途中で や を追加するために使用されることがあります.

Assignments
variable-listは、コンマで区切られた変数のリスト、expression-listは、コンマで区切られた一つ以上の式のリストです. すべての式は代入が行われる前に評価されるので、 は a と b の値を入れ替えることになります.

局所変数の宣言
ローカル変数は、blockまたはchunk内のどこでも宣言することができます. 式のリストがない最初の形式では、変数を宣言しますが、値を割り当てないので、すべての変数の値はnilになります. 2番目の形式では、上記のAssignmentsで説明したように、ローカル変数に値を割り当てます.

ローカル変数の可視性は、ローカル変数宣言の後のステートメントで始まることに注意してください. つまり、 のような宣言は、ローカル変数xを宣言し、それに外部スコープからのxの値を割り当てます. ローカル変数は、ローカル変数宣言を含む最も内側のブロックの終わりまで、スコープ内に残ります.

制御構造
while文は、式の評価値がtrueの値である限り、blockを繰り返します.

repeatステートメントは、式の評価値が真の値になるまでblockを繰り返します. blockの中で宣言されたローカル変数は、式の中でアクセスすることができます.

このforループの最初の形では、ローカル変数を宣言し、exp1からexp2までの値に対してブロックを繰り返し、繰り返しごとにexp3を加えていきます. なお、exp3は完全に省略することができ、その場合は1が使用されますが、 や などの非数値はエラーになります. すべての式は、ループが開始される前に一度だけ評価されます.

このforループの形式は、おおよそ次のようなものと同じです

ただし、変数var、limit、stepは他の場所ではアクセスできません. 変数nameは block 内のローカル変数であり、ループの後でその値を使用するには、ループの外で宣言された変数にコピーする必要があることに注意してください.

forループの第2の形式は，iterator関数で動作します．第1の形式と同様に，expression-listはループを開始する前に1回だけ評価されます.

このforループの形式は、おおよそ次のようなものと同じです

ただし、ここでも変数 func, static, var は他の場所ではアクセスできません. なお、var-listの変数はblock 内のローカル変数であり、ループの後で使用するには、ループの外で宣言された変数にコピーする必要があります.

多くの場合、expression-listは3つの値を返す単一の関数呼び出しです. 渡されたパラメーターのみに依存するように iterator 関数を記述できる場合は、それが最も効率的です. そうでない場合、Programming in Luaは、テーブルを静的変数として返し、反復ごとにそのメンバーを更新するよりも、クロージャを優先することを提案しています.

exp1がtrueを返す場合はblock1を実行し、そうでない場合はexp2がtrueを返す場合はblock2を実行し、それ以外の場合はblock3を実行します. の部分は省略でき、 portion may be omitted, and the の部分は、必要に応じて繰り返したり省略したりできます.

returnステートメントは、関数またはchunk（単なる関数）から値を返すために使用されます. expression-listは、0個以上の式のコンマで区切ったリストです.

Luaはtail callsを実装しています. expression-listが関数呼び出しであるちょうど1つの式で構成されている場合、現在のスタックフレームはその関数への呼び出しに再利用されます. これは、 や のようなコールスタックを扱う関数に影響を与えます.

returnステートメントは、そのblockの最後のステートメントである必要があります. 何らかの理由で block の途中で return が必要な場合は、明示的な block を使用できます.

breakステートメントは、while、repeat、forなどのループの実行を終了し、ループの後の次のステートメントにスキップするために使用されます.

break文は、block内の最後の文である必要があります. 何らかの理由で block の途中で break が必要な場合は、明示的に block  を使用することができます.

ステートメントとしての関数呼び出し
関数の呼び出しをステートメントとして使用することができます. この場合、関数はその関数が持つ可能性のある副作用(例えばmw.logログの値)のためだけに呼び出され、戻り値はすべて破棄されます.

関数宣言文
Luaは、関数を宣言し、それを変数に割り当てることをより自然にするためのシンタックスシュガー（糖衣構文）を提供します. 次の宣言のペアは同等です

-- 基本宣言 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

ここでのコロン表記は、関数呼び出しのコロン表記と同様に、引数リストの先頭に"self"という暗黙の引数を追加することに注意してください.

エラーハンドリング
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は自動メモリ管理を実行します. これは、新しいオブジェクトにメモリを割り当てることや、オブジェクトが不要になったときにメモリを解放することについて心配する必要がないことを意味します. Luaは、garbage collectorを時々実行して、すべてのデッドオブジェクト（つまり、Luaからアクセスできなくなったオブジェクト）とweak referencesを介してのみ到達可能なオブジェクト）を収集することにより、メモリを自動的に管理します. Luaが使用するすべてのメモリは、テーブル、関数、文字列などの自動管理の対象となります.

ガベージコレクションは自動的に行われ、Scribunto 内で設定することはできません.

標準ライブラリ
標準のLuaライブラリは、Luaに不可欠なサービスとパフォーマンスが重要な機能を提供します. Scribunto で利用可能な標準ライブラリの部分のみがここに記載されています.

_G


この変数は、現在のグローバル変数テーブルへの参照を保持します. グローバル変数 は としてアクセスすることもできます. ただし、_G自体について特別なことは何もないことに注意してください. 他の変数と同じ方法で再割り当てできます.

グローバル変数テーブルは、他のテーブルと同じように使用できます. 例えば、

_VERSION


実行中のLuaのバージョンを含む文字列. 例: "Lua 5.1"

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

もし が他の値であれば、assertは と を含むすべての引数を返します.

Luaでやや一般的なイディオムは、関数が通常動作時には "true" を返し、失敗時には最初の値として nil または false を返し、2番目の値としてエラーメッセージを返すというものです. 簡単なエラーチェックは、 への呼び出しでラップすることで実装できます.

error
エラーを発生させ、テキスト  を表示します.

は通常、エラーの発生場所に関する情報を追加します. が 1 または省略された場合、その情報は  自身の呼び出しの位置であり、2 は error を呼び出した関数の呼び出しの位置を使用し、以下同様です. 0を渡すと、場所の情報は含まれません.

getfenv
この機能は、エンジンの構成が の場合、使用できないことがあります.

で指定されているように、environment（グローバル変数テーブル）を返します.


 * If 1, nil, or omitted, returns the environment of the function calling . 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.

すべての標準ライブラリ関数と Scribunto ライブラリ関数で使用される環境は保護されています. を使ってこれらの環境にアクセスしようとすると、代わりに nil が返されます.

getmetatable
tableのmetatableを返します. それ以外の型は nil を返します.

metatable に フィールドがある場合は、実際の metatable ではなく、その値が返されます.

ipairs
イテレータ関数、テーブル 、0の3つの値を返します. これは、iterator form of での使用を想定しています.

これは、( 1, t[1] )、( 2, t[2] )などのペアを反復し、t[i]がnilになった時点で停止します.

標準的な動作は、 metamethodを指定することでオーバーライドすることができます. そのメタメソッドが存在する場合、ipairsの呼び出しは、代わりに で返された3つの値を返します.

next
これにより、テーブルの中のキーを繰り返し処理することができます. がnilまたは指定されていない場合は、テーブルの「最初の」キーとその値を返し、そうでない場合は「次の」キーとその値を返します. それ以上のキーがない場合は、nilを返します. テーブルが空であるかどうかは、 という式を使って調べることができます.

数値インデックスを持つテーブルの場合でも、キーが返される順序は指定されていないことに注意してください. テーブルを数値順にたどるには、numerical forまたはipairsを使用します.

探索にnextを使用しているときに、存在しないキーに値が割り当てられた場合の動作は未定義です. 既存のフィールドに新しい値(nilを含む)を割り当てることは可能です.

pairs
イテレータ関数(nextまたはそれに類するもの)、テーブル 、そしてnilの3つの値を返します. これは、iterator form of での使用を想定しています.

これは、nextと同様に  のキーと値のペアを繰り返し処理します. 探索中にテーブルを変更する際の制限については next のドキュメントを参照ください.

標準の動作を上書きするには、__pairs metamethodを指定します. そのメタメソッドが存在する場合、pairs の呼び出しは  が返す 3 つの値を代わりに返します.

pcall
与えられた引数で関数  を protected mode で呼び出します. つまり、 の呼び出し中にエラーが発生した場合、pcall は false を返し、エラー・メッセージが表示されます. エラーが発生しなかった場合、 pcall は true を返し、呼び出しによって返されたすべての値を返します.

pseudocodeでは、 は次のように定義されている可能性があります.

rawequal
これは、__eqのmetamethodを無視することを除いて、 と同じです.

rawget
これは、__indexのmetamethodを無視することを除いて、 と同じです.

rawset
これは、__newindexのmetamethodを無視することを除いて、 と同じです.

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

つまり、 は、 にnilの値が含まれていても正しく動作するという点を除いては、おおよそ以下のようなものです（nilの問題については、#およびunpackのドキュメントを参照してください）.

setmetatable
metatableのtableを設定します. はnilの場合がありますが、明示的に指定する必要があります.

現在のメタテートに__metatableフィールドがある場合、 はエラーを投げます.

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

オプションの （デフォルト10）は、数字を解釈する基数を指定します. 基数は、2から36までの任意の整数です. 10以上の基数では、文字 'A' （大文字または小文字）が10を、'B'が11を、そして'Z'が35を表します.

基数10では、値に小数部分があり、E notationで表され、基数16を示す先頭に「0x」が付いている場合があります. 他の基数では、符号なし整数のみが受け入れられます.

tostring
を文字列に変換します. それぞれの型がどのように変換されるかについての詳細は、上記のData typesを参照してください.

テーブルの標準的な動作は、__tostring metamethodを指定することで上書きすることができます. そのメタメソッドが存在する場合、tostring の呼び出しは、代わりに  で返される単一の値を返します.

type
のタイプを文字列で返します： 、 、 、 、 、.

unpack
Returns values from the given table, something like  would do if written out manually. If nil or not given,  defaults to 1 and   defaults to.

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

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

In pseudocode,  might be defined something like this:

debug.traceback
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.abs
Returns the absolute value of.

math.acos
Returns the arc cosine of  (given in radians).

math.asin
Returns the arc sine of  (given in radians).

math.atan
Returns the arc tangent of  (given in radians).

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

math.ceil
Returns the smallest integer larger than or equal to.

math.cos
Returns the cosine of  (given in radians).

math.cosh
Returns the hyperbolic cosine of.

math.deg
Returns the angle  (given in radians) in degrees.

math.exp
Returns the value $$e^x$$.

math.floor
Returns the largest integer smaller than or equal to.

math.fmod
Returns the remainder of the division of  by   that rounds the quotient towards zero. For example,  yields.

math.frexp
Returns two values  and   such that:


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

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

math.ldexp
Returns $$m \times 2^e$$ ( should be an integer).

math.log
Returns the natural logarithm of.

math.log10
Returns the base-10 logarithm of.

math.max
Returns the maximum value among its arguments.

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

math.min
Returns the minimum value among its arguments.

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

math.modf
Returns two numbers, the integral part of  and the fractional part of. For example,  yields.

math.pi
The value of $$\pi$$.

math.pow
Equivalent to.

math.rad
Returns the angle  (given in degrees) in radians.

math.random
Returns a pseudo-random number.

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


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

Note that incorrect output may be produced if  or   are less than −2147483648 or greater than 2147483647, or if   is greater than 2147483646.

math.randomseed
Sets  as the seed for the pseudo-random generator.

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

math.sin
Returns the sine of  (given in radians).

math.sinh
Returns the hyperbolic sine of.

math.sqrt
Returns the square root of. Equivalent to.

math.tan
Returns the tangent of  (given in radians).

math.tanh
Returns the hyperbolic tangent of.

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

os.date

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

日付と時間を添え、 の規定する書式を設定した文字列もしくはテーブルを返します. 書式が除去されたり nil の場合、「%c」を採用します.

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

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


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

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
Returns the number of seconds from  to.

os.time
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".

require
Loads the specified module.

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

Otherwise, it calls each loader in the  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  and is returned.

See the documentation for  for information on the loaders available.

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

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

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

package.loaders
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   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.

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

package.seeall
Sets the __index metamethod for  to _G.

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

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
If the string is considered as an array of bytes, returns the byte values for,  , ···,. The default value for  is 1; the default value for  is. Identical to mw.ustring.byte.

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.

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

string.find
Looks for the first match of  in the string. If it finds a match, then  returns the offsets in   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  specifies where to start the search; its default value is 1 and can be negative. A value of true as a fourth, optional argument  turns off the pattern matching facilities, so the function does a plain "find substring" operation, with no characters in   being considered "magic".

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

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

string.format
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 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
Returns an iterator function that, each time it is called, returns the next captures from  over string. If  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
Returns a copy of  in which all (or the first , if given) occurrences of the   have been replaced by a replacement string specified by  , which can be a string, a table, or a function. also returns, as its second value, the total number of matches that occurred.

If  is a string, then its value is used for replacement. The character  works as an escape character: any sequence in   of the form  , with d between 1 and 9, stands for the value of the d-th captured substring. The sequence  stands for the whole match, and the sequence   stands for a single.

If  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  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
Returns the length of the string, in bytes. Is not confused by ASCII NUL characters. Equivalent to.

See mw.ustring.len for a similar function using Unicode codepoints rather than bytes.

string.lower
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
Looks for the first match of  in the string. If it finds one, then  returns the captures from the pattern; otherwise it returns nil. If  specifies no captures, then the whole match is returned.

A third, optional numerical argument  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  offset is in characters rather than bytes.

string.rep
Returns a string that is the concatenation of  copies of the string. Identical to mw.ustring.rep.

string.reverse
Returns a string that is the string  reversed (bytewise).

string.sub
Returns the substring of  that starts at   and continues until  ;   and   can be negative. If  is nil or omitted, it will continue until the end of the string.

In particular, the call  returns a prefix of   with length , and   returns a suffix of   with length.

See mw.ustring.sub for a similar function in which the offsets are characters rather than bytes.

string.upper
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  quantifier in PCRE).
 * The only zero-width assertions are,  , and the   "frontier" pattern; assertions such as PCRE's   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, ). Use  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:

Pattern items
A pattern item can be


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

Note that frontier patterns were present but undocumented in Lua 5.1, and officially added to Lua in 5.2. The implementation in Lua 5.2.1 is unchanged from that in 5.1.0.
 * , a frontier pattern; such item matches an empty string at any position such that the next character belongs to set and the previous character does not belong to set. The set set is interpreted as previously described. The beginning and the end of the subject are handled as if they were the character '\0'.

Pattern
A pattern is a sequence of pattern items.

A ' ' at the beginning of a pattern anchors the match at the beginning of the subject string. A ' ' at the end of a pattern anchors the match at the end of the subject string. At other positions, ' ' and ' ' have no special meaning and represent themselves.

Captures
A pattern can contain sub-patterns enclosed in parentheses; they describe captures. When a match succeeds, the substrings of the subject string that match captures are stored ("captured") for future use. Captures are numbered according to their left parentheses. For instance, in the pattern, the part of the string matching   is stored as the first capture (and therefore has number 1); the character matching   is captured with number 2, and the part matching   has number 3.

Capture references can appear in the pattern string itself, and refer back to text that was captured earlier in the match. For example,  will match any pair of identical lowercase letters, while   will match any 7-letter palindrome.

As a special case, the empty capture  captures the current string position (a number). For instance, if we apply the pattern  on the string , there will be two captures: 3 and 5.

Table library
Most functions in the table library assume that the table represents a sequence.

The functions,  , and   may be available but are deprecated. Use a for loop with pairs, a for loop with ipairs, and the length operator instead.

table.concat
Given an array where all elements are strings or numbers, returns.

The default value for  is the empty string, the default for   is 1, and the default for   is the length of the table. If  is greater than , returns the empty string.

table.insert
Inserts element  at position   in , shifting up other elements to open space, if necessary. The default value for  is the length of the table plus 1, so that a call   inserts   at the end of table.

Elements up to  are shifted; see Length operator for caveats if the table is not a sequence.

table.maxn
Returns the largest positive numerical index of the given table, or zero if the table has no positive numerical indices.

To do this, it iterates over the whole table. This is roughly equivalent to

table.remove
Removes from  the element at position  , shifting down other elements to close the space, if necessary. Returns the value of the removed element. The default value for  is the length of the table, so that a call   removes the last element of table.

Elements up to  are shifted; see Length operator for caveats if the table is not a sequence.

table.sort
Sorts table elements in a given order, in-place, from  to. If  is given, then it must be a function that receives two table elements, and returns true when the first is less than the second (so that   will be true after the sort). If  is not given, then the standard Lua operator   is used instead.

The sort algorithm is not stable; that is, elements considered equal by the given order may have their relative positions changed by the sort.

Scribuntoライブラリ
All Scribunto libraries are located in the table.

mw.addWarning
Adds a warning which is displayed above the preview when previewing an edit. is parsed as wikitext.

mw.allToString
Calls tostring on all arguments, then concatenates them with tabs as separators.

mw.clone
Creates a deep copy of a value. All tables (and their metatables) are reconstructed from scratch. Functions are still shared, however.

mw.getCurrentFrame
Returns the current frame object, typically the frame object from the most recent.

mw.incrementExpensiveFunctionCount
Adds one to the "expensive parser function" count, and throws an exception if it exceeds the limit (see ).

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

mw.loadData
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  can use a significant amount of time. To avoid this issue,  is provided.

works like, with the following differences:


 * The loaded module is evaluated only once per page, rather than once per  call.
 * The loaded module is not recorded in.
 * 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  has metamethods that provide read-only access to the table returned by the module. Since it does not contain the data directly,   and   will work but other methods, including ,  , 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  to efficiently load the data.

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

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

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

mw.logObject
Calls mw.dumpObject and appends the resulting string to the log buffer. If  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, and to the parser.

Note that there is no frame library, and there is no global variable named. A frame object is typically obtained by being passed as a parameter to the function called by, and can also be obtained from.

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

then  will return ,   will return  , and   (or  ) will return. It is also possible to iterate over arguments using  or. 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;  may be used to convert them to numbers, if necessary. Keys, however, are numbers even if explicitly supplied in the invocation:  gives string values   and   indexed by numeric keys   and.

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

 * Note the use of named arguments.

Call a parser function, returning an appropriate string. This is preferable to, but 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:

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

frame:expandTemplate

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

frame:extensionTag
This is equivalent to a call to frame:callParserFunction with function name  and with   prepended to.

frame:getParent
Called on the frame created by, returns the frame for the page that called. Called on that frame, returns nil.

For instance, if the template  contains the code , and a page transcludes that template with the code  , then in Module:ModuleName, calling   and   returns   and  , and calling   and   returns   and  , with   being the first argument in the function call.

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

frame:newChild

 * 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. The number of frames that may be created at any one time is limited.

frame:preprocess
This expands wikitext in the context of the frame, i.e. templates, parser functions, and parameters such as  are expanded. Certain special tags written in XML-style notation, such as,  ,   and  , will be replaced with "strip markers" &mdash; special strings which begin with a delete character (ASCII 127), to be replaced with HTML after they are returned from.

If you are expanding a single template, use  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  for the same reasons.

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

The returned object has one method,, that returns the expanded wikitext for the argument.

frame:newParserValue
Returns an object with one method,, that returns the result of.

frame:newTemplateParserValue

 * Note the use of named arguments.

Returns an object with one method,, that returns the result of   called with the given arguments.

frame:argumentPairs
Same as. Included for backwards compatibility.

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

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

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

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

A basic example could look like this:

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

can be a table with the following keys:


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

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

mw.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
Appends a newline to the mw.html object.

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

mw.html:attr
Set an HTML attribute with the given  and   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
Get the value of a html attribute previously set using  with the given.

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

mw.html:css
Set a CSS property with the given  and   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
Add some raw  to the node's style attribute. If a nil parameter is passed, this is a no-op.

mw.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
Like, 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  are available on the global   table; functions documented as   and   are methods of a language object (see   or  ).

mw.language.fetchLanguageName
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.

mw.language.fetchLanguageNames
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  returns all names in that language.

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

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

mw.language.getFallbacksFor


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

mw.language.isKnownLanguageTag
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 ) and returns a non-empty string for.

mw.language.isSupportedLanguage
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 ), 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 ). Also note that certain codes are "supported" despite  returning false.

mw.language.isValidBuiltInCode
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 ); 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 ) even though this function returns false.

mw.language.isValidCode
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
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
Returns the language code for this language object.

mw.language:getFallbackLanguages
Returns a list of MediaWiki's fallback language codes for this language object. Equivalent to.

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

mw.language:lc
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:lcfirst
Converts the first character of the string to lowercase, as with lang:lc.

mw.language:uc
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:ucfirst
Converts the first character of the string to uppercase, as with lang:uc.

mw.language:caseFold
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
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  is a table of options, which can be:

Digit transformation may still occur, which may include transforming the decimal separator.
 * : Set true to omit grouping separators and use a dot as the decimal separator.

mw.language:formatDate
Formats a date according to the given format string. If  is omitted, the default is the current time. The value for  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  are identical to those for the #time parser function from. 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:

mw.language:formatDuration
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.

, if given, is a table with values naming the interval units to use in the response. These include ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', and ' '.

mw.language:parseFormattedNumber
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.

mw.language:convertPlural
This chooses the appropriate grammatical form from  (which must be a sequence table) or   based on the number. For example, in English you might use  or   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

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

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

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

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

mw.language:getArrow
Returns a Unicode arrow character corresponding to :


 * 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
Returns "ltr" or "rtl", depending on the directionality of the language.

mw.language:getDirMark
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  is a true or false value.

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

mw.language:getDurationIntervals
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.

, if given, is a table with values naming the interval units to use in the response. These include ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', and ' '.

Those unit keywords are also the keys used in the response table. Only units with a non-zero value are set in the response, unless the response would be empty in which case the smallest unit is returned with a value of 0.

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

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

mw.message.new
Creates a new message object for the given message. The remaining parameters are passed to the new object's  method.

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

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

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

mw.message.rawParam
Wraps the value so that it will not be parsed as wikitext by.

mw.message.numParam
Wraps the value so that it will automatically be formatted as by. Note this does not depend on the Language library actually being available.

mw.message.getDefaultLanguage
Returns a Language object for the default language.

mw.message: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  object, to allow for call chaining.

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

Returns the  object, to allow for call chaining.

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

Returns the  object, to allow for call chaining.

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

The default language is the one returned by.

Returns the  object, to allow for call chaining.

mw.message:useDatabase
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  object, to allow for call chaining.

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

mw.message:exists
Returns a boolean indicating whether the message key exists.

mw.message: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
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 "-".

mw.site.currentVersion
A string holding the current version of MediaWiki.

mw.site.scriptPath
The value of.

mw.site.server
The value of.

mw.site.siteName
The value of.

mw.site.stylePath
The value of.

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


Gets statistics about the category. If  has the special value " ", the result is 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  is one of the above keys ("all", "subcats", "files", "pages"), the result is a number with the corresponding value.

Each new category queried will increment the expensive function count.

mw.site.stats.pagesInNamespace
Returns the number of pages in the given namespace (specify by number).

mw.site.stats.usersInGroup
Returns the number of users in the given group.

mw.site.interwikiMap
Returns a table holding data about available interwiki prefixes. If  is the string "local", then only data for local interwiki prefixes is returned. If  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.
 * 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
Replaces HTML entities in the string with the corresponding characters.

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

mw.text.encode
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  is supplied, it should be a string as appropriate to go inside brackets in a Ustring pattern, i.e. the "set" in. The default charset is  (the space at the end is the non-breaking space, U+00A0).

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

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

To relax certain requirements in JSON, such as no terminal comma in arrays or objects, pass. 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  is used.

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

Normally Lua one-based sequence tables are encoded as JSON zero-based arrays; when  is set in , 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  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  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
Removes all MediaWiki strip markers from a string.

mw.text.listToText
Joins a list, prose-style. In other words, it's like  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:

mw.text.nowiki
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
 * Blank lines will have one of the associated newline or carriage return characters escaped
 * escaped
 * will have one underscore escaped
 * will have the colon escaped
 * A whitespace character following,  , or   will be escaped

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

For example,  would return a table.

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

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

mw.text.tag

 * Note the use of named arguments.

Generates an HTML-style tag for.

If  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  is not given (or is nil), only the opening tag is returned. If  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, use frame:extensionTag instead.

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

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

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

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

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

mw.text.unstripNoWiki
Replaces MediaWiki &lt;nowiki&gt; strip markers with the corresponding text. Other types of strip markers are not changed.

mw.text.unstrip
Equivalent to.

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

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

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

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
Returns the title object for the current page.

mw.title.new


Creates a new title object.

If a number  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  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,  (which may be any key found in  ) will be used. If the text is not a valid title, nil is returned.

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

Note that, unlike, this method will always apply the specified namespace. For example,  will create an object for the page Template:Module:Foo, while   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  return titles as string values whereas the fields ending with   return title objects.

.
 * id: The page_id.  if the page does not exist.
 * interwiki: The interwiki prefix, or the empty string if none.
 * namespace: The namespace number.
 * fragment: The fragment (aka section/anchor linking), 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.
 * baseText: If this is a subpage, the title of the page it is a subpage of without prefixes. Otherwise, the same as.
 * subpageText: If this is a subpage, just the subpage name. Otherwise, the same as.
 * canTalk: Whether the page for this title could have a talk page.
 * exists: Whether the page exists. Alias for  for Media-namespace titles. For File-namespace titles this checks the existence of the file description page, not the file itself..
 * 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..
 * 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.
 * inNamespaces( ... ): Whether this title is in any of the given namespaces. Namespaces may be specified by anything that is a key found in.
 * 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.
 * contentModel: The content model for this title, as a string..
 * pageLanguage: The page language for this title, as a language object similar to the default returned from  but specific to this page..
 * basePageTitle: The same as.
 * rootPageTitle: The same as.
 * talkPageTitle: The same as, or   if this title cannot have a talk page.
 * subjectPageTitle: The same as.
 * redirectTarget: Returns a title object of the target of the redirect page if the page is a redirect and the page exists, returns  otherwise.
 * protectionLevels: The page's protection levels. This is a table with keys corresponding to each action (e.g.,  and  ). 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  ..
 * cascadingProtection: The cascading protections applicable to the page. This is a table with keys  (itself a table with keys like   has) and   (an array listing titles where the protections cascade from). If no protections cascade to the  page,   and   will be empty..
 * subPageTitle( text ): The same as.
 * partialUrl: Returns  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:,  ,   (the default), or.
 * 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  if there is no page. The page will be recorded as a transclusion.

Title objects may be compared using relational operators. will return.

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  method or accessing the   field records it as a "", and accessing the title object's   or   fields records it as a "".

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


 * exists: Whether the file exists. It will be recorded as an image usage. The  property on a Title object exists for backwards compatibility reasons and is an alias for this property. If this is , all other file properties will be.
 * 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 . 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.
 * length: The length (duration) of the media file in seconds. Zero for media types which do not support length.

Expensive properties
The properties,  ,  , and   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.

mw.uri.encode
Percent-encodes the string. The default type,, encodes spaces using '+' for use in query strings;   encodes spaces as %20; and   encodes spaces as '_'.

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

mw.uri.decode
Percent-decodes the string. The default type,, decodes '+' to space;   does not perform any extra decoding; and   decodes '_' to space.

mw.uri.anchorEncode
Encodes a string for use in a MediaWiki URI fragment.

mw.uri.buildQueryString
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
Decodes the query string  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  and   can be used to specify a substring of   to be parsed, rather than the entire string. is the position of the first character of the substring, and defaults to 1. is the position of the last character of the substring, and defaults to the length of the string. Both  and   can be negative, as in string.sub.

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

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

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

mw.uri.new
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
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
 * password: String password
 * 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

will give the URI string.

Methods of the URI object are:

mw.uri:parse
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
Makes a copy of the URI object.

mw.uri:extend
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
Returns individual bytes; identical to string.byte.

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

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

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

mw.ustring.codepoint
Much like string.byte, except that the return values are codepoints and the offsets are characters rather than bytes.

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

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

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

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

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

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

mw.ustring.len
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
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
Much like string.match, except that the pattern is extended as described in Ustring patterns and the  offset is in characters rather than bytes.

mw.ustring.rep
Identical to string.rep.

mw.ustring.sub
Much like string.sub, except that the offsets are characters rather than bytes.

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

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

mw.ustring.upper
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:


 *  : represents all characters with General Category "Letter".
 *  : represents all characters with General Category "Control".
 *  : represents all characters with General Category "Number, decimal digit".
 *  : represents all characters with General Category "Lowercase Letter".
 *  : represents all characters with General Category "Punctuation".
 *  : represents all characters with General Category "Separator", plus tab, linefeed, carriage return, vertical tab, and form feed.
 *  : represents all characters with General Category "Uppercase Letter".
 *  : represents all characters with General Category "Letter" or "Decimal Number".
 *  : adds fullwidth character versions of the hex digits.

Like in String library patterns,  ,  ,  ,  ,  ,  ,    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  , and quantifiers applied to multibyte characters will work correctly. Empty captures will capture the position in code points rather than bytes.

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

bit32
This emulation of the Lua 5.2  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
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
Returns the bitwise complement of.

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

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
Extracts  bits from , starting with bit. Accessing bits outside of the range 0 to 31 is an error.

If not specified, the default for  is 1.

bit32.replace
Replaces  bits in , starting with bit  , with the low   bits from. Accessing bits outside of the range 0 to 31 is an error.

If not specified, the default for  is 1.

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

Note that a displacement over 31 will result in 0.

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

Note that a displacement over 31 will result in 0.

bit32.arshift
Returns the number  shifted   bits to the right. This is an arithmetic shift: if  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
Returns the number  rotated   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
Returns the number  rotated   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
Raises an error if  does not match. In addition, no error will be raised if  is nil and   is true.

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

libraryUtil.checkTypeMulti
Raises an error if  does not match any of the strings in the array.

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

libraryUtil.checkTypeForIndex
Raises an error if  does not match.

This is intended for use in implementing a  metamethod.

libraryUtil.checkTypeForNamedArg
Raises an error if  does not match. In addition, no error will be raised if  is nil and   is true.

This is intended to be used as an equivalent to  in methods called using Lua's "named argument" syntax,.

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

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

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

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 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, usually in the table  , however, they are only present when certain extensions are installed (in addition to the Scribunto extension itself).

Such extensions use Scribunto provided hooks:
 * ScribuntoExternalLibraries
 * ScribuntoExternalLibraryPaths

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
provides access to localizable structured data, most notably Wikidata. See md_docs_topics_lua.html and.

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. を参照してください. 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.

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.

mw.ext.cattools
CategoryToolbox provides a means to check from Lua if a certain page belongs to a category. Is is experimental and not enabled on public WikiMedia wikis.

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.

mw.ext.seo
WikiSEO provides a means to set SEO Data for the current page. See Extension:WikiSEO.

変更された関数
以下の関数は改造されました.
 * setfenv
 * getfenv: May not be available, depending on the configuration. If available, attempts to access parent environments will fail.
 * getmetatable: Works on tables only to prevent unauthorized access to parent environments.
 * 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.loaded
 * package.preload
 * package.loaders: Loaders which access the local filesystem or load C libraries are not present. A loader for Module-namespace pages is added.
 * 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
 * loadfile
 * io.*, file.*: Allows local filesystem access, which is insecure.
 * load
 * loadstring: 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.

Additional caveats
Attempting to do so will cause undefined behavior. This includes (but is not limited to) returning such data structures from the module called by  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.
 * 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.

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.

Library
The PHP portion of the library is a class that must extend. See the documentation for that class for implementation details. In the Scribunto extension, this file should be placed in, and a mapping added to. 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. This file should generally include boilerplate something like this:

The module in  (load this with  ) 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,, 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. In the Scribunto extension, the test case should be in  and added to the array in  (in  ); extensions should add the test case in their own   hook function, probably conditional on whether   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  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:, the name of test  , and a string that is the expected output for test.
 * run( n ): Function that runs test  and returns one string.

If  is declared as shown, "Module:TestFramework" is available which provides many useful helper methods. If this is used,  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  and how   is called. Included types are:


 * Normal:  is a table of return values, or a string if the test should raise an error.   is simply called.
 * Iterator:  is a table of tables of return values.   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.

Test cases in another extension
There are (at least) two ways to run PHPUnit tests:

If your extension's test class names all contain a unique component (e.g. the extension's name), the  option may be used to run only your extension's tests.
 * 1) Run phpunit against core, allowing the tests/phpunit/suites/ExtensionsTestSuite.php to find the extension's tests using the  hook.
 * 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  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 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:

説明文書
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.

関連項目

 * jp:Lua

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

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