Question about metamethod __index

[mc3334]

I understand metamethods fairly well. I can use them if I need to. There is one thing I have always seen and have never understood the purpose of. Certain module scripts I have come across have looked like this:

local moudle = {}
module.__index = module

return module

I understand everything about this, except line 2. Why would you even bother including that line of code? Doesn’t it just make the table search itself, which it is already doing by default? Any help is appreciated, thanks.

[xZylter]

Fires when table[index] is indexed, if table[index] is nil. Can also be set to a table, in which case that table will be indexed.
Metatables | Roblox Creator Documentation

Being new to OOP and metamethods, I’m only making assumptions here. But when using OOP you have tables which will have their metatable set to the module in this case. Now because of how OOP works you are telling this new table to get methods it doesn’t have (which means this table indexed something which is nil) so it goes to it’s metatable for the index. And because this index returned nil it then prompts .__index to fire and use the table provided to index for the function.

So yes, it’s making the table search itself, but it’s due to a certain condition that was met which is common in OOP.

[mc3334]

From a logistics perspective, this concept still makes no sense to me. Your making the table look through itself, which it is already doing anyways. Does __index do something else under the hood of roblox’s engine that I am not aware of?

[sudylu]

this is used to do OOP in lua. More precisely it is a small optimization.

@luya_yobanka

this is the least you can do to make OOP work

local A = {}
local MT = {}
MT.__index = A

function A.new ()
	local self = {}
	setmetatable(self, MT)
	return self
end

If you have understood why, then doing A.__index = A is just a small optimization as it says in the documentation .

Let’s say you create an object

local a = A.new()

then you expect to do this:

a.size = ...
local x = a.position

but you don’t expect to do this:

a.__index = ... 
local x = a.__newIndex

because these indexes are reserved for the functioning of the metatables. That means that these indexes will never be used in your object, nor in your class.

Since the reserved indexes will never be used in class A , and MT will never use other indexes than the reserved ones, then A could also act as MT , A.__index = A . Which is an optimization since you don’t need to create an extra table.

[dthecoolest]

@mc3334

table search itself

Actually not, it makes the table with the metatable set search the metatable table instead of searching itself.

This is usually for oop stuff as @xZylter mentions. Usually you have a table of properties and one single shared metatable containing all the functions that does stuff with those properties.

Here is it’s equivalent code piece example for the function inputted into the index function.

New to Metatables

Using @HugeCoolboy2007 .x example This: local myTable = {x=10} myTable.__index = myTable local meta = setmetatable({}, myTable) print(meta.x) --> prints 10 because the main table '{}' doesn't have that index but the metatable has that index Is equal to this: local myTable = {x=10} myTable.__index = function(someTable,index) return myTable[index] end local meta = setmetatable({}, myTable) print(meta.x) --> prints 10 because the main table '{}' doesn't have that index but the metatable ha…