Lua Table のすべて：作成から操作まで完全ガイド

はじめに

Luaにおけるテーブルは、他の多くのプログラミング言語における様々なデータ構造（配列、ハッシュマップ、辞書、連想配列、構造体、オブジェクトなど）の機能をすべて兼ね備えた、言語の中核をなす唯一の複合データ型です。シンプルでありながら驚くほど強力で柔軟性があり、Luaプログラミングのほぼすべてにおいてテーブルの理解は不可欠です。

他の言語で複数の専用のデータ構造を使い分ける必要があるのに対し、Luaでは単一のテーブル型でこれら全ての役割をこなします。これにより、言語の設計がシンプルになり、学習曲線が緩やかになります。しかし、その多機能性ゆえに、テーブルの内部的な挙動や様々な使用パターンを深く理解することが、効率的でLuaらしいコードを書く上で重要となります。

Luaのテーブルは、基本的にキーと値のペアの集まりです。キーにはnilとNaN（Not-a-Number）を除く任意の型の値を使用でき、値にはnilを含む任意の型の値を使用できます。要素をテーブルから削除するには、そのキーに対応する値をnilに設定するだけです。

この記事では、Luaテーブルの基本から応用までを網羅的に解説します。テーブルの作成方法、要素へのアクセスと操作、配列としての利用、ハッシュマップとしての利用、イテレーションの方法、コピー、関数やメタテーブルとの連携、そして効率的な使用法について、豊富なコード例と共に詳細に説明します。この記事を読めば、Luaテーブルの真価を理解し、Luaプログラミングのレベルを一段階引き上げることができるでしょう。

さあ、Luaテーブルの深淵な世界へ踏み込みましょう。

Luaテーブルの基本

Luaテーブルは、波括弧 {} を使って作成します。空のテーブルを作成することも、初期値を指定して作成することも可能です。

空のテーブルの作成

最も基本的なテーブルの作成方法は、空の波括弧を使用することです。

lua local myTable = {} print(type(myTable)) -- 出力: table

これにより、何も要素を含まない新しいテーブルが作成されます。

初期値を持つテーブルの作成

テーブルの作成時に、初期のキーと値のペアを指定することができます。これはテーブルコンストラクタと呼ばれます。コンストラクタ内で指定された要素は、新しいテーブルに自動的に挿入されます。

初期値を指定する方法はいくつかあります。

1. 配列ライクな要素:

要素を順番にカンマ , で区切って並べると、自動的に1から始まる連続した整数キーが割り当てられます。これは配列ライクなテーブルを作成する一般的な方法です。

“`lua
local fruits = {“apple”, “banana”, “cherry”}
— これは以下と等価です:
— local fruits = { [1] = “apple”, [2] = “banana”, [3] = “cherry” }

print(fruits[1]) — 出力: apple
print(fruits[2]) — 出力: banana
print(fruits[3]) — 出力: cherry
print(#fruits) — 出力: 3 (配列の長さ演算子)
“`

Luaの配列は1ベースインデックスであることに注意してください。最初の要素のキーは1です。

2. ハッシュマップライクな要素 (キーと値のペア):

キー = 値 の形式を使用することで、特定のキーを持つ要素を指定できます。キーが有効な識別子（変数名などに使える文字列）である場合、ドット .構文に似た キー = 値 の形式を使えます。有効な識別子でない場合や、文字列以外のキーを使いたい場合は、[キー] = 値 の形式を使います。これらはハッシュマップライクなテーブルを作成する一般的な方法です。

“`lua
local person = {
name = “Alice”,
age = 30,
city = “New York”
}
— これは以下と等価です:
— local person = { [“name”] = “Alice”, [“age”] = 30, [“city”] = “New York” }

print(person.name) — 出力: Alice
print(person[“age”]) — 出力: 30 (ageは識別子だが、ブラケット構文も使える)
print(person.city) — 出力: New York
“`

キーとして文字列以外も使用できます。

“`lua
local myMap = {
[100] = “Value for 100”,
[true] = “Value for true”,
[{}] = “Value for a new table as key” — 新しいテーブルをキーに使用 (各テーブルはユニークな参照を持つ)
}

print(myMap[100]) — 出力: Value for 100
print(myMap[true]) — 出力: Value for true

— {} をキーにした値を取得するには、同じテーブル参照を使う必要がある
local keyTable = {}
myMap[keyTable] = “Value for keyTable reference”
print(myMap[keyTable]) — 出力: Value for keyTable reference
print(myMap[{}]) — 出力: nil (別の新しいテーブルだから)
“`

キーとして使える値は、nilとNaN（Not-a-Number）を除く任意の型の値です。

3. 混合型のテーブル:

一つのテーブルコンストラクタ内で、配列ライクな形式とハッシュマップライクな形式を混在させることもできます。

“`lua
local mixedTable = {
“first array element”, — キー 1
“second array element”, — キー 2
name = “Bob”, — キー “name”
age = 25, — キー “age”
[5] = “fifth element”, — キー 5 (途中の3, 4は飛ばされている)
“sixth element” — キー 6 (前の要素(キー5)の次の整数キー)
}

print(mixedTable[1]) — 出力: first array element
print(mixedTable[2]) — 出力: second array element
print(mixedTable.name) — 出力: Bob
print(mixedTable.age) — 出力: 25
print(mixedTable[5]) — 出力: fifth element
print(mixedTable[6]) — 出力: sixth element
print(#mixedTable) — 出力: 6 (配列部分の長さ、挙動は後述)
print(mixedTable[3]) — 出力: nil (キー3は存在しない)
“`

テーブルコンストラクタ内の要素はカンマ , またはセミコロン ; で区切ることができます。通常はカンマが使われますが、セミコロンも同様に機能します。これは主に、カンマを含む文字列や式を値として使用する場合に、可読性を高めるために使われることがあります。

lua local anotherMixed = { id = 123; status = "active", "ready"; -- これは実際にはエラーではなく、"active" が status キーの値になり、"ready" は新しい要素 (キー3) になる data = { x = 10, y = 20 } } -- 混乱を避けるため、通常は要素間はカンマで統一し、値リストは別のテーブルコンストラクタ内で定義する方が良い local preferredMixed = { id = 123, status = "active", readiness = "ready", -- 別々のキーにするか data = { x = 10, y = 20 } }
テーブルコンストラクタ内の status = "active", "ready" の例はややトリッキーです。Luaのパーサーはこれを status = "active" と ["ready"] として解釈しません。テーブルコンストラクタは field1, field2, ... というリストであり、それぞれのフィールドは [exp1] = exp2 または name = exp または exp のいずれかの形式を取り得ます。exp 形式は [i] = exp （ここで i は前に自動割り当てされた整数キーの次の値）と解釈されます。したがって、status = "active", "ready" は status = "active" (キー “status”) と "ready" (前の要素の次の整数キー、つまり3) と解釈されます。意図しない挙動になりがちなので注意が必要です。

テーブルの型

type() 関数を使うと、テーブルの型を確認できます。当然ですが、結果は常に "table" になります。

lua local t = {} print(type(t)) -- 出力: table

テーブルは参照型です。変数にテーブルを代入すると、テーブルそのものではなく、そのテーブルへの参照がコピーされます。

“`lua
local original = { a = 1, b = 2 }
local copy = original — 参照をコピー
copy.a = 10
print(original.a) — 出力: 10 (originalも変更される)

local newTable = {}
for k, v in pairs(original) do — 内容をコピー (浅いコピー)
newTable[k] = v
end
newTable.a = 100
print(original.a) — 出力: 10 (originalは変更されない)
print(newTable.a) — 出力: 100
“`
テーブルのコピーについては後ほど詳しく説明します。

テーブルへのアクセスと操作

テーブルを作成したら、その要素にアクセスしたり、要素を追加・変更・削除したりすることができます。

要素へのアクセス

テーブルの要素にアクセスするには、ブラケット演算子 [] または ドット演算子 . を使用します。

ブラケット演算子 []:
任意の有効なキー（nilとNaNを除く）を使って値にアクセスできます。ブラケットの中には、キーを表す式を書きます。
“`lua
local t = {
[1] = “one”,
[“name”] = “Lua”,
[true] = “boolean key”
}

print(t[1]) — 出力: one
print(t[“name”]) — 出力: Lua
print(t[true]) — 出力: boolean key

local keyVar = “name”
print(t[keyVar]) — 出力: Lua (変数を使ったアクセス)

local numKey = 1 + 0 — 式を使ったアクセス
print(t[numKey]) — 出力: one

local complexKey = {}
t[complexKey] = “complex value”
print(t[complexKey]) — 出力: complex value
`` 指定したキーが存在しない場合、またはそのキーの値がnilである場合、アクセス結果はnil` になります。

lua local t = { a = 10 } print(t["b"]) -- 出力: nil t["a"] = nil -- 要素を削除 print(t["a"]) -- 出力: nil
キーが存在しないのか、値がnilなのかを区別するには、pairsやnext（nextはやや低レベル）といったイテレータを使う必要があります。
ドット演算子 .:
ドット演算子は、キーが文字列リテラルであり、かつ有効なLua識別子である場合にのみ使用できます。これはブラケット演算子 ["key"] の糖衣構文（シンタックスシュガー）です。

“`lua
local person = { name = “Alice”, age = 30 }

print(person.name) — 出力: Alice (person[“name”] と等価)
print(person.age) — 出力: 30 (person[“age”] と等価)
“`
ドット演算子はコードをより簡潔にしますが、使えるキーの種類が限られます。文字列ではないキーや、空白や特殊文字を含む文字列キーには使えません。

lua local t = { ["my-key"] = "value" } -- print(t.my-key) -- これはエラーになります。ハイフンは減算と解釈されます。 print(t["my-key"]) -- 出力: value

また、ドット演算子の後にくる名前がLuaの予約語（if, while, functionなど）である場合も使用できません。

lua local keywords = { ["if"] = "conditional" } -- print(keywords.if) -- Syntax error near 'if' print(keywords["if"]) -- 出力: conditional

一般的に、ブラケット演算子の方がより汎用性があります。ドット演算子は、有効な識別子である文字列キーに対してコードの可読性を高めるために使用されます。

要素の追加と変更

テーブルに新しい要素を追加したり、既存の要素の値を変更したりするには、アクセス演算子 [] または . の左辺にテーブルとキーを指定し、右辺に新しい値を代入します。

“`lua
local person = {} — 空のテーブルを作成

— 新しい要素を追加
person.name = “Bob” — キー “name”, 値 “Bob”
person[“age”] = 25 — キー “age”, 値 25
person[1] = “first item” — キー 1, 値 “first item”

print(person.name) — 出力: Bob
print(person[1]) — 出力: first item

— 既存の要素の値を変更
person.age = 26
person[1] = “updated first item”

print(person.age) — 出力: 26
print(person[1]) — 出力: updated first item
“`

配列ライクなテーブルの末尾に要素を追加する一般的な方法は、長さ演算子 # とブラケット演算子を組み合わせる方法です。

“`lua
local list = { “a”, “b” }
list[#list + 1] = “c” — #list は 2 なので、list[3] = “c” となる
list[#list + 1] = “d” — #list は 3 なので、list[4] = “d” となる

print(#list) — 出力: 4
print(list[3]) — 出力: c
print(list[4]) — 出力: d
`` ただし、この方法はテーブルが密な配列（1から連続した整数キーを持つ）である場合に最も確実に機能します。疎な配列や、非数値キーを含むテーブルでの#演算子の挙動には注意が必要で、この方法が常に期待通りに末尾に追加するとは限りません。安全に配列の末尾に要素を追加するには、table.insert()` 関数を使用することを推奨します。

要素の削除

テーブルから要素を削除するには、そのキーに対応する値を nil に設定します。

“`lua
local t = { a = 10, b = 20, c = 30 }

print(t.a, t.b, t.c) — 出力例: 10 20 30

t.b = nil — キー “b” の要素を削除
print(t.a, t.b, t.c) — 出力例: 10 nil 30

t[1] = “first”
t[2] = “second”
print(t[1], t[2]) — 出力例: first second

t[1] = nil — キー 1 の要素を削除
print(t[1], t[2]) — 出力例: nil second
`` 値をnilに設定されたキーは、テーブルから削除されたと見なされ、以降のテーブル走査（pairs`など）では通常現れなくなります。これはガベージコレクションの対象となり、メモリが解放される可能性があります。

多次元テーブル (ネストされたテーブル)

テーブルの値として別のテーブルを持つことで、多次元的なデータ構造を表現できます。

“`lua
local matrix = {
{1, 2, 3}, — matrix[1] は {1, 2, 3} というテーブル
{4, 5, 6}, — matrix[2] は {4, 5, 6} というテーブル
{7, 8, 9} — matrix[3] は {7, 8, 9} というテーブル
}

print(matrix[1][1]) — 出力: 1 (1行目の1列目)
print(matrix[2][3]) — 出力: 6 (2行目の3列目)

local complexData = {
person1 = { name = “Alice”, age = 30, address = { street = “Main St”, city = “Anytown” } },
person2 = { name = “Bob”, age = 25, address = { street = “Oak Ave”, city = “Otherville” } }
}

print(complexData.person1.name) — 出力: Alice
print(complexData.person2.address.city) — 出力: Otherville
“`
ネストの深さに制限はありません（ただし、スタックオーバーフローやメモリ制限は考慮する必要があります）。

テーブルと配列

前述のように、Luaは配列に特化したデータ型を持たず、テーブルで配列を表現します。1から始まる連続した整数キーを持つテーブルが「配列ライクなテーブル」として扱われます。

Luaにおける配列の特別な扱い

Luaのいくつかの組み込み機能や標準ライブラリ関数は、テーブルを配列として扱う際に特別な挙動を示します。最も顕著なのは長さ演算子 # と、table標準ライブラリです。

長さ演算子 `#`

テーブルに対して # 演算子を使用すると、「配列部分の長さ」を返そうとします。具体的には、1から始まり、値が nil でない最大の整数キー i を返します。もし、キー i の値が nil でないにも関わらず、キー i+1 の値が nil である場合（つまり配列に「穴」がある場合）、# 演算子の結果は i か、または nil でないキーを持つ任意の j < i の値である可能性があります。

理想的な、穴のない密な配列では、# 演算子は期待通りに要素数を返します。

“`lua
local denseArray = {“a”, “b”, “c”, “d”}
print(#denseArray) — 出力: 4

local denseWithNilEnd = {“a”, “b”, “c”, nil} — 最後のnilはテーブルに含まれないと見なされる
print(#denseWithNilEnd) — 出力: 3
“`

しかし、配列部分に「穴」（nil値またはキーの欠落）がある場合、# 演算子の結果は予測が難しくなります。

lua local sparseArray = {10, 20, [5] = 50, 60} -- このテーブルは以下のキー/値ペアを持つ: { [1]=10, [2]=20, [5]=50, [6]=60 } -- キー3, 4は存在しない（穴がある） print(#sparseArray) -- 出力例: 2 または 6 (Luaの実装による) -- 一般的に、穴の手前で見つかった nil でない最後のキーの値を返す可能性が高いが保証はない -- Lua 5.2以降は、穴がない最大の i を返そうとする -- この例では、i=2 までは連続している。 i=5 は穴の後。 -- したがって、多くの実装で 2 または 6 を返しうる。

非数値キーが存在する場合、# 演算子はそれらを無視し、あくまで整数キーの連続性に基づいて長さを計算しようとします。

lua local mixedTable = {"one", "two", name = "three", [4] = "four"} -- キー/値ペア: { [1]="one", [2]="two", ["name"]="three", [4]="four" } print(#mixedTable) -- 出力: 2 (キー1, 2は連続しているが、3が欠落しているため)

結論として、# 演算子は密な配列に対して使うのが最も安全です。疎な配列や混合テーブルの場合は、意図した結果が得られない可能性があることを理解しておく必要があります。

`table` 標準ライブラリ

Luaの標準ライブラリ table は、配列ライクなテーブルに対して便利な操作を提供する関数を提供します。

table.insert(table, [pos], value):
posで指定された位置（インデックス）にvalueを挿入します。posを省略した場合、テーブルの末尾（#table + 1の位置）に挿入します。指定された位置以降の既存の要素は後ろにずらされます。

“`lua
local list = {“a”, “b”, “c”}
table.insert(list, “d”) — 末尾に追加
— list は {“a”, “b”, “c”, “d”} になる
print(list[4]) — 出力: d
print(#list) — 出力: 4

table.insert(list, 2, “x”) — 2番目の位置に挿入
— list は {“a”, “x”, “b”, “c”, “d”} になる
print(list[1], list[2], list[3], list[4], list[5]) — 出力: a x b c d
print(#list) — 出力: 5
``table.insertは、末尾への追加時に#table + 1を使うため、#` 演算子の挙動に依存します。ただし、これは標準的な配列操作として意図されており、一般的な密な配列では期待通りに動作します。
table.remove(table, [pos]):
posで指定された位置（インデックス）の要素を削除し、その値を返します。指定された位置以降の既存の要素は前にずらされます。posを省略した場合、末尾の要素（#tableの位置）を削除します。

“`lua
local list = {“a”, “b”, “c”, “d”}
local removed_last = table.remove(list) — 末尾を削除
— list は {“a”, “b”, “c”} になる, removed_last は “d”
print(#list) — 出力: 3
print(removed_last) — 出力: d

local removed_middle = table.remove(list, 2) — 2番目を削除
— list は {“a”, “c”} になる, removed_middle は “b”
print(list[1], list[2]) — 出力: a c
print(#list) — 出力: 2
print(removed_middle) — 出力: b
``table.removeも#` 演算子の挙動に依存します。
table.concat(table, [sep], [i], [j]):
テーブルの要素を文字列として結合します。結合する要素は、整数キー i から j までのものに限定されます。sep は区切り文字として使用されます。sep、i、j は省略可能です。sep のデフォルトは空文字列 ""、i のデフォルトは 1、j のデフォルトは #table です。

lua local list = {"apple", "banana", "cherry"} print(table.concat(list)) -- 出力: applebananacherry print(table.concat(list, ", ")) -- 出力: apple, banana, cherry print(table.concat(list, "-", 2, 3)) -- 出力: banana-cherry
table.concat は、デフォルトで 1 から #table までの整数キーを持つ要素のみを対象とします。
table.sort(table, [comp]):
テーブルをインプレース（元のテーブルを直接変更）でソートします。ソートの基準は整数キーです。comp はオプションの比較関数で、comp(a, b) が true を返すと a が b より前に来ます。comp が省略された場合、標準の < 演算子を使用してソートします。

“`lua
local numbers = {3, 1, 4, 1, 5, 9, 2}
table.sort(numbers)
— numbers は {1, 1, 2, 3, 4, 5, 9} になる
for _, v in ipairs(numbers) do
print(v)
end

local strings = {“banana”, “apple”, “cherry”}
table.sort(strings)
— strings は {“apple”, “banana”, “cherry”} になる

local objects = {{name = “Bob”, age = 25}, {name = “Alice”, age = 30}}
table.sort(objects, function(a, b)
return a.age < b.age — ageで昇順ソート
end)
— objects は {{name=”Bob”, age=25}, {name=”Alice”, age=30}} になる
``table.sort` も 1から始まる連続した整数キーを持つ要素に対して機能します。
table.move(a1, f, e, t, a2) (Lua 5.3+):
テーブル a1 の f から e までの要素を、テーブル a2 の t から始まる位置に移動します。a2 を省略した場合、a1 に移動します。これはテーブル内の要素のブロックを効率的にコピーまたは移動するために使用されます。

lua local source = {10, 20, 30, 40, 50} local dest = {1, 2, 3} table.move(source, 2, 4, 4, dest) -- sourceのキー2から4 (値 20, 30, 40) を destのキー4からに移動 -- dest は {1, 2, 3, 20, 30, 40} になる for _, v in ipairs(dest) do print(v) end -- 出力: 1 2 3 20 30 40

table ライブラリの関数は、主にテーブルを密な配列として使用する場合に便利です。疎な配列や、非数値キーを多く含むテーブルに対してこれらの関数を使用する際は注意が必要です。

テーブルとハッシュマップ/連想配列

Luaテーブルのもう一つの重要な役割は、キーと値のペアを格納するハッシュマップ（または連想配列、辞書）としての機能です。キーにはnilとNaNを除く任意の型の値を使用できます。

任意の型のキー

Luaのテーブルでは、数値、文字列、ブーリアン、関数、userdata、そして他のテーブルなど、様々な型の値をキーとして使用できます。

“`lua
local myMap = {}
local funcKey = function() end
local tableKey = {}

myMap[123] = “numeric key”
myMap[“hello”] = “string key”
myMap[true] = “boolean key”
myMap[funcKey] = “function key”
myMap[tableKey] = “table key”

print(myMap[123]) — 出力: numeric key
print(myMap[“hello”]) — 出力: string key
print(myMap[true]) — 出力: boolean key
print(myMap[funcKey]) — 出力: function key
print(myMap[tableKey]) — 出力: table key

— 異なるテーブル参照は異なるキーと見なされる
print(myMap[{}]) — 出力: nil
`` キーの等価性は、Luaの等価性ルール（==`演算子）に基づいて判断されます。特にテーブルやuserdataは参照で比較されるため、同じ内容でも参照が異なれば別のキーと見なされます。

`nil`をキーにできない理由

Luaのテーブルは、キーに対応する値がnilである場合にそのキーの要素が存在しない（削除された）と解釈します。したがって、キー自体にnilを使用することはできません。もしnilをキーとして指定しようとすると、エラーが発生します。

lua local t = {} t[nil] = "value" -- エラー: table index is nil
また、キーにNaN（Not-a-Number）を使用することもできません。これは、IEEE 754浮動小数点数の仕様で、NaNは自分自身を含め他のどの値とも等しくないと定義されているため、キーとして機能しないからです。

lua local t = {} local nan = 0/0 t[nan] = "value" -- エラー: table index is NaN

キーの重複と上書き

テーブルに既に存在するキーで新しい値を代入すると、元の値は上書きされます。

“`lua
local config = { setting1 = 10, setting2 = “abc” }
print(config.setting1) — 出力: 10

config.setting1 = 20 — 値を変更
print(config.setting1) — 出力: 20

config[“setting2”] = “xyz” — 値を変更
print(config.setting2) — 出力: xyz

config[“new_setting”] = true — 新しいキーを追加
print(config.new_setting) — 出力: true
“`

キーの存在チェック

特定のキーがテーブルに存在するかどうかを確認する最も一般的な方法は、そのキーに対応する値を取得し、それがnilでないかを確認することです。

“`lua
local person = { name = “Alice”, age = 30 }

if person.name ~= nil then
print(“Name exists:”, person.name) — 出力: Name exists: Alice
end

if person.city == nil then
print(“City does not exist”) — 出力: City does not exist
end
`` ただし、この方法は「キーが存在し、その値が明示的にnilに設定されている場合」と「キーが最初から存在しない場合」を区別できません。両方の場合で取得結果はnil`になるからです。

キーが本当に存在するかどうか（つまり、値がnilであってもキーとして登録されているか）を確認するには、低レベルな next() 関数を使う方法があります。next(table, key) は、指定された key の次にテーブル内に存在するキーと値を返します。キーが存在しない場合は nil を返します。

“`lua
local t = { existing_key = 10, nil_value_key = nil } — nil_value_keyは存在するが値がnil
t.non_existent_key = nil — non_existent_keyは存在しない

print(t.existing_key) — 出力: 10
print(t.nil_value_key) — 出力: nil
print(t.non_existent_key) — 出力: nil

— キーが存在するかどうかを正確に判定 (ただし、通常は pairs で十分)
— Lua 5.0以降の仕様では、nilを値として設定されたキーはテーブルから削除されるため、
— この「値がnilだがキーは存在する」という状態は通常発生しません。
— 次の例は、メタテーブル等で特殊な操作が行われない限り、t.key == nil と next(t, key) == nil は同義となります。
— そのため、一般的なコードで next を使ってキーの存在を判定する必要はほとんどありません。
— 念のため、古いLuaバージョンや特殊なケースを考慮した表現を残しておきますが、実用的ではないかもしれません。

— 通常はこれで十分:
if t.nil_value_key == nil then
print(“t.nil_value_key is nil (either not exists or value is nil)”) — 出力
end

— より正確な判定 (ただし、Luaの通常セマンティクスでは t.key = nil はキー削除)
— local key_exists = select(2, next(t, “nil_value_key”)) ~= nil
— print(“Key ‘nil_value_key’ exists?”, key_exists) — Luaの通常セマンティクスでは false

— MetaTableの__indexを使ったキーの存在チェックは高度なトピックです。
— __index メタメソッドが定義されている場合、存在しないキーへのアクセス時に__indexが呼ばれるため、
— t.key == nil の判定は__indexの結果に依存する可能性があります。
— しかし、__indexはキーが存在しない場合にのみ呼ばれるため、t.key == nil はやはり「キーが存在しないか、存在しても値がnilである」という意味になります。
— 結局のところ、Luaで一般的なテーブル操作においては、t.key == nil をキーの存在チェックとして使うのが最も普通です。もしキーが存在するが値がnilであるという状態を特別に扱いたい場合は、別の方法（例えば、nil以外の特別な値で「削除済み」を示す）を検討する必要がありますが、これは一般的ではありません。
“`

テーブルのイテレーション

テーブルの要素を一つずつ処理（走査）するには、ジェネリックforループとイテレータ関数を使用します。Luaはテーブル走査のために二つの主要なイテレータ関数 pairs() と ipairs() を提供しています。

ジェネリックforループ

ジェネリックforループの構文は for var1, var2, ... in iterator, state, initial_value do ... end です。テーブル走査では、通常 for key, value in iterator(table) do ... end の形式を使用します。

`pairs()` イテレータ

pairs(table) は、テーブル内のすべてのキーと値のペアを列挙するためのイテレータです。キーの順序は保証されません。テーブルのハッシュ部分（非整数キー、または連続していない整数キー）と配列部分（連続した整数キー）の両方を走査します。

“`lua
local t = {
name = “Alice”,
age = 30,
[1] = “first”,
[3] = “third”, — 穴がある
city = “London”
}

print(“Iterating with pairs():”)
for key, value in pairs(t) do
print(“Key:”, key, “Value:”, value)
end
— 出力例 (順序は不定):
— Key: 1 Value: first
— Key: 3 Value: third
— Key: name Value: Alice
— Key: age Value: 30
— Key: city Value: London
``pairs()は、テーブルに格納されているすべてのキー・値ペアを、nil` 値が設定されたキーを除いて確実に列挙します。

`ipairs()` イテレータ

ipairs(table) は、テーブルの配列部分のみを効率的に列挙するためのイテレータです。具体的には、キーが 1 から始まり、値が nil でない最初のキーまでを順番に（昇順に）列挙します。

“`lua
local t = {
[1] = “one”,
[2] = “two”,
[4] = “four”, — キー3がない (穴)
[“name”] = “Lua”
}

print(“Iterating with ipairs():”)
for index, value in ipairs(t) do
print(“Index:”, index, “Value:”, value)
end
— 出力:
— Index: 1 Value: one
— Index: 2 Value: two
— (キー3がないため、ここで停止)
``ipairs()は、キーiに対してt[i]をチェックし、それがnilでなければ(i, t[i])を返して次のキーi+1を試します。値がnil` になった時点で走査を終了します。これにより、密な配列ではすべての要素を効率的に走査できますが、配列部分に穴がある場合は途中で停止します。非数値キーは完全に無視されます。

`pairs()` と `ipairs()` の使い分け

テーブル全体（ハッシュ部分と配列部分）のすべてのキーと値を走査したい場合は、pairs() を使用します。キーの順序は重要でない場合に適しています。
テーブルを1から始まる密な配列として扱い、その配列部分を順番に走査したい場合は、ipairs() を使用します。配列に穴がある場合、ipairs は途中で停止することを理解しておく必要があります。

数値forループ

テーブルが1から始まる密な配列であることが分かっている場合、長さ演算子 # と組み合わせて数値forループを使用することもできます。

lua local list = {"a", "b", "c"} for i = 1, #list do print("Index:", i, "Value:", list[i]) end -- 出力: -- Index: 1 Value: a -- Index: 2 Value: b -- Index: 3 Value: c
この方法は ipairs() と似ていますが、# 演算子の正確さに依存します。密な配列であることが確実なら問題ありませんが、疎な配列では ipairs() と同様に途中で停止したり、# の結果によっては期待通りの範囲を走査しない可能性があります。また、非数値キーは完全に無視されます。

テーブルのコピー

Luaのテーブルは参照型です。あるテーブルを変数に代入したり、関数に引数として渡したりすると、テーブルそのものがコピーされるのではなく、テーブルへの参照がコピーされます。したがって、コピーした変数経由でテーブルの内容を変更すると、元のテーブルも変更されます。

テーブルの内容を独立してコピーしたい場合は、新しいテーブルを作成し、元のテーブルから要素を一つずつ新しいテーブルにコピーする必要があります。コピーの方法には「浅いコピー（Shallow Copy）」と「深いコピー（Deep Copy）」があります。

浅いコピー (Shallow Copy)

浅いコピーでは、元のテーブルのトップレベルのキーと値のペアを新しいテーブルにコピーします。値が別のテーブルへの参照である場合、その参照がコピーされるだけで、参照先のテーブル自体はコピーされません。つまり、元のテーブルとコピー先のテーブルは、ネストされたテーブルを共有します。

浅いコピーは、pairs() イテレータを使ってシンプルに実装できます。

“`lua
function shallow_copy(t)
local new_t = {}
for k, v in pairs(t) do
new_t[k] = v — キーと値をそのままコピー
end
return new_t
end

local original = {
a = 10,
b = { x = 1, y = 2 }, — ネストされたテーブル
c = “hello”
}

local copied = shallow_copy(original)

print(“Original:”, original.a, original.b.x, original.c) — 出力: Original: 10 1 hello
print(“Copied:”, copied.a, copied.b.x, copied.c) — 出力: Copied: 10 1 hello

— コピー側のトップレベル要素を変更
copied.a = 20
print(“Original:”, original.a, copied.a) — 出力: Original: 10 Copied: 20 (aは独立)

— コピー側のネストされたテーブルの要素を変更
copied.b.x = 99
print(“Original:”, original.b.x, “Copied:”, copied.b.x) — 出力: Original: 99 Copied: 99 (bの中身は共有されている)
“`
浅いコピーはシンプルで高速ですが、ネストされたテーブルがある場合には注意が必要です。

深いコピー (Deep Copy)

深いコピーでは、元のテーブルとその中にネストされているすべてのテーブルを再帰的にコピーします。これにより、元のテーブルとコピー先のテーブルは完全に独立し、一方の変更がもう一方に影響することはありません。

深いコピーは再帰関数として実装する必要があります。また、テーブルの循環参照（テーブルAがテーブルBを参照し、テーブルBがテーブルAを参照しているような状況）を適切に処理しないと、無限ループに陥る可能性があります。

循環参照を扱うためには、既にコピー済みのテーブルを記憶しておく仕組みが必要です。

“`lua
function deep_copy(t, seen)
— nilや非テーブル型の値はそのまま返す
if type(t) ~= “table” then
return t
end

-- 循環参照をチェック (既に見ているテーブルか？)
seen = seen or {} -- seenテーブルがまだなければ作成
if seen[t] then
    return seen[t] -- 既にコピーしたテーブルへの参照を返す
end

-- 新しいテーブルを作成
local new_t = {}
seen[t] = new_t -- 元のテーブルと新しいテーブルのマッピングを記憶

-- 要素を再帰的にコピー
for k, v in pairs(t) do
    -- キーもテーブルの場合があるので再帰的にコピー
    local new_k = deep_copy(k, seen)
    -- 値も再帰的にコピー
    local new_v = deep_copy(v, seen)
    new_t[new_k] = new_v
end

return new_t

end

local original = {
a = 10,
b = { x = 1, y = 2 },
c = “hello”
}
original.self = original — 循環参照の例

local copied = deep_copy(original)

print(“Original:”, original.a, original.b.x, original.c)
print(“Copied:”, copied.a, copied.b.x, copied.c)

— コピー側のトップレベル要素を変更
copied.a = 20
print(“Original:”, original.a, “Copied:”, copied.a) — 独立

— コピー側のネストされたテーブルの要素を変更
copied.b.x = 99
print(“Original:”, original.b.x, “Copied:”, copied.b.x) — 独立

— 循環参照のチェック
print(“Original self:”, original.self == original) — 出力: true
print(“Copied self:”, copied.self == copied) — 出力: true (新しい循環参照が作成された)
print(“Original self == Copied self:”, original.self == copied.self) — 出力: false (参照が異なるため)

— 参照されていない元の循環参照要素を削除
original.self = nil
print(“Original self after nil:”, original.self) — 出力: nil
print(“Copied self:”, copied.self == copied) — 出力: true (コピーされた循環参照は保持されている)
“`
深いコピーは浅いコピーよりも複雑で、特に大規模なテーブルや複雑な構造を持つテーブルではパフォーマンスに影響を与える可能性があります。必要に応じて使い分けることが重要です。

テーブルと関数（オブジェクト指向プログラミングの基礎）

Luaでは、関数も第一級の値として扱われるため、テーブルの要素として関数を格納することができます。これを利用して、オブジェクト指向プログラミング（OOP）のようなスタイルを実現できます。

テーブルに関数を格納する

テーブルの値として関数を代入することができます。

“`lua
local myObject = {}

myObject.greet = function(obj)
print(“Hello, my name is ” .. obj.name)
end

myObject.name = “World”

myObject.greet(myObject) — 出力: Hello, my name is World
`` この例では、greet関数は引数としてテーブル自身（myObject）を受け取っています。慣習として、このようなメソッド関数では、そのメソッドが呼び出されたテーブル自身を指すためにself` という名前のパラメータを使用することが多いです。

“`lua
local myObject = {}

myObject.greet = function(self)
print(“Hello, my name is ” .. self.name)
end

myObject.name = “World”

myObject.greet(myObject) — 出力: Hello, my name is World
“`

メソッド構文 `:`

Luaは、テーブルの要素として格納された関数を、よりオブジェクト指向らしく呼び出すための糖衣構文 :（コロン）を提供しています。

table:method(args) という呼び出しは、table.method(table, args) と完全に等価です。コロン構文を使用すると、呼び出し対象のテーブルが自動的に第一引数として関数に渡されます。これにより、メソッドの定義時に self パラメータを明示的に定義し、呼び出し時に self を渡す手間を省けます。

メソッドを定義する際にも、コロン構文を使用できます。

“`lua
local myObject = {}

— コロン構文でメソッドを定義
function myObject:greet(greeting)
— ここでの self は、メソッドが呼び出されたテーブル (myObject) を指す
print((greeting or “Hello”) .. “, my name is ” .. self.name)
end

myObject.name = “Lua”

— コロン構文でメソッドを呼び出し
myObject:greet() — 出力: Hello, my name is Lua
myObject:greet(“Hi”) — 出力: Hi, my name is Lua

— ドット構文でも呼び出せるが、selfを明示的に渡す必要がある
myObject.greet(myObject, “Hey”) — 出力: Hey, my name is Lua
“`
コロン構文は、Luaでオブジェクト指向的なコードを書く際の基盤となります。クラスや継承といった概念は、主にテーブルとメタテーブル（後述）を組み合わせて実現されます。テーブルがオブジェクトの「インスタンス」となり、メソッドやプロパティを保持します。

テーブルとメタテーブル（高度なトピック）

メタテーブルは、Luaの強力な機能の一つであり、テーブルの特定の操作の挙動を変更するために使用されます。テーブルにメタテーブルを設定することで、標準の演算子（加算、連結、比較など）のオーバーロードや、存在しないキーへのアクセス、新しいキーへの代入といった挙動をカスタマイズできます。

メタテーブルの目的

メタテーブルは、あるテーブル（オペランドテーブル）が特定の操作を受けたときに呼ばれる特殊な関数群（メタメソッド）を保持するテーブルです。メタメソッドは、メタテーブル内の特定の名前のフィールドとして定義されます（例: __add は加算、__index はインデックスアクセス）。

`setmetatable()` と `getmetatable()`

テーブルにメタテーブルを設定するには setmetatable(table, metatable) 関数を使用します。メタテーブルを取得するには getmetatable(table) 関数を使用します。

“`lua
local myTable = {}
local myMetatable = {}

setmetatable(myTable, myMetatable) — myTable に myMetatable を設定

local retrievedMetatable = getmetatable(myTable)
print(retrievedMetatable == myMetatable) — 出力: true
``setmetatableを使って、既にメタテーブルが設定されているテーブルに別のメタテーブルを設定しようとすると、そのテーブルのメタテーブルに__metatableというフィールドが設定されていない限り、エラーになります。__metatableが設定されている場合、setmetatableはエラーになり、getmetatableは__metatableの値を返します（通常、__metatable` にはメタテーブル自身ではなく、メタテーブルが変更できないことを示すブーリアン値などが設定されます）。

主要なメタメソッド

メタテーブルに定義できる主要なメタメソッドをいくつか紹介します。

__index:
テーブル内の存在しないキーにアクセスしようとしたときに呼び出されます。このメタメソッドの値が関数であれば、その関数が (table, key) を引数として呼び出され、その戻り値がアクセス結果となります。値がテーブルであれば、そのテーブルに対して同じキーでアクセスが試みられます（連鎖的な検索）。これは継承やデフォルト値の設定によく使われます。

“`lua
local defaults = { unit = “kg” }
local item = { name = “apple”, weight = 0.2 }

local item_mt = {
__index = defaults — 存在しないキーは defaults テーブルから探す
}

setmetatable(item, item_mt)

print(item.name) — 出力: apple (item自身に存在する)
print(item.weight) — 出力: 0.2 (item自身に存在する)
print(item.unit) — 出力: kg (item_mt.__index が defaults を探しに行く)
print(item.price) — 出力: nil (defaultsにも存在しない)
`__index` の値が関数である例：lua
local calculate_on_demand_mt = {
__index = function(t, key)
print(“Accessing non-existent key:”, key)
if key == “area” then
return t.width * t.height
else
return nil — デフォルトの挙動
end
end
}
local rect = { width = 10, height = 5 }
setmetatable(rect, calculate_on_demand_mt)
print(rect.area) — 出力: Accessing non-existent key: area, 50
“`
__newindex:
テーブル内の存在しないキーに値を代入しようとしたときに呼び出されます。このメタメソッドの値が関数であれば、その関数が (table, key, value) を引数として呼び出され、代入処理はデフォルトでは行われません。値がテーブルであれば、そのテーブルに対してキーと値の代入が行われます。これは、新しいプロパティの追加を制御したり、ログを記録したりするのに使われます。

“`lua
local immutable_mt = {
__newindex = function(t, key, value)
error(“Attempt to add or change key ‘” .. tostring(key) .. “‘ to immutable table”, 2)
end
}
local config = { readonly_setting = 100 }
setmetatable(config, immutable_mt)

— config.readonly_setting = 200 — エラー発生: Attempt to add or change key ‘readonly_setting’ …
— config.new_setting = “abc” — エラー発生: Attempt to add or change key ‘new_setting’ …

— 既存のキーへの代入も __newindex が呼ばれることに注意
— 厳密なイミュータブルを実現するには __index を組み合わせるなどの工夫が必要な場合があります
``__newindexは、キーがテーブル内に既に存在するかどうかに関わらず、代入操作が行われた場合に呼び出される可能性があります。正確には、「テーブルの生の値（メタテーブルや__newindexを介さない直接的な値）が変更されようとしたとき」に呼び出されます。新しいキーへの代入や、値がnilだった既存のキーへの代入などで呼ばれます。既存のキーに新しい（非nil`）値を代入する場合、通常は呼ばれませんが、正確な挙動はLuaのバージョンや実装に依存する可能性があります。最も確実なのは「キーが存在しないか、またはその値がnilである場所への代入」で呼ばれると理解することです。
__call:
テーブル自体を関数のように呼び出そうとしたときに呼び出されます。このメタメソッドの値は関数である必要があり、table(arg1, arg2, ...) の呼び出しは getmetatable(table).__call(table, arg1, arg2, ...) の呼び出しに変換されます。

“`lua
local callable_table = { value = 10 }
local callable_mt = {
__call = function(t, multiplier)
return t.value * (multiplier or 1)
end
}
setmetatable(callable_table, callable_mt)

print(callable_table(5)) — 出力: 50 (callable_table.value * 5)
print(callable_table()) — 出力: 10 (multiplierのデフォルトは1)
“`
演算子に関するメタメソッド:
__add, __sub, __mul, __div, __mod, __pow, __unm (単項マイナス) – 算術演算子
__concat – 連結演算子 ..
__eq, __lt, __le – 関係演算子 ==, <, <=
__len – 長さ演算子 #
__tostring – tostring() 関数が呼ばれたとき

“`lua
local vector1 = { x = 1, y = 2 }
local vector2 = { x = 3, y = 4 }

local vector_mt = {
__add = function(a, b) — ベクトル加算を定義
return { x = a.x + b.x, y = a.y + b.y }
end,
__tostring = function(t) — print()などで文字列化されるときの表示を定義
return string.format(“Vector(%f, %f)”, t.x, t.y)
end
}

setmetatable(vector1, vector_mt)
setmetatable(vector2, vector_mt)

local vector_sum = vector1 + vector2 — __add メタメソッドが呼ばれる
print(vector_sum) — 出力: Vector(4.000000, 6.000000) (__tostring メタメソッドが呼ばれる)
“`
演算子のオーバーロードは、カスタムデータ型をLuaで表現する際に非常に強力です。

メタテーブルは高度な機能であり、その動作には注意が必要です。しかし、これらを理解することで、Luaの柔軟性を最大限に活用し、独自のデータ構造やオブジェクトシステムを構築することが可能になります。

テーブルの効率とベストプラクティス

Luaテーブルは内部的に、整数キー用の配列部分と、その他のキー用のハッシュ部分（またはハッシュマップ）という二つの構造を組み合わせて実装されています。これは、テーブルの利用パターンに応じて効率を最適化するためです。

配列部とハッシュ部の仕組み (簡潔に)

配列部分: 連続した正の整数キー (1, 2, 3, ...) を持つ要素は、内部的に配列として効率的に格納される傾向があります。インデックスによるアクセスが高速です。
ハッシュ部分: それ以外のキー（文字列キー、負の数、テーブル、疎な整数キーなど）を持つ要素は、ハッシュテーブルとして格納されます。キーのハッシュ値を計算して要素の場所を特定するため、配列アクセスほど高速ではありませんが、キーの種類に柔軟に対応できます。

Luaは、テーブルが作成されたり要素が追加・削除されたりする際に、内部的な構造を自動的に調整しようとします。例えば、多くの連続した整数キーが追加されると、ハッシュ部分から配列部分に移行する最適化が行われることがあります。

効率的なテーブルの利用

配列として使う場合: 1から始まる連続した整数キーを使用するように設計すると、#演算子やtableライブラリ関数が効率的に機能しやすくなります。特に、要素の追加や削除を頻繁に行う場合は、table.insertやtable.removeを使うことで効率的な要素の移動が内部的に行われます。
ハッシュマップとして使う場合: 主に文字列キーを使うことが多いでしょう。キーの文字列が短いほどハッシュ計算が速くなる可能性がありますが、通常は大きな差はありません。キーの種類によるパフォーマンスの違いはありますが、一般的なアプリケーションでは顕著なボトルネックになることは少ないでしょう。
混合テーブル: 配列とハッシュマップの両方の性質を持つテーブルは、両方の内部構造を使用します。特に問題なく機能しますが、特定の操作（例: ipairs vs pairs, # 演算子）で挙動が異なる場合があることを理解しておく必要があります。
テーブルの初期サイズ: テーブルコンストラクタ {...} を使用すると、初期要素に基づいてLuaが適切な内部サイズを推測しようとします。多数の要素を持つテーブルを空 {} で作成し、後から一つずつ追加していくよりも、可能な場合はコンストラクタで初期値を指定する方が効率的な場合があります。しかし、通常の使用ではこの違いは微々たるものです。極端なパフォーマンスチューニングが必要な場合に検討するレベルです。

メモリ管理とガベージコレクション

Luaは自動的なメモリ管理（ガベージコレクション、GC）を行います。テーブルもGCの対象です。テーブルへの参照がなくなったとき、そのテーブルはGCによってメモリから解放される候補となります。

テーブルの要素を削除するために値をnilに設定することは、そのキーと値のペアがテーブルから削除されたことを意味します。これにより、その値（もし他の場所から参照されていなければ）やキー（もしそれがテーブルやuserdataのようなGC対象の値であり、他の場所から参照されていなければ）がGCによって解放される可能性があります。

“`lua
local bigTable = { data = string.rep(“x”, 1000000) } — 大きな文字列を持つテーブル
print(“Memory usage before:”, collectgarbage(“count”))

bigTable.data = nil — 大きな文字列への参照がテーブルからなくなる
— LuaのGCはインクリメンタルなので、すぐにメモリが解放されるとは限らない
collectgarbage(“collect”) — 明示的にGCを実行 (通常は不要)
print(“Memory usage after:”, collectgarbage(“count”))
`` （注意：collectgarbage(“count”)` はキロバイト単位のメモリ使用量を返しますが、これはLua内部のGCが管理するメモリに限られ、システム全体のメモリ使用量を示すものではありません。また、GCの実行タイミングや効率はLuaの実装によって異なります。）

不要になったテーブルやその要素は、明示的にnilを代入することで、GCによるメモリ解放の対象となりやすくなります。特に、長期間生存するテーブル内で一時的な大きなデータを持つ要素は、不要になったらnilを代入して明示的に解放を促すのが良いプラクティスです。

テーブル設計のヒント

目的に合わせて構造を選ぶ: 配列として使うなら1ベースの整数キー、プロパティ集なら文字列キー、マップなら任意の型のキー、と目的に応じて使い分けることでコードの意図が明確になります。
密な配列を優先: 可能であれば、配列は1から始まる密な構造を保つようにすると、#演算子やtableライブラリの恩恵を最大限に受けられます。配列の途中に意図的にnilを置いて「穴」を作ることは、#やipairsの挙動を不安定にする可能性があるため、避けるのが無難です。
一時的なデータをクリア: 長期間使用するテーブル内に、ある処理のためだけに一時的に大きなデータ構造（別のテーブルなど）を保持する場合、その処理が終わったら明示的にnilを代入して参照を解除することを検討してください。
メタテーブルは慎重に: メタテーブルは強力ですが、乱用するとコードの可読性やデバッグの難易度を高める可能性があります。必要な場合にのみ使用し、その効果を十分に理解して使用してください。

まとめ

Luaのテーブルは、そのシンプルさの中に驚くべき柔軟性とパワーを秘めています。配列、ハッシュマップ、構造体、オブジェクトといった、他の言語では別々の型として提供される多くのデータ構造の役割を、ただ一つのテーブル型で担います。

この記事では、Luaテーブルの作成から始まり、要素へのアクセス、追加、変更、削除といった基本的な操作、配列としての利用（#演算子やtableライブラリ）、ハッシュマップとしての利用（任意の型のキー）、そして最も重要なイテレーションの方法（pairsとipairs）を詳しく解説しました。

また、テーブルが参照型であることと、その内容をコピーする方法（浅いコピーと深いコピー）についても触れました。さらに、テーブルを第一級関数と組み合わせることで実現するオブジェクト指向の基礎（メソッド構文 :)、そしてテーブルの挙動をカスタマイズできる高度な機能であるメタテーブルについても紹介しました。

Luaプログラミングにおいて、テーブルの理解は不可欠です。この記事で学んだ知識を活用することで、より効率的で、Luaの哲学に則ったコードを書くことができるようになるでしょう。Luaのフレームワークやライブラリの多くも、テーブルを巧みに活用して構築されています。テーブルを深く理解することは、それらを効果的に使用するための鍵ともなります。

Luaテーブルの旅はここで終わりではありません。実際にコードを書き、様々なケースでテーブルを使ってみることで、その挙動や可能性に対する理解はさらに深まるでしょう。

このガイドが、あなたのLuaプログラミング学習の一助となれば幸いです。