nil は他のどの値とも異なる特殊な値です。

C で例えるなら NULL のようなものです。 C の NULL と異なるのは、 NULL は型がポインタであり、値が NULL であるのに対し、 nil は型が nil であり、値も nil であることです。

true, false が定義されています。

ただし、論理演算が true か false だけを返す訳ではありません。 詳しくは後述します。

数値は全て符号付き実数です(Lua の環境によって整数の場合もある)。 C では char, short, int, long などのバイト長の違いや、 signed, unsigned の符号の有無の違いがありますが、 Lua では符号付き実数のみです。

実数ですが、整数ビット演算が利用可能です。

リテラルは、次のように 10 進数と 16 進数で指定できます。

• 3
• 345
• 0xff
• 0xBEBADA

また、実数は次のような指定が可能です。

• 3.0
• 3.1416
• 314.16e-2
• 0.31416E1
• 34e1
• 0x0.1E
• 0xA23p-4
• 0X1.921FB54442D18P+1

Lua の文字列は、C とは異なり '\0' で終端されていません。 なぜならば、Lua の文字列は全てのバイナリデータを格納できるためです。

終端文字があるということは、終端文字を複数持てないことと同義。

'\0' で終端されていない代わりに、文字列データそのものがサイズ情報を保持しています。 サイズ情報には # でアクセスできます。

例えば #"abc" は 3 になります。

なお、Lua の文字列には文字コードの概念はありません。 単なるバイト列として扱われます。

文字列は ' か " で囲みます。 ' で囲む場合 " を文字列中に含められます。 " で囲む場合 ' を文字列中に含められます。

文字列中には \xXX(Xは 16進数) や \ddd(Xは 10進数)で、 0〜255までの任意の値を指定できます。

さらに \u{XXX}(X は1桁以上の16進数) で、マルチバイト文字を指定できます。

文字列中に改行を含ませるには、次の方法があります。

• \n を利用する
• \ の直後に改行する
• [[]] を利用する

[[]] は [=[]=] [==[]==] [===[]===] のように = を入れられます。

[[]] で囲まれた文字列は \n 等のエスケープはそのままの文字列となります。

なお、 [[]] の [[ 直後にある改行は無視されます。

str = '"abc"' -- "abc"
str = "'abc'" -- 'abc'
str = [[
"'abc'"
]] -- "'abc'"\n
str = [=[[[abc]]]=] -- [[abc]]

文字列 str の N 番目の文字コードを取得する場合は、string.byte( str, N ) です。 N は 1 以上です。

文字列は .. で連結できます。

"abc" .. "def" は "abcdef" です。

Lua は関数自体を値として扱えます。 ただし、C の関数ポインタのように他の型への型変換はできません。 関数はあくまで関数です。

Lua は、主に C 言語をホストプログラムとして組込むことを想定した言語です。 ホストプログラムと連携して動作する場合、 ホストプログラムのデータを Lua の値にマッピングできない、 あるいはマッピングするためのオーバーヘッドが大きくなることがあります。 そのような場合に、ホストプログラムのデータを ユーザデータ として そのまま Lua に渡すことができます。

ただし Lua からは、ユーザデータはユーザデータとしてしかアクセスできません。

ユーザデータに何が格納されているか、直接 Lua スクリプトからアクセスできません。

ここでスレッドとは pthread 等で扱う OS の thread ではなく、Lua のコルーチンを指します。

コルーチンは、プリエンプティブで処理を切り替える概念です。

なお、Lua のコルーチンを複数作っても 1 つの OS の thread 上で動作します。

テーブルは、配列と STL の map が一緒になったようなデータです。 テーブルには、nil 以外の全ての型のデータを格納できます。

テーブルは、次のように {} で囲みます。

tblA = { "1", "2", "3", 4, [5] = 5 }
-- tblA[1] == "1"; tblA[2] == "2"; tblA[3] == "3"; tblA[4] == 4; tblA[5] == 5;

上記のテーブルの要素にアクセスする場合、インデックスは 1 からになります。 C 言語では 0 からなので、気を付ける必要があります。

また、次のように数値以外のキーを指定することもできます。

tblB = { foo = 1, bar = 2, [ ".hoge" ] = 3 }
-- tblB.foo == "1"; tblB.bar == "2"; tblB[".hoge"] == "3";

キーには nil(と NaN) 以外の全ての値を指定できます。

数値以外のキーが指定されている場合、 tblB.foo のようにキーのシンボルを指定して要素にアクセスできます。 tblB[ "foo" ] としてもアクセス可能です。

キーが . や = 等の文字を含んでいる場合は、 [ "." ] や [ "=" ] のように指定することでアクセスできます。

なお、テーブルで保持するデータの全てのキーが 1 から順に 1 ずつ増えている場合(自然数)、 そのテーブルを シーケンス と呼びます。 数値以外のキーや、数値であっても 1 ずつ増えてない場合は、 シーケンス とは言いません。

#table で、そのテーブルの要素数を返しますが、これはシーケンスの要素数を返します。 シーケンスでないテーブルの # は要素数を示しません。

任意のテーブルがシーケンスかどうかを判定する方法は提供されていません。

上記の例で言うと、#tblA は 5 を返しますが、#tblB は 3 になりません。

存在していないキーにアクセスすると、nil を返します。

上記の例では、 tblB.xyz は nil になります。

local function func()
  return 1, 2, 3
end
{ a, b, c, func() } -- { a, b, c, 1, 2, 3 }
{ a, b, c, func(), d } -- { a, b, c, 1, d }
{ a, b, c, func(), nil } -- { a, b, c, 1 }

変数にはグローバル変数とローカル変数があります。

ローカル変数の宣言は local を使用します。 local を使用しないとグローバル変数になります。

globalA = 10       -- global 
local localA = 10  -- local

ローカル変数のスコープは、ローカル変数宣言の次の文から有効で、 ブロックの終端で終わります。

value = 10               -- global value = 10
do
  local value = value    -- local value = global valule(10)
  value = value + 1      -- local value = 10 + 1 = 11
  print( value )         -- local value: 11
end
print( value )           -- global valule: 10

グローバル変数は、 _ENV テーブルに格納されます。

value = 10
if value == _ENV.value then -- true
  print( "equals" )
end

なお、C でグローバル変数の利用を控えることが推奨されているように、 Lua でも特に理由がない限りローカル変数を使用するべきです。

Lua の代入は、1つの文で複数の値を代入できます。

例えば次の文は、3 つの値を代入する同じ処理です。

value1 = 1
value2 = 2
value3 = 3

value1, value2, value3 = 1, 2, 3

なお、代入先の変数に対して代入元の値の個数が足りない場合、 足りない分は nil が代入されます。 代入元の値が多い場合は無視されます。

代入文でも、テーブルコンストラクタのように最終式が関数呼び出しか、 可変長式の場合は、その値全てが展開されます。

local function func()
  return 10, 20
end
value1, value2, value3 = 0, func() -- value1 = 0, value2 = 10, value2 = 20

代入は、右辺の全ての値が評価され、その後それぞれの値が左辺に代入されます。

例えば、X, Y の値を swap する場合、次のようにすることができます。

X,Y = Y,X

なお、Lua の代入は、値を持ちません。 よって、次の C の様な代入はできません。

int value1 = value2 = 0;

if exp then block {elseif exp then block} [ else block] end

Lua の if は上記構文です。

次が C との差分です。

• 条件式に () が不要
• 必ず end が必要
• else if ではなく elseif がある

while exp do block end

Lua の while は上記構文です。

次が C との差分です。

• 条件式に () が不要
• 必ず end が必要

repeat block until exp

Lua の repeat は上記構文です。

until の exp が真になるまで、block を繰り返します。

なお、exp では block で宣言したローカル変数にアクセスできます。

for 文は 2 種類あります。

int v;
for ( v = e1; v <= e2; v += e3 ) {
}

for key, value in pairs( tbl ) do
  print( key, value )
end

local function ite( param, prev )
   if prev == param then
      return nil
   end
   if prev == nil then
      prev = 0
   end
   local next = prev + 1
   return next, string.format( "%d", next )
end

for value1, value2  in ite, 10, nil do
   print( string.format( '%d "%s"',  value1, value2 ) ) -- 1, "1" : 2, "2" : 〜 : 10, "10"
end

Lua の break 文は、基本的に C 言語と同じです。

break 文は、while, repeat, for 文のループを抜けます。

ループが入れ子になっている場合は、最も内側のループを抜けます。

Lua には continue がありません。

not は真・偽を反転します。

not false -- true
not nil -- true
not true -- false
not 1 -- false

必ず true か false になります。

or は真になるまで値を評価します。 or の結果は、真になるまで最終的に評価した値です。

nil or false or 1 -- 1
nil or 2 or 3 -- 2
4 or 5 -- 4
nil or false -- false

and は、偽になるまで値を評価します。 and の結果は、偽になるまで最終的に評価した値です。

1 and 2 and 3 and nil -- nil
1 and 2 and 3 -- 3
1 and false and 2 -- false

次の定義方法があります。

• name = function( args ) block end
• local name; name = function( args ) block end

1 番目がグローバル関数で、 2 番目がローカル関数です。 name が関数名、args は引数、block は関数の処理です。 args は 0 個以上の変数です。 また、args は関数内がスコープになるローカル変数となります。

function() end が関数オブジェクトを返す式であることは分かると思います。 その関数オブジェクトをグローバル変数に代入するか、ローカル変数に代入するかで、 その関数がグローバル関数になるかローカル関数になるかが決まります。

local 関数の場合、変数に代入する前に local 変数の宣言をしています。 これは、再帰呼び出しを行なう際に、その関数自身を呼ぶことを保証するためです。

なお、関数定義は次のようにも書けます。

• function name ( args ) block end
• local function name ( args ) block end

これは上記と全く同じ意味を持ちます。

特に理由がない限り、関数定義は後者の書式で書いた方が良いでしょう。

関数オブジェクトに () を付けることによって関数が実行されます。 () には、引数を与えます。

local function func( value )
  return value + 1
end
print( "value = ", func( 1 ) ) -- 2
print( "value = ", (function(value) return value + 2 end)(1) ) -- 3

上記 5 行目のように、 function() body end で取得した関数オブジェクトに 直接 () を付けても実行できます。

関数呼び出し時に与えた引数の数と、 関数オブジェクトで定義した引数の数に違いがある場合は、 代入文で説明した通り足りない場合は nil を設定、多い場合は無視されます。

このような動作になるため、C++ のオーバーロードの概念は Lua にはありません。

Lua は、C の printf のような可変長の引数を持つ関数を定義することができます。

function( … )

上記のように引数の宣言部に … を記載することで、そこは可変長引数になります。

可変長引数は、次のようにそのまま … を指定することで与えられた引数を表現できます。

local function log( ... )
  if enableLogFlag then
    print( ... )
  end
end
log( "test", "hoge" ) -- print( "test", "hoge" )

return … で、可変長引数をそのまま返すこともできます。

… に何が与えられているのかを調べたい場合は、 {…} で、その可変長引数を要素に持つテーブルを生成できるので、 テーブルを作成した後でそのテーブルに対して操作することで 可変長引数の要素にアクセスできます。

なお、これは上記のテーブルコンストラクタで説明した通り 最終要素のみの特徴であるため、 次の場合は可変長引数の先頭要素だけを持つテーブルが生成されます。

{…,nil}

local function log( ... )
  local val1 = {...}
  print( val1[1], val1[2] ) -- "test" "hoge"
  local val2 = {...,nil}
  print( val2[1], val2[2] ) -- "test" nil
end
log( "test", "hoge" )

関数を終了し、戻り値を返します。

なお、関数は戻り値を複数個返すことができます。

local function func()
  return 1, 2, 3
end
local val1, val2, val3 = func() -- val1 = 1, val2 = 2, val3 = 3

require は、別のスクリプトで定義した機能を利用する際に使用します。

• main.lua

local sub = require( 'foo.sub' )
print( sub:func(1) ) -- 1
print( sub:func(1) ) -- 2
local sub2 = require( 'foo.sub' )
print( sub == sub2 ) -- true

• foo/sub.lua

local tbl = { value = 0 }
function tbl:func( val )
  self.value = self.value + val
  return self.value
end
return tbl

概念が似ているだけで、include とはそもそも動作が異なります。

• require はファイル名ではなく、モジュール名で指定します。

  • モジュール名は拡張子を含みません。またパス区切りには / ではなく . を使用します。
  • . や .. の相対パスは使えません。 (区切り文字が . なので、 . を使うと意味不明になる)
• require は、指定されたモジュールをロードし、実行結果を返します。
• require した際に返される値は 1 つだけです。
• require( modname ) したモジュール結果は、package.loaded[ modname ] テーブルに格納されます。
• 次に require( modname ) した時は、 package.loaded[ modname ] に格納している値を返します。
• もしも modname で指定したモジュールの内容が、前回 require したときと異なる内容になっていたとしても package.loaded[ modname ] にロードされている場合は新規にロードしなおしません。
• 強制的にロードし直したい場合は、事前に package.loaded[ modname ] = nil とします。

モジュールの検索パスは、 package.path を利用します。

loadfile は指定したスクリプトをロードして、そのロードしたスクリプトを実行するための関数を返します。 よって、loadfile が返した関数を実行するまで、指定したスクリプトは実行されません。

require と loadfile とでは次の点で異なります。

• スクリプトの実行タイミング

  • require は、 require() を処理したタイミングで実行します
  • loadfile は、loadfile() が返す関数を実行したタイミングになります

• 2回目以降の処理

  • require は、2 回目以降実行した場合は前回と同じモノを返します
  • loadfile は新しくオブジェクトを生成します
• main.lua

local sub3func = loadfile( 'foo/sub.lua' )
local sub31 = sub3func()
local sub32 = sub3func()
print( sub31:func(1) ) -- 1
print( sub32:func(1) ) -- 1
print( sub31 == sub32 ) -- false

• foo/sub.lua

local tbl = { value = 0 }
function tbl:func( val )
  self.value = self.value + val
  return self.value
end
return tbl

loadfile は次のようにファイル名の他に、mode, env を指定できます。

loadfile( filename, mode, end )

• mode は、次を指定できます。デフォルトは "bt" です。

  • "b": 対象ファイルをスクリプトファイルに限定
  • "t": 対象ファイルをバイトコード済みファイルに限定
  • "bt": 対象ファイルを限定しない
• env は、グローバル変数の格納テーブルを指定します。デフォルトは _ENV です。

次の場合を除き、 require を使うべきです。

• loadfile の mode, env 引数を指定する必要がある場合。
• スクリプトを再実行したい場合。

メタメソッドは次の引数を持ちます。

function func( value1, value2 )

次の二項演算をカスタマイズできます。

• __add

  • +

• __sub

  • -

• __mul

  • *

• __div

  • /

• __mod

  • %

• __pow

  • ^

• __concat

  • ..

• __idiv

  • // (ver 5.3)

二項演算は、第一引数、第二引数の順で、該当のハンドラを定義しているかどうかを確認します。 ハンドラを定義している場合、そのハンドラの処理を実行します。 定義していない場合は、デフォルトの処理を行ないます。

メタメソッドは演算結果を返します。

メタメソッドは次の引数を持ちます。

function func( value1, value2 )

• __band

  • &

• __bor

  • |

• __bxor

  • ~

• __bnot

  • ^

• __shl

  • <<

• __shr

  • >>

ビット演算は、第一引数、第二引数のどちらかが整数でなく、かつ整数に変換不可能な値の場合に、 第一引数、第二引数の順で、該当のハンドラを定義しているかどうかを確認します。 ハンドラを定義している場合、そのハンドラの処理を実行します。 定義していない場合は、デフォルトの処理を行ないます。

メタメソッドは演算結果を返します。

メタメソッドは次の引数を持ちます。

function func( value )

次の単項演算をカスタマイズできます。

• __unm

  • -

• __len

  • #

単項演算は、指定の値のメタテーブルが該当のハンドラを定義しているかどうかを確認します。 ハンドラを定義している場合、そのハンドラの処理を実行します。 定義していない場合は、デフォルトの処理を行ないます。

メタメソッドは演算結果を返します。

メタメソッドは次の引数を持ちます。

function func( value1, value2 )

__eq は、第一引数と第二引数が、該当のハンドラを定義しているかどうかを確認します。 また、そのハンドラが同じハンドラである場合に限り、そのハンドラの処理を実行します。 そうでない場合は、デフォルトの処理を行ないます。

メタメソッドは条件が成り立つ時に true, 成り立たない時に false を返します。

メタメソッドは次の引数を持ちます。

function func( value1, value2 )

__lt , __le は、第一引数、第二引数の順で、該当のハンドラを定義しているかどうかを確認します。 ハンドラを定義している場合、そのハンドラの処理を実行します。 定義していない場合は、デフォルトの処理を行ないます。

メタメソッドは条件が成り立つ時に true, 成り立たない時に false を返します。

ただし __le の定義がない場合、a <= b は not (b < a) として __lt を確認します。

メタメソッドは次の引数を持ちます。

function func( table, key )

table[key] のデータにアクセスする際の動作をカスタマイズします。

__index に設定されているのが関数だった場合、上記の関数として実行し戻り値を返します。 関数ではなくテーブルだった場合、そのテーブルのキー key の要素を返します。

なお、カスタマイズ可能なのは table に key のデータがない場合のみです。 table に key のデータがある場合は、その値を返します。 また、 __index に設定されているのが、関数ではなくテーブルだった場合、 そのテーブルのキー key の要素を返します。

メタデータをセットしているのがユーザデータ型の場合は、常に有効になります。

メタメソッドは table の key に対する値を返します。

メタメソッドは次の引数を持ちます。

function func( table, key, value )

table[key] にデータを設定する際の動作をカスタマイズします。

__newindex に設定されているのが関数だった場合、上記の関数として実行します。 関数ではなくテーブルだった場合、そのテーブルのキー key に値 value を設定します。

なお、カスタマイズ可能なのは table に key のデータがない場合のみです。

table に key のデータがある場合は、指定の値がセットされます。

メタデータをセットしているのがユーザデータ型の場合は、常に有効になります。

メタメソッドは次の引数を持ちます。

function func( func, … )

関数コールの動作をカスタマイズします。

指定の値のメタテーブルが該当のハンドラを定義しているかどうかを確認します。 ハンドラを定義している場合、そのハンドラの処理を実行します。 定義していない場合は、デフォルトの処理を行ないます。

メタメソッドは func の実行結果を返します。

メタメソッドは次の引数を持ちます。

function func( self )

__gc は、そのメタメソッドを設定されている値が GC で解放される前に呼び出されます。

メタメソッドは次の引数を持ちます。

function func( self )

__tostring は、 string.format の "%s" 等で変換する際に呼出されます。

メタメソッドは文字列を返します。