Lua標準ライブラリ

The standard Lua libraries provide essential services and performance-critical functions to Lua. この記事では、主にScribunto上でも使用できる標準ライブラリについて記述します。

このアイコンがある物はAviUtl上での事について記述されています。
このアイコンがある物はWikia上での事について記述されています。
## 基本ライブラリ

### \_G

グローバル変数を全て含むテーブルです。\_G自身も含まれます。

```
foo = 1
mw.log( foo ) -- logs "1"
\_G.foo = 2
mw.log( foo ) -- logs "2"
\_G = {}       -- \_Gの中に\_Gを作成した事になるが・・・
\_G.foo = 3
mw.log( foo ) -- 表示されるのは"2"のまま

```

\_G自身をテーブルとして使用する例です。

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

```

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

```

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

```

### \_VERSION

Luaのバージョンを示す文字列です。

拡張編集 0.90d3時点での内容は"Lua 5.1"です。
### assert

`assert(v[, mes])`

`v` が `nil` か false だった時、エラーメッセージ`mes`を送出します

`mes`省略時のエラーメッセージは "assertion failed!" になります

もしそうでなかった場合、そこに記述された引数をそのまま返します。中に関数を記述した場合、その返す値で`assert`を実行します。

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

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

```

### error

`error(mes[, level])`

エラーメッセージ`mes`を送出します

`level`はエラーメッセージに付加する位置情報を指定します

1なら`error`関数を呼び出した位置

2なら`error`関数を呼び出した関数を呼び出した位置

`level`が0か関数呼び出しの深度以上の場合、位置情報は付加されません

### getfenv

`getfenv(f)`

※Lua 5.2では削除されます。エンジン設定の`allowEnvFuncs`によって異なります。

指定された関数の現在の環境を返します。`f`にはLuaの関数かスタックレベルを指定します。

* 1、nil、または省略された場合、`getfenv`を呼び出す関数の環境を返します。多くの場合、これは`\_G`と同じになります。
* 整数2〜10は、呼び出しスタックの上位にある関数の環境を返します。たとえば、2は現在の関数を呼び出した関数の環境を返し、3はその関数を呼び出す関数の環境を返します。値がスタック内の関数呼び出しの数よりも大きい場合、またはターゲットのスタックレベルが末尾呼び出しで返された場合は、エラーが発生します。
* 関数を渡すと、その関数が呼び出されたときに使用される環境が返されます。

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

### getmetatable

`getmetatable(t)`

`t`のメタテーブルを返します

`t`のメタテーブルが`__metatable`メソッドを持ってたら、その値を返します

nilを返す事もあります

セキュリティの事情でテーブル型以外の値にメタテーブルを設定できないためテーブル型以外では返せません。
### ipairs

`ipairs(t)`

イテレータ関数、`t`、0の3つの値を返します。

```
for i, v in ipairs( t ) do
    -- block
end

```

上のコードは 1 から連続する t の正の整数のインデックスの要素すべてに対して処理を行います
iはインデックス、vはその値です

`e`のメタテーブルが`__ipairs`メソッドを持っていたら、そちらを呼び出します

### next

`next(t[, i])`

テーブル`t`の要素`i`の次の要素の名前と値を返します

`i`がnilもしくは未定義の値なら`t`の最初の要素の名前と値を返します

最後のインデックスで呼び出すか、空のテーブルに対して`nil`で呼び出すと、nextは`nil`を返す。 二番目の引数が省略された場合は`nil`と解釈される。 特に、`next( t ) == nil`を使うとテーブルが空かどうか調べることができる。

Luaにはフィールドの宣言がない。テーブル内にフィールドが存在しないのと、`nil`値が格納されたフィールドには、何の違いも無い。ゆえに、`next`は`nil`でない値を持つフィールドのみを考慮する。インデックスが列挙される順番は、数値のインデックスに対しても、不定である (数値順にテーブルを巡回するには、数値用のfor文やipairs関数を使う)。

テーブルの巡回中に、もし存在していないフィールドに新たに値が割り当てられたら、`next`の動作は未定義である。しかし既存のフィールドは変更してもよい。特に、既存のフィールドを消去するのは構わない。

### pairs

`pairs(t)`

`next`関数、`t`、`nil`の3つの値を返します

```
for k, v in pairs( t ) do
    -- block
end

```

上のコードはtの要素すべてに対して処理を行います
 k は要素名、v はその値です

巡回中にテーブルを変更する際の注意は`next`を参照。
`e`のメタテーブルが`__pairs`メソッドを持っていたら、そちらを呼び出します

### pcall

`pcall(f,[ ...])`
関数`f`に指定された引数を(*protected mode*で)渡して実行します。

関数`f`内でエラーが発生してもプログラムを中断せずに、falseとエラーコードを返します。

成功時はtrueと関数`f`の戻り値を返します。

特定の内部エラーを傍受することはできません。
関数の実行中にエラーが発生した場合、通常は呼び出し元までエラーが伝搬し、そこで実行を止めてしまう。しかし、アプリケーション組み込みのスクリプトでは特に、エラーが発生しても止まってほしくないことがある。そこで、単に関数を呼び出す代わりに pcall() という関数を使って関数を呼び出す。

擬似コードでは、`pcall`は次のようになります:

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

```

### rawequal

`rawequal(a, b)`

`__eq`メタメソッドを呼ばずにaとbが等しいか調べます。戻り値はブーリアンです

### rawget

`rawget(t, i)`

`__index`メタメソッドを呼ばずに t[i] の値を取得します。t はテーブルでなければなりません

### rawset

`rawset(t, i, v)`

`__newindex`メタメソッドを呼ばずに t[i] に v を代入します。t はテーブルでなければなりません

### select

`select(i, ...)`

`i`が整数なら`[i+1]`番目以降の引数の値を全て返します
`i`が文字列`'#'`なら`i`を除く引数の数を返します

言い換えれば、`select`は`...`にnil値が含まれていても正しく動作することを除けば、ほぼ次のようなものです（`nil`の問題については `#`と`unpack`の項目をご覧ください）

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

```

負の値を指定することも可能で、その場合末尾からの位置になります。

* ＋
* －

```
local secondToLast, last = select(2, "one", "two", "three", "four")

mw.log(secondToLast) --> "two"
mw.log(last)         --> "three"

```

```
local secondToLast, last = select(-2, "one", "two", "three", "four")

mw.log(secondToLast) --> "three"
mw.log(last)         --> "four"

```

### setmetatable

`setmetatable(t, meta)`

テーブル`t`のメタテーブルを設定します

もし`meta`が`nil`であれば、テーブル`t`のメタテーブルは除去される。 元のメタテーブルが`__metatable`フィールドを持っていると、エラーになる。

テーブル型以外の値にメタテーブルを設定するには、C言語側で処理する必要があります
### tonumber

`tonumber(e[, base])`

`e`が数値か、数値に変換可能な文字列なら数値を、それ以外なら`nil`を返します

`base(省略時:10)`には`e`を変換する際に使う基数を 2～36 の範囲で指定します

基数10では値は小数部を持ったり、E表記で表されたり、基数16ではそれを示すために先行 "0x"を持つ可能性があります。他の基数では、符号なし整数のみが受け入れられます。

### tostring

`tostring(e)`

`e`を文字列に変換します

それぞれの型がどのように変換されるかについての詳細はLuaのデータ型を見てください。

`e`のメタテーブルが`__tostring`メソッドを持っていたら、そちらを呼び出します

### type

`type(v)`

`v`の型を文字列で返します。返される文字列は以下のどれかです

`"nil"`
`"number"`
`"string"`
`"boolean"`
`"table"`
`"function"`
`"thread"`
`"userdata"`
### unpack

`unpack(t[, i[, j]]`

テーブル`t`の、`i`以上`j`以下の整数の要素すべてを返します

`nil`もしくは省略した時、`i`は 1、`j`は`#t`の値になります

`t`がシーケンスではなく、`j`が`nil`または未指定の場合、結果は確定的ではありません。詳細は長さ演算子を見てください。

※Lua 5.2からはテーブルライブラリになり、`table.unpack`となります

### xpcall

`xpcall(f, err)`
関数 f を実行し、エラーが発生したらエラーメッセージを引数に関数 err を実行します。

関数 f 成功時は true と関数 f の戻り値を返します。

失敗時はfalseと関数`err`の戻り値を返します。

特定の内部エラーを傍受することはできません。
擬似コードでは、`xpcall`は次のようになります:

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

```

### debug.debug

`debug.debug()`

ユーザーとの対話モードに入り、ユーザーが入力した文字列を実行する。単純なコマンドや他のデバッグ機能を使って、ユーザーはグローバル変数やローカル変数を調べたり値を変更したり式を評価したりその他ができる。ユーザーが*cont*だけの行を入力すると対話モードを終えて実行を継続する。

debug.debugで実行されるコマンドは、どの関数のレキシカルスコープにも入っていないので、ローカル変数へは直接アクセスできないことに注意。

### debug.getmetatable

`debug.getmetatable(object)`
object のメタテーブルを返します

### debug.setmetatable

`debug.setmetatable(object, t)`
object がテーブル型以外でもメタテーブルを設定します

### debug.getlocal

`debug.getlocal(level, i)`
スタックレベル level の i 番目のローカル変数の名前と値を返します

### debug.setlocal

`debug.setlocal(level, i, v)`
スタックレベル level の i 番目のローカル変数に v を代入します
i が存在しなければ nil を、そうでなければローカル変数の名前を返します

### debug.getupvalue

`debug.getupvalue(f, i)`
関数 f の i 番目の上位値の名前と値を返します
上位値が存在しなければ nil を返します

### debug.setupvalue

`debug.setupvalue(f, i, v)`
関数 f の i 番目の上位値に v を代入します
i が存在しなければ nil を、そうでなければ上位値の名前を返します

### debug.gethook

`debug.gethook()`
現在のフック関数、フックマスク、フックカウントを返します

### debug.sethook

`debug.sethook(hook, mask [, count])`
フック関数をhook、フックマスクをmask、フックカウントをcount(もしくは)に設定します

### debug.getfenv

`debug.getfenv(o)`
オブジェクト o の環境を返す

### debug.setfenv

`debug.setfenv(object, table)`
指定した object の環境を指定した table にする。

### debug.getregistry

`debug.getregistry()`
レジストリテーブルを返します

### debug.getinfo

`debug.getinfo(f [, what])`

関数に関する情報をテーブルに入れて返す。 関数を直接指定するか数値を指定することができる。 数値は、関数が走っているコールスタックのレベルを意味し、 レベル0は現在の関数 (getinfo 自身)、 レベル1は getinfo を呼び出した関数で、以下同様。 function がアクティブな関数の数よりも大きい数値であれば getinfo は nil を返す。

what はどのフィールドを埋めるかを記述する文字列で、 戻り値のテーブルには lua\_getinfo から返されるフィールドがすべて含まれている。 what のデフォルト値では有効なすべての情報を取得する。 もし存在すれば、`f´ オプションは func という名前のフィールドにその関数自身を入れる。

例えば、式 debug.getinfo(1,"n").name は現在の関数の名前を返す (もし適当な名前があれば)。 debug.getinfo(print) は print 関数に関するすべての利用可能な情報を持つテーブルを返す。

### debug.traceback

`debug.traceback([thread,] [message [, level]])`
message が文字列でも nil でもなければ、 それ以上の処理をせずに message を返します。 そうでなければ、 スタックトレースの文字列を返します。 省略可能な文字列 message がトレースの先頭に追加されます。 省略可能な数値 level はトレースを開始するレベルを指定します (デフォルトは 1 で、 traceback を呼んだ関数です)。

## 数学ライブラリ

### 三角関数

#### math.pi

円周率(

π

{\displaystyle \pi }

)を表す定数です

```
小数点以下14桁目を四捨五入しているようです。

```

#### math.deg

`math.deg(x)`

ラジアン`x`を角度(°)に変換します

```

 r
 ×

 180
 π

 {\displaystyle r \times \frac{180}{\pi}}

ってことです

```

#### math.rad

`math.rad(x)`

角度(`x`°)をラジアンに変換します

```

 d
 ×

 π
 180

 {\displaystyle d \times \frac{\pi}{180}}

ってことです

```

#### math.sin

`math.sin(x)`

ラジアン`x`からサインの値を得ます

#### math.cos

`math.cos(x)`

ラジアン`x`からコサインの値を得ます

#### math.tan

`math.tan(x)`

ラジアン`x`からタンジェントの値を得ます

#### math.asin

`math.asin(x)`

サイン`x`の値からラジアンを得ます。定義域は

−
1
≤
x
≤
1

{\displaystyle -1 \leq x \leq 1}

, 戻り値は

−

π
2

≤
y
≤

π
2

{\displaystyle -\frac{\pi}{2}\le y \le \frac{\pi}{2}}

定義域外の値が渡されると戻り値はNaNになります

#### math.acos

`math.acos(x)`

コサインの値`x`からラジアンを得ます。定義域は

−
1
≤
x
≤
1

{\displaystyle -1 \leq x \leq 1}

, 戻り値は

0
≤
y
≤
π

{\displaystyle 0\le y \le \pi}

定義域外の値が渡されると戻り値はNaNになります

#### math.atan

`math.atan(x)`

タンジェントの値`x`からラジアンを得ます。戻り値は

−

π
2

≤
y
≤

π
2

{\displaystyle -\frac{\pi}{2}\le y \le \frac{\pi}{2}}

#### math.atan2

`math.atan2(y, x)`

座標からラジアンを得ます

言い換えるとすれば結果の象限を見つけるために両方のパラメータの符号を使って、`y/x`の逆正接（ラジアン）を返します。

#### math.sinh

`math.sinh(x)`

`x`の双曲線正弦の値を返します

#### math.cosh

`math.cosh(x)`

`x`の双曲線余弦の値を返します

#### math.tanh

`math.tanh(x)`

`x`の双曲線正接の値を返します

### 指数・対数

#### math.pow

`math.pow(x, y)`

`x`の`y`乗の値を返します。`x^y`の式でも代用できます

#### math.exp

`math.exp(x)`

e
x

{\displaystyle e^x}

を返します

#### math.log

`math.log(x[,base])`

baseを底とする`x`の対数を返します。base省略時は自然対数を返します

#### math.log10

`math.log10(x)`

※この関数はLua 5.2で廃止予定です。
math.logでの代用を推奨します
`math.log(x,10)`と同じ値を返します

#### math.sqrt

`math.sqrt(x)`

`x`の平方根の値を返します。`x^0.5`の式でも代用できます

#### math.ldexp

`math.ldexp(m, e)`

m
×

2
e

{\displaystyle m \times 2^e}

の値を返します。(`e`が実数だと四捨五入されて整数にされるようです)

#### math.frexp

`math.frexp(x)`

`m`と`e`を返しますが・・・

* `x` が0以外の有限:

# x
m
×

2
e

{\displaystyle x = m \times 2^e}

となるような `m`と`e`になります。`m`は

[
0.5
,
1
)

{\displaystyle [0.5, 1)}

(0.5以上1未満)、`e`は整数です
* `x`が0: `m`と`e`は0になります。
* `x`がNaNもしくは無限大: `m`は`x`、`e`は未定義になります。

### その他

#### math.abs

`math.abs(x)`

x

{\displaystyle |x|}

(`x`の絶対値)を返します

#### math.ceil

`math.ceil(x)`

`x`の小数点以下を切り上げて整数にします

#### math.floor

`math.floor(x)`

`x`の小数点以下を切り捨てて整数にします

#### math.fmod

`math.fmod(x, y)`

`x`を`y`で割った余りを返します

`x % y`は、

x
−
y

⌊

x
y

⌋

{\displaystyle x-y \left\lfloor \frac{x}{y} \right\rfloor}

を返しますが、`math.fmod(x,y)`は、

s
g
n

(
x
)

(

x

−

y

×

⌊

x
y

⌋

)

を返します

```
y==0のときは、-1.#INFを返します

```

#### math.max

`math.max(x, ...)`

与えられた引数の中から最も大きい値を返します

NaNでの動作は指定されていません。現在の実装では、`x`がNaNの場合NaNが返されますが、それ以外のNaNは無視されます。

#### math.min

`math.min(x, ...)`

与えられた引数の中から最も小さい値を返します

NaNでの動作は指定されていません。現在の実装では、`x`がNaNの場合NaNが返されますが、それ以外のNaNは無視されます。

#### math.modf

`math.modf(x)`

`x`の整数部と小数部の2つの値を返します

#### math.random

`math.random([m[, n]])`

乱数を返します

拡張編集の乱数とは違い、呼び出し毎に値が変わります
mとnは整数を設定する事ができます

* 引数なしで呼ぶと

[
0
,
1
)

{\displaystyle [0,1)}

(0以上1未満)の実数を返します
* 数値mを渡すと、

[
1
,
m
]

{\displaystyle [1,m]}

(1以上m以下)の整数を返します
* 数値mとnを渡すと、

[
m
,
n
]

{\displaystyle [m,n]}

(m以上n以下)の整数を返します

#### math.randomseed

`math.randomseed(x)`

乱数のシード値を`x`に設定します

ちなみに、乱数といっても擬似乱数なので同じシードを設定すると同じ順番で`math.random`の返値を生成します

### os.clock

`os.clock()`

Luaステートが初期化されてから経過した秒数を返します

AviUtl拡張編集のLuaステートの初期化は初めてスクリプトが実行される直前に行われるようです
### os.date

`os.date([fmt [, time]])`
`os.date( format, time )`

*Language library's formatDate may be used for more comprehensive date formatting*
Returns a string or a table containing date and time, formatted according to `format`. If the format is omitted or nil, "%c" is used.

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

If `format` starts with '!', then the date is formatted in UTC rather than the server's local time. After this optional character, if format is the string "\*t", then date returns a table with the following fields:

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

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

### os.difftime

`os.difftime( t2, t1 )`

時刻`t1`から時刻`t2`までの秒数を返します

### os.time

`os.time( table )`

Returns a number representing the current time.

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

### os.remove

`os.remove(filename)`

指定された名前のファイル、またはディレクトリを削除します

### os.rename

`os.rename(old, new)`

名前が`old`のファイル、またはディレクトリを`new`にリネームします

### os.tmpfile

`os.tmpfile()`

一時ファイルの名前として使えるファイル名を返します

### os.getenv

`os.getenv(varname)`

プロセスの環境変数`varname`の値を返します

### os.execute

`os.execute([cmd])`

OSのシェルに文字列 `cmd`を渡して実行します

`cmd`省略時には、シェルが利用可能ならば非ゼロ、そうでなければゼロを返します

### os.exit

`os.exit([code])`

ホストプログラム(AviUtl)を終了させます

`code`にはエラーがあればそのエラーコードを指定します
省略時は成功を表すコードです

### require

`require( modulename )`

この疑似コードを見てくれ。こいつをどう思う？

```
 function require(modname)
  	if(package.loaded[modname]~=nil)then
  		return package.loaded[modname]
  	end

  	local mod
  	if(package.preload[modname]~=nil)then
     	mod=package.preload[modname]()

     --Luaのローダーを探す

     --本当はpackage.pathには複数のパスのデータが入りうる ;で区切られている
  	elseif(<package.path..modname..".lua"が存在する>)then
  		mod=dofile(package.path:gsub("?",modname))
  	 	\_G[modname]=mod
  		package.loaded[modname]=mod
  		return mod

  	else
  		--Cのローダーを探す

  		-- -(ハイフン)までの文字は、-含め切り捨てて、.(ドット)は\_(アンダースコア)に置換される
  		-- a.b-c.d は c\_d になる
  		local c\_loader\_path=modname:match("%-(.+)"):gsub("%.","\_")

      	--package.cpathも同様
  		if(<package.cpath..c\_loader\_path..".dll"が存在する>)then
  			local mod=package.loadlib(
  				package.cpath:gsub("?",modname),
  				"luaopen\_"..c\_loader\_path
  			)()
  	 		\_G[modname]=mod
  			package.loaded[modname]=mod
  			return mod

  		--オールインワンローダーを探す
  		else
  			-- 一番最初の.の直前までをファイル名にする a.b.cなら ~\a.dllを見に行く
  			if(<package.cpath..modname:match(".+%.")..".dll"が存在する>)then --同上
  				local mod=package.loadlib(
  					package.cpath:gsub("?",modname),
  					"luaopen\_"..modname:gsub("%.","\_")
  				)()
  	 			\_G[modname]=mod
  				package.loaded[modname]=mod
  				return mod
  			end

  		end

  	end
  end

```

Loads the specified module.

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

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

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

Note that every required module is loaded in its own sandboxed environment, so it cannot export global variables as is sometimes done in Lua 5.1. Instead, everything that the module wishes to export should be included in the table returned by the module.

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

```
local p = {}

p.someDataValue = 'Hello!'

return p

```

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

```
local giving = require( "Module:Giving" )

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

```

#### Global modules

Modules hosted in dev.wikia.com are called global modules because they can be loaded by other modules using a similar syntax to loading local modules. The correct syntax to use is `require("Dev:ModuleName")` . **This is case sensitive.**It should also be added to all modules hosted on dev.wikia or else it'll attempt to use a module in a local wiki (e.g. crocodile.wikia.com).

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

```
local giving = require( "Dev:Giving" )

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

```

### 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 `package.preload[modulename]` for the loader function
2. Look in the modules provided with Scribunto for the module name, and if that fails look in the Module: namespace. The "Module:" prefix must be provided.

Note that the standard Lua loaders are **not** included.

### package.preload

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

### package.seeall

`package.seeall( table )`

Sets the `__index` metamethod for `table` to `\_G`.

## 文字列ライブラリ

Luaの文字列のインデックス付けは、最初の文字が1の位置である (C、PHP、JavaScriptのように0ではない)。 文字列の末尾から逆方向にマイナス値で指定することもできる。 つまり、最後の文字は -1 の位置で示される。

『待った！』 この文字列ライブラリは1バイト専用と言ってもよく、
**2バイト以上の文字に対応していません**。

2バイト以上の文字を含む場合は、ScribuntoのUstlingライブラリをご利用ください。

### string.byte

`string.byte(s[, i[, j]])`

文字列`s`の`i`番目から`j`番目までの文字コードの値を返します。
省略時`i`は1、`j`は`i`と同じになります。
Identical to `mw.ustring.byte()`.

### string.char

`string.char(...)`

引数の数値と等しい文字コードの文字を連結した文字列を返します

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

### string.find

`string.find(s, p[, init[, plain]])`

文字列`s`内でのパターン`p`の最初のマッチの開始位置と終了位置を返します。

マッチしなかった場合はnilを返します。init には検索開始位置を指定します。

plain が true の場合パターンマッチングは行われず、単純な部分文字列検索になります。

パターン内にキャプチャが指定されていた場合、その内容が3番目以降の戻り値として返されます。

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

### string.format

`string.format(fmt, ...)`

任意のフォーマットで記述します。書式文字列は標準C関数の`printf`と同じ。

* 認識されるフラグは '-'、'+'、''、'#'、および '0'。
* 最大99までの整数フィールド幅がサポートされています。
* 最大99までの整数精度がサポートされています。
	+ どちらも'\*'は未サポート。
* 長さ指定子は全て未サポート。
* 位置指定子("%2$s"みたいなの)も未サポート。
* それ以外の 'c', 'd', 'i', 'o', 'u', 'x', 'X', 'e', 'E', 'f', 'g', 'G', 's', '%'と'q'はサポートされている。
	+ 未サポート：\*、l、L、n、p、h
	+ 追加：q

q オプションは、Luaインタプリタで安全に読み戻せる適切な形式の文字列に書式化する。この時、文字列はダブルクォートの間に書かれ、文字列中のダブルクォート、改行、埋め込まれたゼロ、バックスラッシュは正しくエスケープされる。

c、d、E、e、f、g、G、i、o、u、X、x はすべて数値の引数を期待し、 q と s は文字列を期待する。

文字列と数値の間の変換はデータ型の指定に従って実行されます。他の型は自動的に文字列に変換されません。 NUL文字（バイト値0）を含む文字列は正しく処理されません。

Identical to `mw.ustring.format()`.

### string.gmatch

`string.gmatch(s, p)`

汎用 for 文で使用します。文字列`s`内の正規表現`p`にマッチする部分文字列を返すイテレータ関数を返します。`pattern`にキャプチャが指定されていない場合は、各呼び出しで完全一致が生成されます。

この関数では、パターンの先頭にある '`^`'は、繰り返しを妨げるので魔法のようなものではありません。それはリテラル文字として扱われます。

See `mw.ustring.gmatch()` for a similar function for which the pattern is extended as described in Ustring patterns.

### string.gsub

`string.gsub(s, p, repl[, n])`

文字列`s`内のパターン`p`にマッチする部分を`repl`で置換します。

`repl`には文字列、テーブル、関数のいずれかを指定します。`n`には置換が行われる回数を指定します。

返値は実際に置換が行われた回数が入ります。

`repl`が文字列の場合は、その文字列が置換に使われます。文字`%`はエスケープ文字として働きます。`repl`中の`%*n*`(ただし*n*は1から9)はd番目のキャプチャした部分文字列の値(以下参照)を表します。`%0`はマッチ全体を表し、`%%`は単一の`%`を表します。
`repl`がテーブルの場合は、各マッチごとに最初のキャプチャをキーとしてテーブルを引きます。パターンにキャプチャがなければ、マッチ全体をキーとして使います。
`repl`が関数の場合は、その関数はマッチが現れるたびに呼ばれ、すべてのキャプチャされた部分文字列が順番通りに引数として渡されます。パターンにキャプチャがなければ、マッチ全体が単一の引数として渡されます。
テーブル検索または関数呼び出しの戻り値が文字列または数値であれば、それが置換文字列として使われます。そうでなく、falseまたはnilであれば、置換されません(つまり、元のマッチがそのまま文字列中に保たれます)。
See `mw.ustring.gsub()` for a similar function in which the pattern is extended as described in Ustring patterns.

### string.len

`string.len(s)`
string.len(str) 文字列の長さを取得します。`#s`でも代用できます

空文字列 "" の長さは0である。 文字列中のゼロも数えるので、"a\000b\000c" の長さは5である。

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

### string.lower

`string.lower(s)`

文字列s中のアルファベットを小文字にした文字列を返します

アルファベットと同じ値の2バイト文字も変換されるので注意

See `mw.ustring.lower()` for a similar function in which all characters with uppercase to lowercase definitions in Unicode are converted.

### string.match

`string.match(s, p[, init])`

文字列`s`内のパターン`p`にマッチする部分文字列を返します。見つからなければ`nil`を返します。

パターン内にキャプチャがあればそれを返します。`init`(省略時は1)は検索開始位置を指定します。

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

### string.rep

`string.rep(s, n)`

文字列`s`を`n`回繰り返した文字列を返します。Identical to `mw.ustring.rep()`.

### string.reverse

`string.reverse(s)`

文字列`s`を逆にした文字列を返します

2バイト文字は正しく処理されません

### string.sub

`string.sub(s, i[, j])`

文字列`s`の`i`番目から`j`番目の文字までの部分文字列を返します。
`j`省略時は文字列の末尾になります。

特に、`string.sub(s,1,j)`は`s`の先頭から`j`文字を取り出し、`string.sub(s, -i)`は`s`の最後の`i`文字を取り出す。

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

### string.upper

`string.upper(s)`

文字列`s`中のアルファベットを大文字にした文字列を返します

アルファベットと同じ値の2バイト文字も変換されるので注意

See `mw.ustring.upper()` for a similar function in which all characters with uppercase to lowercase definitions in Unicode are converted.

### Luaパターン

Luaパターンは正規表現のようでそうでない。特に、正規表現やPCREとの以下の違いに注意するように:

* メタ文字にPerlなどの「`\`」ではなく、「`%`」を使う。
* ドット(`.`)は改行コードもマッチ対象。
* 文字クラスの小文字と大文字の関係は補集合となる。
* 「複数の正規表現のいずれかにマッチ」する `|` は実装されていない。
* 量指定子（`*`、`+`、`?`、および`-` ）はグループを捕らえず、個々の文字または文字クラスにのみ適用できます。
* -は0回以上の最短マッチ。(-は既存の正規表現でいうところの｢\*?｣と思っておけばよいだろう。)
* 一般化された有限数量詞はありません（例えば、PCREの `{*n*、 *m*}` 数量詞）。
* 幅がゼロのアサーションは、`^`、`$`、および`％f[set]` "frontier"パターンのみです。 PCREの`\b`や`(?=···)`などのアサーションは存在しません。
* パターン自体は '\''ddd'''のような文字エスケープを認識しません。ただし、パターンはstringsなので、これらの種類のエスケープは、pattern-stringを作成するために使用される文字列リテラルで使用できます。

パターンには途中にゼロ(ASCII NUL、`"\0"`)を含むことができない。代わりに`%z`を使う。

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

#### 文字クラス

*文字クラス* は文字の集合を表すために使われます。 文字クラスの記述では以下の組み合わせが使用できます。

#### パターンの要素

*パターンの要素* は以下のいずれかである。

* 単一の文字クラス
* 単一の文字クラスに'`*`'が続いたもの。そのクラスの文字の0以上の繰り返しにマッチする。可能な限り長いシーケンスにマッチする。
* 単一の文字クラスに'`+`'が続いたもの。そのクラスの文字の1以上の繰り返しにマッチする。可能な限り長いシーケンスにマッチする。
* 単一の文字クラスに'`-`'が続いたもの。そのクラスの文字の0以上の繰り返しにマッチする。'`*`'と異なり、可能な限り*短い*シーケンスにマッチする。
* 単一の文字クラスに'`?`'が続いたもの。そのクラスの文字の0回または1回の出現にマッチする。
* `%*n*`(*n*は1から9)。これは、*n*番目にキャプチャされた文字列にマッチするような要素である (下の説明を参照)。
* `%b*xy*`(*x*と*y*は異なる文字)。これは*x*で始まって*y*で終わる文字列にマッチするような要素である。*x*と*y*は対応が取れる。つまり、文字列を左から右に読んでいって、*x*が現れるたびにカウントを +1 し、*y*では -1 したとき、最後の*y*はカウントが0になる最初の*y*である。例えば、要素`%b()`はカッコの対応が取れた式にマッチする。
* `%f[*set*]`(*境界パターン*)。この項目は、次の文字が*set*に属し前の文字が*set*に属さない場所で、空文字列にマッチします。集合*set*は上で述べたように解釈されます。対象の先頭および末尾では、文字 '\0' が存在するかのように扱われます。
※このパターンはLua5.1ではリファレンスに載っていなかったが、Lu5.2で追加された。ソース解析でこれを見つけた人に感謝。

#### ^Pattern$

*pattern*はパターン要素の列である。

パターンの最初に現れる'`^`'は対象文字列の先頭にマッチを固定する。パターンの最後に現れる'`$`'は対象文字列の最後にマッチを固定する。他の位置では、'`^`'や'`$`'は特別な意味を持たず、それ自身を表す。

#### キャプチャ

パターンは、カッコで囲まれたサブパターンを含むことができ、これをキャプチャと呼びます。パターンが合致したときには、キャプチャに相当する部分文字列は保存され、後で使用することができるようになります。キャプチャの順序は開きカッコの出現順です。たとえば、パターン"`(a*(.)%w(%s*))`,"において、最初のキャプチャは`a*(.)%w(%s*)`に相当する部分文字列であり、2番目のキャプチャは`.`に、3番目のキャプチャは`%s*`に相当する部分文字列となります。

Luaパターンの特殊なケースとして、空っぽのキャプチャ`()`は、その場所の文字列の中での位置をキャプチャします。たとえば、パターン`"()aa()"`を文字列`"flaaap"`に適用した場合、3と5がキャプチャされます。この空っぽのキャプチャは正規表現では使えません。

## テーブルライブラリ

テーブルライブラリのほとんどの関数はテーブルがシーケンスである事を前提としています。

`table.foreach()`、`table.foreachi()`と`table.getn()`は使用非推奨のため記載していません。汎用`for`文と`pairs()`、汎用`for`文と`ipairs()`、長さ演算子`#`で代用して下さい。

### table.concat

`table.concat(t[, sep[, i[, j]]])`

テーブル`t`の`i`番目から`j`番目までの要素の間に文字列`sep`を挟み、
それら全てを連結した文字列を返します。

省略時、`sep`は空文字列、`i`は1、`j`はテーブルの長さになります。

`concat`メタメソッドは呼ばれない？
### table.insert

`table.insert(t,[ n,] v)`

テーブル`t`の位置`n`に`v`を挿入します。
`n`の位置にすでに要素がある時は、それ以降の要素を1つ後ろにずらします。
`n`省略時は`t`の末尾に追加します。

`#t`までの要素がシフトされます。テーブルがシーケンスでない場合の注意事項については、長さ演算子を参照してください。

### table.maxn

`table.maxn(t)`
テーブル`t`の正の最大の数値インデックスを返します。

※Lua 5.2で廃止
これを行うには、テーブル全体を反復処理します。これはほぼ次のものと同等です。

```
function table.maxn( table )
    local maxn, k = 0, nil
    repeat
        k = next( table, k )
        if type( k ) == 'number' and k > maxn then
            maxn = k
        end
    until not k
    return maxn
end

```

### table.remove

`table.remove(t[, n])`

テーブル`t`の位置`n`の要素を削除して、それ以降の要素を1つ前にずらします。削除された要素を返します。`n`省略時はテーブル`t`の最後尾を削除する事になります。

`#t`までの要素がシフトされます。テーブルがシーケンスでない場合の注意事項については、長さ演算子を参照してください。

### table.sort

`table.sort(t[, f])`

テーブル`t`の1から連続した正の整数のインデックスの要素を並び替えます。
`table.sort`は`t`の先頭から要素2つを関数`t`に渡して呼び出し、
関数`f`が偽の値を返したとき、2つの値の位置を入れ替えます。
`f`省略時は`<`演算子で比較した結果によってソートします。

ソートのアルゴリズムは安定*ではない*。つまり、指定された順序において等しいと考えられる要素は、ソートによってその相対位置が変わるかもしれない。

## Optimization (Garbage Collector)

Methods for collecting and flushing garbage are unavailable in Scribunto.

出典
--

1. ↑ FANDOM Technical Update: June 24, 2015
2. ↑ http://www.lua.org/manual/5.1/manual.html#pdf-collectgarbage (http://milkpot.sakura.ne.jp/lua/lua51\_manual\_ja.html#5.1)
3. ↑ Wikipedia:Lua\_reference\_manual