ルア。 ダミーのメタテーブルの簡単な紹介

この記事を書くために、私はLuaのメタテーブルとOOPに関する多数の質問に促されました。これはこの言語の学習者にとって最も困難で問題のあるセクションであるためです。しかし、Luaは初心者およびメタテーブルの助けを借りて、複雑なタスクに対する驚異的で非常にエレガントなソリューションを使用できることを考えると、開発用の資料を「後で」残すことは価値がありません。

この出版物では、Lua 5.1-5.3のバージョン用のすべての標準メタメソッドを例とともに説明します。 始めましょう。

メタテーブル

これは何ですか

実際、メタテーブルは通常のテーブルと違いはありませんが、コントロールテーブルとしてリストされている点が異なります。

概略的には、たとえば次のように想像できます。



メタテーブルは、アクションに対するメインテーブルの反応を説明します。たとえば、テーブルを関数として呼び出したり、任意の値でテーブルを分割したり、特別なキーのおかげで、テーブルからキーを抽出しようとします（特に明記しない限り、Lua 5.1）：

一般的なメタメソッド

• __index-元のテーブルが存在しない場合にキーを探す関数またはテーブル。
• __newindex-テーブルに* new *キーを追加する方法の機能は、既存のものに影響しません。
• __call-テーブルが関数として呼び出されるときに呼び出される関数。
• __tostring-たとえば、printまたはtostringを使用して、__ concatと組み合わせて、テーブルを文字列に変換しようとするときに呼び出される関数。
• __concat-テーブルを何かと連結しようとするときに呼び出される関数は、__ tostringと組み合わされます。
• __metatable-このテーブルからメタテーブルを取得しようとして返される値により、メタテーブルを非表示にできます。
• __mode-ガベージコレクション中にテーブル内のリンクの「強度」を制御する文字列。これを使用して、弱リンクテーブルまたはエフェメロンを作成できます。
• __gc-ユーザーデータ（5.1+）またはテーブル（5.2+）がガベージコレクターによって収集されるときに呼び出される関数（5.1で本当に必要な場合）-使用する方法があります。
• __len-＃（5.2+）演算子を使用してテーブルの長さを計算しようとするときに呼び出される関数。
• __pairs-関数、特定のテーブル（5.2+）のペア反復子の代替。
• __ipairs-関数、ipairs（5.2+）の代替;

数学的メタメソッドと比較（関数）

• __add-（+）追加;
• __sub-（-）減算;
• __mul-（*）乗算;
• __div-（/）部門;
• __pow-（^）べき乗;
• __mod-（％）モジュロ除算;
• __idiv-（//）整数部を削除した除算（5.3+）;
• __eq-（==）等値比較;
• __lt-（<）比較「より小さい」、反対方向で自動的に実行され、引数を逆にします。
• __le-（<=）比較「以下」;

ビット操作（機能、5.3以降のみ）

• __band-（＆）「そして」;
• __bor-（|） "OR";
• __bxor-（〜）排他的な「OR」（a〜b）;
• __bnot-（〜） "NO"（〜a）;
• __bshl-（<<）ビット左シフト。
• __bshr-（>>）ビットを右にシフトします。

例

索引

最も一般的なメタメソッドの1つであり、最も多くの質問を引き起こしています。
引数（self、key）を持つテーブルまたは関数になります。selfは検索するテーブルで、keyは値を取得するキーです。

このメタメソッドに基づいて、OOP、プロキシテーブル、テーブルのデフォルト値など、多数の機能が構築されます。

このテーブルの正確なキーを取得する必要がある場合は、有害になる可能性があります。そのような場合は、テーブルのデフォルトのアクセス関数である関数値= rawget（テーブル、キー）を使用します（キーで値を取得しようとすると、バイトコードで呼び出されます） 。

--[[1]] foo = {} foo.key = 'value' --[[2]] mt = {__index = foo} -- setmetatable       --[[3]] bar = setmetatable({}, mt) bar.key2 = 'value2' -- : --[[4]] print('bar.key2', bar.key2) --> 'value2' --[[5]] print('bar.key', bar.key) --> 'value' --[[6]] bar.key = 'foobar' foo.foo = 'snafu' print('bar.key', bar.key) --> 'foobar' print('bar.foo', bar.foo) --> 'snafu' print('bar.foobarsnafu', bar.foobarsnafu) --> nil --[[7]] foo = {key = 'FooBar'} --    bar = setmetatable({}, {__index = foo}) snafu = setmetatable({}, {__index = bar}) print('snafu.key', snafu.key) --> 'FooBar' --[[8]] foo = {} foo.__index = foo setmetatable(foo, foo) -- print('foo.key', foo.key) --> error: loop in gettable print('foo.__index', foo.__index) --> "table: 0x12345678" print('rawget(foo, "key")', rawget(foo, "key")) --> nil --[[9]] foo = {} foo.key = 'value' setmetatable(foo, {__index = function(self, key) return key end}) print('foo.key', foo.key) --> 'value' print('foo.value', foo.value) --> 'value' print('foo.snafu', foo.snafu) --> 'snafu' --[[10]] fibs = { 1, 1 } setmetatable(fibs, { __index = function(self, v) self[v] = self[v - 1] + self[v - 2] return self[v] end }) 

ここで何が起こっていますか：

1. foo-持っていないキーを探すテーブル。
2. mtは、キー__index = fooを持つテーブルです。 メタテーブルのようなものにアタッチすると、「キーがない場合は、fooでそれらを見つけてください。」と表示されます。
3.メタテーブルmtを空のテーブル（バーになる）にチェーンするプロセスを次に示します。
4.テーブルキーへの直接アクセスの例。 この場合、通常のようにバーテーブルからキーを取得します。
5. __indexのキーへのアクセスの例。 この場合、キー["key"]はbarテーブルにありません。fooテーブルの__indexメタテーブルで検索します。
6.明確化：バーテーブルにキーキーを追加すると、その中に見つかり、値を取得しようとすると、メタメソッドチェーンは呼び出されません。 しかし、["foo"]などのその他の存在しないキーはすべて、メタメソッドチェーンを呼び出し続けます。 キー["foobarsnafu"]は両方のテーブルに存在せず、その意味は通常nilです。
7.インデックスを使用すると、検索チェーンを作成できます。 この場合、キー検索アルゴリズムは次のとおりです。

1. snafuテーブルでキー["key"]を探しています。
2.見つかりません。 snafuメタテーブルには、バーテーブルを指す__indexキーがあります。 私たちはそこを見ています。
3.再び見つかりません。 しかし、fooテーブルを指す__indexキーを持つメタテーブルもあります。 探しています。
4.見つけた！ ここがキーであり、その意味は「FooBar」です！



8.この場合、それ自体に等しい__indexキーを持つテーブルを作成し、それ自体のメタテーブルとして設定します。 不足しているキーの値を取得しようとすると、内部で検索を試行し、__ indexメタテーブルをナビゲートしてさらに検索する再帰サイクルが発生します。 したがって、閉じた検索チェーンを実行しない方が良いです。 rawgetを使用する場合、メタメソッドは呼び出されず、このキーの正確な値が取得されます。
9. __indexキーとして、メタテーブルは2つの引数を持つ関数を持つことができます-self-テーブル自体、key-値を取得したいキー。 関数の戻り値が値になります。 これにより、テーブルに任意のインデックスを作成したり、プロキシを作成したりできます。
10. Wikipediaから例を取り上げます。 この場合、fibsテーブルの__indexは、メモ化を使用してフィボナッチ数の値を自動的に再計算します。 print（fibs [10]）は、10番目のフィボナッチ数を出力します。 欠落したテーブル値の再帰的な計算を介して機能します。 後続の値はテーブルにメモされます。 理解するには少し時間がかかります。fibs[v-1]が存在しない場合、fibs [v]と同じアクションセットが実行されます。

Newindex

あまり一般的なメタメソッドではありませんが、閉じたテーブルの作成、フィルタリングまたはプロキシ処理などに便利なこともあります。

常に引数（self、key、value）を持つ関数のみにすることができます。

有害な場合があるため、このメタメソッドを強制的に使用しない場合、rawset（self、key、value）関数が使用されます。これは、テーブルのデフォルト関数です。

 --[[1]] foo = {} mt = {} function mt.__newindex(self, key, value) foo[key] = value end bar = setmetatable({a = 10}, mt) bar.key = 'value' print('bar.key', bar.key) --> nil print('foo.key', foo.key) --> 'value' --[[2]] bar.a = 20 print('bar.a', bar.a) --> 20 --[[3]] mt = {} function mt.__newindex(self, key, value) if type(value) == 'number' then --       __newindex rawset(self, key, value) end end foo = setmetatable({}, mt) foo.key = 'value' foo.key2 = 100500 print('foo.key', foo.key) --> nil print('foo.key2', foo.key2) --> 100500 

1.これは、__ newindexメタメソッドを使用してプロキシテーブルを介してキーを追加する最も簡単な例です。 バーテーブルに追加するすべての新しい値キーは、関数に従ってfooに追加されます。 自己、この場合、バーテーブル。

2. __newindexは、存在しないキーにのみ適用されます。

3.数値のみをテーブルに追加できるフィルター関数の例。 同様に、「数字キーのみを追加する」をチェックするか、行テーブル番号などのために事前にいくつかのテーブルを作成し、対応するものに値を追加することができます（分類/バランスなど）。

電話する

このメタメソッドは、要素を削減したり、テーブルを使用して関数のデフォルトメソッドを呼び出したり、クラステーブルを関数として呼び出してオブジェクトを取得する際のOOPを少し快適にしたりするのに便利です。

 --[[1]] mt = {} function mt.__call(self, a, b, c, d) return a..b..c..d end foo = setmetatable({}, mt) foo.key = 'value' print(foo(10, 20, 30, '!')) --> 102030! print(foo.key) --> 'value' print(foo.bar) --> nil --[[2]] mt = {} --  -  ,      -- : a, b, c, d = ... function mt.__call(self, ...) return self.default(...) end foo = setmetatable({}, mt) function foo.mul2(a, b) return a * b end function foo.mul3(a, b, c) return a * b * c end foo.default = foo.mul2 print('foo.mul2(2, 3)', foo.mul2(2, 3)) --> 6 print('foo.default(2, 3)', foo.default(2, 3)) --> 6 print('foo.mul3(2, 3, 4)', foo.mul3(2, 3, 4)) --> 24 --    . print('foo(2, 3)', foo(2, 3)) --> 6 foo.default = foo.mul3 print('Default was changed') print('foo(2, 3, 4)', foo(2, 3, 4)) --> 24 

1.メタテーブルの使用例として、テーブルを関数として呼び出すことができます。 関数として呼び出されるテーブル自体は、selfとして渡されます。

2.この例では、テーブルに関数を入力します。メタテーブルは、関数として呼び出された場合、デフォルトキーの下で関数の結果を返すことを示します。

トストリングと連結

オブジェクトを文字列にキャストして連結するだけです。

 mt = {} function mt.__tostring(self) return '['..table.concat(self, ', ')..']' end foo = setmetatable({}, mt) foo[1] = 10 foo[2] = 20 foo[3] = 30 print('foo', foo) --> [10, 20, 30] -- print('foo..foo', foo..foo) -- !   ! function mt.__concat(a, b) return tostring(a)..tostring(b) end print('foo.."!"', foo.."!") --> [10, 20, 30]! print('"!"..foo', "!"..foo) --> ![10, 20, 30] print('foo..foo', foo..foo) --> [10, 20, 30][10, 20, 30] 

メタテーブル

メタテーブルを非表示にすると便利な場合があります。

 mt = {} mt.id = 12345 foo = setmetatable({}, mt) print(getmetatable(foo).id) --> 12345 mt.__metatable = 'No metatables here!' print(getmetatable(foo)) --> 'No metatables here!' mt.__metatable = false print(getmetatable(foo)) --> false 

モード

文字列。テーブル値間の関係のモードを示します。 文字 'k'が含まれている場合、キーは弱いと宣言され、文字 'v'が含まれている場合、値は弱いと宣言されます。 それらを一緒に使用できます。 例ではcollectgarbage関数を使用します-すべてのガベージを強制的に収集します。

Luaのテーブル-常に参照渡し。

 --[[1]] mt = {__mode = 'v'} foo = setmetatable({}, mt) --[[2]] bar = {foobar = 'fu'} foo.key = bar foo.key2 = {barfoo = 'uf'} foo[1] = 100500 --[[3]] print('foo.key.foobar', foo.key.foobar) --> 'fu' print('foo.key2.barfoo', foo.key2.barfoo) --> 'uf' print('foo[1]', foo[1]) --> 100500 collectgarbage() print('foo.key.foobar', foo.key.foobar) --> 'fu' print('foo[1]', foo[1]) --> 100500 -- print('foo.key2.barfoo', foo.key2.barfoo) --> , key2  ! --[[4]] bar = nil collectgarbage() -- print('foo.key.foobar', foo.key.foobar) --> , key  ! 

1.弱い値のテーブルの例：このテーブルを除き、値への参照がない場合、それらはガベージコレクション中に削除されます。

2.このコードセクションの実行後、テーブルへ
「{foobar = 'fu'}」には、2つの参照（グローバルスペースとテーブルfoo）、およびテーブルへの参照があります。
「{barfoo = 'uf'}」は、fooの中にあります。

3. fooテーブルにはすべての値がありますが、ガベージコレクションの後、key2テーブルが消えていることがわかります。 これは、それへの強力なリンクがなくなり、ガベージコレクターがそれを収集できる弱いリンクのみが存在するためです。 これはfoo [1]には適用されません。100500は参照型ではないためです（テーブルではなく、関数でも、ユーザーデータなどでも、数字ではありません）。

4.唯一の強力なリンクバーを削除すると、ガベージコレクション後にテーブル{foobar = 'fu'}も破棄されます。

テーブル参照キー（foo [{key = 'value'}] = true）に関してのみ、 'k'でも同様に機能します。

Gc

テーブルがガベージコレクターによって収集されると、__ gc関数が呼び出されます。 ファイナライザーとして使用できます。 テーブルとcdata / userdataを持つ関数。

 mt = {} function mt.__gc(self) print('Table '..tostring(self)..' has been destroyed!') end -- lua 5.2+ foo = {} setmetatable(foo, mt) -- Lua 5.1 if _VERSION == 'Lua 5.1' then --  __gc   5.1     cdata-. --   -  ,   . --     'foo',    local t = foo -- newproxy  cdata-,   Lua 5.1. local proxy = newproxy(true) --  __gc  cdata -  __gc-  foo getmetatable(proxy).__gc = function(self) mt.__gc(t) end foo[proxy] = true end print(foo) foo = nil collectgarbage() --> 'Table 0x12345678 has been destroyed!' 

レン

テーブルの長さを計算するためのアルゴリズムをオーバーライドする関数（Lua 5.2+）。

 mt = {} function mt.__len(self) local keys = 0 for k, v in pairs(self) do keys = keys + 1 end return keys end foo = setmetatable({}, mt) foo[1] = 10 foo[2] = 20 foo.key = 'value' print('#foo', #foo) --> 3 (2  Lua 5.1) 

ペアとペア

特定のテーブルの標準テーブルイテレータをオーバーライドする（Lua 5.2+）。

 mt = {} function mt.__pairs(self) local key, value = next(self) return function() key, value = next(self, key) --  - . while key and type(key) == 'number' do key, value = next(self, key) end return key, value end end function mt.__ipairs(self) local i = 0 -- ipairs   . return function() i = i - 1 return self[i] and i, self[i] end end foo = setmetatable({}, mt) foo[1] = 10 foo[2] = 20 foo[-1] = -10 foo[-2] = -20 foo.foo = 'foobar' foo.bar = 'barfoo' -- Lua 5.1    , -- 5.2+ -    for k, v in pairs(foo) do print('pairs test', k, v) end --> foo foobar --> bar barfoo -- Lua 5.1      , -- 5.2+ -     for i, v in ipairs(foo) do print('ipairs test', i, v) end --> -1 -10 --> -2 -20 

オペレーターの過負荷

すべての演算子のオーバーロードは1つのスキームに従って機能し、それぞれの詳細な例は必要ありません。

 ]] --[[1]] vector_mt = {} function vector_mt.__add(a, b) local v = {} vx = ax + bx vy = ay + by return setmetatable(v, vector_mt) end function vector_mt.__div(a, b) local v = {} vx = ax / bx vy = ay / by return setmetatable(v, vector_mt) end --   function vector_mt.__tostring(self) return '['..self.x..', '..self.y..']' end vec1 = setmetatable({}, vector_mt) vec1.x = 1 vec1.y = 2 vec2 = setmetatable({}, vector_mt) vec2.x = 3 vec2.y = 4 vec3 = vec1 + vec2 print('vec3', vec3) --> [4, 6] print('vec2 / vec1', vec2 / vec1) --> [3, 2] --[[2]] mt = {} function mt.__add(a, b) local insert_position = 1 if type(a) == 'table' and getmetatable(a) == mt then insert_position = #a + 1 else a, b = b, a end table.insert(a, insert_position, b) return a end --   function mt.__tostring(self) return '['..table.concat(self, ', ')..']' end foo = setmetatable({}, mt) --[[3]] foo = 3 + 4 + foo + 10 + 20 + 'a' + 'b' print('foo', foo) --> [7, 10, 20, a, b] foo = '12345' + foo print('foo', foo) --> [12345, 7, 10, 20, a, b] 

1.メタテーブルのおかげで、ベクトルのように振る舞うテーブルでの演算子のオーバーロードの例。 引数の順序に従う必要があり、各操作は新しいテーブル-「ベクター」を返します。

2.「+」演算子を使用して要素を追加できる表。
追加の順序は、要素を末尾に追加するか先頭に追加するかを決定します。

3. 3 + 4が最初に実行されるため、最初の要素は「7」です。
その他の場合、前の要素の結果に次が追加されます。
（（7 + foo-> foo）+ 10-> foo）...

これらすべてで何ができるでしょうか？

OOP

最初に頼むのは、OOPを作成する試みです。

いくつかの抽象的な「クラス」を実装する単純な関数を作成してみましょう。

 function Class() local class = {} --   . local mClass = {__index = class} -- ,   ""  . function class.instance() return setmetatable({}, mClass) end return class end --   . Rectangle = Class() function Rectangle.new(x, y, w, h) local self = Rectangle.instance() self.x = x or 0 self.y = y or 0 self.w = w or 10 self.h = h or 10 return self end function Rectangle.area(self) return self.w * self.h end --  rect = Rectangle.new(10, 20, 30, 40) print('rect.area(rect)', rect.area(rect)) --> 1200 print('rect:area()', rect:area()) --> 1200 

ここでは、すでにOOPに似ています。 継承やあらゆる種類のクールなものはありませんが、これは悪くありません。
rect.areaを呼び出すとき、オブジェクトテーブルにはエリアキーがないため、クラステーブルの__indexを介して検索し、それを見つけて、そこで最初の引数に置き換えます。

メタテーブルからの小さな余談：2回目の呼び出しの例は、この記事の最初のコロンの出現です。 コロンは、Lua言語の構文糖衣です。 テーブル内の関数をピリオドではなくコロンで呼び出す場合、テーブル自体がこの関数の最初の引数として置換されるため、そのコードは同等です。

詳細：

 foo = {x = 10, y = 20} function foo.bar(self, a, b) return (self.x + a) * (self.y + b) end print('foo.bar(foo, 1, 2)', foo.bar(foo, 1, 2)) --> 242 -- ,  self "" . function foo:bar(a, b) return (self.x + a) * (self.y + b) end print('foo:bar(1, 2)', foo:bar(1, 2)) --> 242 

このオプションを少し改善してみてください。

まず、オブジェクトを返す関数としてクラスを呼び出す機能を追加します。次に、クラス自体の演算子をオーバーロードする機能を追加します。第三に、継承です。

 function Class(parent) local class = {} local mClass = {} --      . --     . class.__index = class --       __index, --  ,   ,   . mClass.__index = parent --   Super  . class.Super = parent -- ,       function mClass:__call(...) local instance = setmetatable({}, class) --    "init" if type(class.init) == 'function' then --         init return instance, instance:init(...) end --     -  . return instance end return setmetatable(class, mClass) end --  . Shape = Class() function Shape:init(x, y) --   self     . self.x = x or 0 self.y = y or 0 return '!!!' end function Shape:posArea() return self.x * self.y end --    Shape      , --     . function Shape:__tostring() return '[' .. self.x .. ', ' .. self.y ..']' end local foo, value = Shape(10, 20) print('foo, value', foo, value) --> [10, 20] !!! --  Rectangle = Class(Shape) function Rectangle:init(x, y, w, h) --   , self -   , --     Rectangle,  . --     Super. self.Super.init(self, x, y) --      -  . self.w, self.h = self:getDefault(w, h) end function Rectangle:area() return self.w * self.h end function Rectangle:getDefault(w, h) return w or 10, h or 20 end function Rectangle:__tostring() return '['..self.x..', '..self.y..', '..self.w .. ', '..self.h..']' end rect = Rectangle(10, 20, 30, 40) print('rect', rect) --> [10, 20, 30, 40] print('rect:area()' , rect:area()) --> 30 * 40 = 1200 --    print('rect:posArea()', rect:posArea()) --> 10 * 20 = 200 

したがって、15行の便利なコードで、本当に必要なOOPの最大値をLuaに実装できます。

もちろん、改善すべき点とそれを重み付けする方法があり、同様の作業がmiddleclassまたはhump.Classライブラリで行われましたが、これも役立つ場合があります。

ちなみに、クラス関数に煩わされたくないが、1つまたは2つのクラスを記述するだけでよい場合は、ここからデザインを使用できます。

プロキシテーブル

最後に、アクティビティトラッキングを備えた本格的なプロキシの例を示します。

 function proxy() local real_table = {} local logger = {} local metatable = {} --         function metatable:__index(key) local value = rawget(real_table, key) table.insert(logger, "Get key "..tostring(key)..' is '.. tostring(value)) return value end --     ,    function metatable:__newindex(key, value) table.insert(logger, "Set key "..tostring(key)..' as '..tostring(value)) rawset(real_table, key, value) end return setmetatable({}, metatable), logger end prox, log = proxy() prox.a = 10 prox.a = 20 print('prox.a', prox.a) --> 20 print('log', '\n'..table.concat(log, '\n')) --> Set key a as 10 --> Set key a as 20 --> Get key a, is 20 

出力は、その使用を記録するテーブルです。 この場合、プロキシテーブルは常に空で、キーが存在しないため、毎回__newindexが呼び出されます。

一時オブジェクトテーブル

一時的に存在する一時オブジェクトが必要になる場合がありますが、十分なメモリがない場合は空き領域が増えます。 この例ではLuasecライブラリ（httpsリクエスト）が必要になりますが、 Luasocketを使用しても同じ成功が得られますが、httpsが必要です。

 page = {} page.https = require'ssl.https' page.cache = setmetatable({}, {__mode = 'v'}) --     page._meta = {} function page._meta:__tostring() return 'Page: ['..self.url.. ']: '.. self.status end setmetatable(page, page) function page:__call(url) return self.cache[url] or self:request(url) end function page:request(url) local page = setmetatable({}, self._meta) page.url = url page.data, page.status, page.error, page.hate = self.https.request(url) print(page.data, page.status, page.error, page.hate) self.cache[url] = page return page end -- , , . p = page('https://yandex.ru') print('p', p) --> Page: [https://yandex.ru]: 200 print('p.status', p.status) --> 200 --     , --     -   . print('page.cache[...]', page.cache['https://yandex.ru']) --> Page: [https://yandex.ru]: 200 --     ,      "p". collectgarbage() print('page.cache[...]', page.cache['https://yandex.ru']) --> Page: [https://yandex.ru]: 200 p = nil collectgarbage() --     -   ,    . print('page.cache[...]', page.cache['https://yandex.ru']) --> Nil 

今のところ

おもしろい例や面白い例があれば、この資料は多かれ少なかれマスターメタテーブルに十分だと思います-コメントに書いてください。

たくさんの質問をしたい人のために- カートにチャットルームへのリンクを残してください。