Variable changes when passing to module (string -> table)

[Alexplazz (SetAsync)]

-- Main Script
LogService:AddLog("Chatlogs", Message)

-- Module Script
function LogsModule.AddLog(LogName, Element)
	print(LogName, Element)
	if #LogsStore[LogName] == SystemSettings[4] then
		table.remove(LogsStore[LogName], 1)
	end
	print(LogName, LogsStore[LogName])
	table.insert(LogsStore[LogName], Element)
end

When I run AddLog from main script I get the following to print:

- table: 0xe8cd682c3a62f63c Chatlogs

The first argument is evidently a string, why does it turn to a table?
Thanks.

(Update: using . instead of : seems to fix it, why??)

[Diamond_Boiiiiiiii]

@Alexplazz

(Update: using . instead of : seems to fix it, why??)

What do you mean by that? You mean table?

[Alexplazz (SetAsync)]

LogsModule . AddLog()
LogsModule : AddLog()
The part inbetween LogsModule and the function name.

[ifkpop]

There is a clear difference between using “.” and “:”.
I went into more detail here:

DataStore2 not loading backup save

Sorry in advance for the lengthy answer I’m looking through your DataStore2 script, I can’t find any method which returns self. From what I’ve seen so far, this is required. I might be wrong about that however. Usually the code is something along the following lines: local MyObject = {} MyObject.__index = Object-- Tell missing indexes to search through this object function MyObject.new() local self = {} -- Create self setmetatable(self, MyObject) -- Set references to Object with…

Hope this helps!

[C_Sharper (Sharpie)]

Calling a method of a table with : implicitly passes the table itself as the first argument, so it’ll replace the first formal parameter of the function. (If you defined the method/function using the dot operator)

Defining a function in a table with : handles it implicitly, so basically this is how it’ll look:

function myTab:something(self, ...) --//self is implicitly added as a formal parameter

end

[UnreaI_King (Unreal_King)]

Whenever you call a method using a colon ‘:’, as in “Part:Destroy()”, it passes the table / module itself as the first argument, so when you call LogsModule:AddLog() (with a colon), the first parameter will be LogsModule, and the second will be the message, when you call with a period rather than a colon it will not send the table/module so the first parameter will be the message.

I recommend reading posts on the usage of the colon. There’s plenty of good ones.

Difference between : and .?

Colon functions are what’s called syntatical sugar, they’re special pieces of code. They allow use of the self parameter without defining it, self is what table the function belongs to. Only functions can make use of this. If you were to call a colon function as a full stop function then you’d have to provide self yourself as the first argument. ie. local t = { Cheese = "nice" } function t:foo() print(self.Cheese) end t:foo() --nice t.foo(t) --nice

Confusion on when to use dots or colons

Periods/dots are used when accessing the children/index of that object, whether that be a property, an event, a function, another object within or whatever else. Colons are used exclusively for calling methods, which passes itself as a variable to that function. As such, following the code you gave us, you can do this: local player = game:GetService(“Players”).LocalPlayer -- or local player = game.GetService(game, “Players”).LocalPlayer Note how in the latter variable definition I passed ‘…

[SummerEquinox]

This is known as ‘syntactic sugar’, where a programming language takes liberty in making things easier to read and express.

There is no effective difference between these two things:

local a = {}

function a:foo()
	print(self)
end

function a.bar(self)
	print(self)
end

a:foo() -- self implicitly passes
a.bar(a) -- self manually passes

Also for the sake of learning, self isn’t a keyword regardless of how it is highlighted because it doesn’t actually reserve space… it’s just another variable that syntactic sugar has the ability to implicitly pass.