What is self's value here

Help and Feedback Scripting Support
#1 
------------[ Module script ] ------------

local tweenService = game:GetService("TweenService")

local door = {}
door.__index = door

door.closed = false
door.closeTime = 2

function door:New(model)
     local newDoor = setmetatable({}, self) -- Here
     newDoor.__index = newDoor
     newDoor.Model = model

     return newDoor
end

function door:CreateTween(properties)
     local tween = tweenService:Create(
     self.Model.Door, -- Here
     TweenService.new(self.closeTime, --Here Enum.EasingStyle.Quad, Enum.EasingDirection.In), 
     properties
     )

     return tween
end

function door:ToggleState()
     self.closed = not self.closed -- Here

     local properties = {}
     properties[true] = {Position = self.Model.ReferencePoints.Closed}
     properties[false] = {Position = self.Model.ReferencePoints.Open} -- Here

local tween = self:CreateTween(properties[self.closed]) -- Here

tween:Play()
end

return door


------------[ Server script ] ------------

local module = require(game.ServerScriptService.ConfigModule)

local collectionService = game:GetService("CollectionService")
local tagged = collectionService:GetTagged("Door")

for _, door in pairs(tagged) do
     local newDoor = module:New(door)
     newDoor:ToggleState()
     newDoor:ToggleState()
end

Please tell me what value self contains in each case.

So you don’t have to give me an example of each case, just tell me what self means in each function, that is all I want to know.

E.g.
Function 1: Contains the door table
Function 2: Contains the newTable in the server script

(These aren’t the real values, I think)

#2
OP Fixed the post
  1. Looks like the script is missing the function keyword. In this case, self is nil.

self is the door table

#3

Ignore the script errors, I didn’t write this in studio. Please just tell me self’s value disregarding any errors.

#4

self is the class/table of the method, for example door:ToggleState() self is door(and in all of your references as well).

#5

For every function? I thought that self would be set to the value the function is called on.

E.g. Door:Something() self is Door or Idk:SomethingElse() self is Idk or is that wrong?

#6

Doing this:

function Table:Method()

end

is the same as:

function Table.Method(self)

end

The only difference is that you don’t manually define self in the parameters.

It should also be noted that if you do the first method, you would have to call the method as

Table:Method(...) --... are the parameters you want to pass

This also works for the second method.

Another way to call it would be:

Table.Method(Table, ...) -- does the same thing the previous example did
#7

Hold on, if self is Door for each function how would the second one work? self.Model is in a different table.

Also, if self didn’t exist would scripts work basically the exact same if you change them a little?

#8

Looking at the code, the author intends for the developer to call the door:New method first and use the functions on the returned value for that (This is common in OOP).

This is what I mean:

local doorData = door:New() 
doorData:CreateTween(...)

It depends on how you structure the code afterwards, a slight change to the code can technically allow you to use the code without self, but an incorrect modification can break the system. So, yes

#9

This is correct, I believe I provided the same response to the other thread you posted

#10

So I don’t think I am getting it…

When you call the function, self isn’t passed, so:

module:New()

In this example module isn’t passed.

But if you set the function, self is passed, so:

function module:New()
     ...
end

Here module is passed as self.

So basically what I am saying is self is passed when you set the function but not call it?

#11

In simpler terms, if you call a function with a colon (:), self is automatically passed, but if you call a function with a dot (.), self isn’t passed (and in that case, if you need self, you would need to pass it manually)

#12

So is my previous reply right then?

function Base:New()
     ...
end

self is Base

Base:New()

self isn’t passed

You can just heart this if this is right if you don’t want to post a reply.

#13

You’re partially correct, in your second example:

Base:New()

self is passed because calling a function with a colon passes Base with it.

If you called it with a dot:

Base.New()

self wouldn’t be passed here

You’re correct in your first example, self is Base

#14 
local Door = {} --class

Door.__index = Door --check class for key/field if object doesnt have it (essentially making the object inherit from the class)

function Door.new(name, size, material) --class constructor function
	local NewDoor = {} --door object
	setmetatable(NewDoor, Door) --sets object's metatable to the door class (essentially making it an object of the door class)
	NewDoor.Name = name --assign custom properties
	NewDoor.Size = size
	NewDoor.Material = material
	NewDoor.Open = false --default property
	return NewDoor
end

function Door:open()
	self.Open = true
end

function Door:close()
	self.Open = false
end

local door = Door.new("RandomDoor", 10, "Wood") --create door object
door:open() --call open instance method on the created door object
print(door.Open) --true
local door2 = Door.new("RandomDoor2", 10, "Wood") --create 2nd door object
print(door2.Open) --false

Here’s an example I just wrote using your door example, hopefully it should help clear things up a little.

We have a door class constructor function which can be called to create door objects, following this we have two methods “open” and “close” which can be called on door objects in order to open/close them respectively.

1 Like
#15

So to sum it up, whatever is before the : is passed as self (when you’re either calling or creating the function).

This example:

local base = {}

function base:New(model)
     self.Model = model

     return self.Model
end

function base:Edit()
     self.Model:Destroy()
end

return base

Is equivalent to:

local base = {}

function base.New(model)
     base.Model = model

     return base.Model
end

function base.Edit()
     base.Model:Destroy()
end

return base

And:

local mod = require(path)

mod:New()

Is equivalent to:

local mod = require(path)

mod.New(mod)

Heart if I’m correct.

#16 
local mod = require(path)
mod:New()

Is equivalent to:

local mod = require(path)
mod.New(mod)

This is a good example, yes.

Referring back to my example from earlier.

door:open() --call open instance method on the created door object
--is the same as
door.open(door)
2 Likes
#17

So I am reading:

function door:CreateTween(properties)
     local tween = tweenService:Create(
     self.Model.Door, -- Here
     TweenService.new(self.closeTime, --Here Enum.EasingStyle.Quad, Enum.EasingDirection.In), 
     properties
     )

     return tween
end

And it doesn’t make sense. If self is door how would self.Model.Door work if Model isn’t associated with the door table?

#18 
newDoor.Model = model

Did you miss this?

#19

That’s a different table though.

#20 
function door:New(model)
     local newDoor = setmetatable({}, self) -- Here
     newDoor.__index = newDoor
     newDoor.Model = model

     return newDoor
end

This is your door constructor function (or whoever made the script).

That returned door object “doorNew” can then have the door classes instance methods called on it, including “CreateTween”.