I know this probably has a very simple answer, (no previous posts helped)
But when you connect an event (Clicked ) to a function like for example:
local TextButton = script.Parent
local player = game:GetService("Players").LocalPlayer
TextButton.MouseButton1Click:Connect(
function(player)
print(player.Name)
end
)
when do you use Disconnect then? as it says without disconnecting the function, it will keep listening for .Clicked
Not to mention, the code above gives the output âattempt to index nil with playerâ
Or does the function disconnect it self when not called ?
You need to define the event before youâre able to disconnect it. Like this:
local Mouse1ClickEvent
Mouse1ClickEvent = TextButton.MouseButton1Click:Connect(function()
print("Clicked!")
Mouse1ClickEvent:Disconnect()
end)
To answer why the event was erroring when calling the print, MouseButton1Click does not return any arguments. Thatâs only for ClickDetectors. GuiButton objects can only be clicked by clients, so thereâs no point in having a player argument.
But my question is ;
Is it really important to do this? Since it is an anonymous function wont it disconnect it self after end?
And if so , will I have to change all my code to disconnect the function?
The client would still be listening for that specific event, which just causes it to use more resources than necessary (as well as potential memory leaks because it isnât being discarded). For the sake using less memory, itâs best that you do utilize the Disconnect function.
You canât disconnect a function, but rather the you can disconnect the event. When you disconnect the event, it will stop listening and calling the anonymous function you stated.
Connecting and disconnecting are one-time things. You shouldnât disconnect a function from an event after it gets fired and then connect it again, that doesnât make sense. You connect a function to an event as soon as you need to start listening for an action (here: user input) and disconnect once youâre certain itâs gonna be a considerable amount of time until the connection is needed again, but you arenât destroying the object that supplies the event.
If you have a TextButton as a (semi-)permanent part of UI and never destroy it, it is usually not necessary or advised to ever disconnect the function from the event, unless you specifically want to (as provided by above example: only listening to an event call once).
So what you basically mean by that is that I shouldnât disconnect the event after being called , because the event that is connected to the function will automatically be stopped being called for after end) ?
And so in other places where events are being fired upon an event (clicked) that connects the Clicked event to the function which fires the other event, there I should disconnect them, because new connections for example would need to be made and disconnected every time right?
Yes. Disconnecting from an event means you will stop listening to the event, it doesnât mean that your function will stop running. A function will have nothing to do after reaching the end definition and therefore stop. The ârunning functionâ isnât kept in memory, only the connection (when event, do function) which you can usually keep (because you will usually need to use it more than a few times).
No. The event does not âstopâ automatically. Once you connect a Mousebutton1Click event, it kinda âlistensâ until it receives a signal that, yes the button has been clicked. So, Roblox uses resources to âlistenâ to event. But disconnecting it stops Roblox from âlisteningâ thus doesnât use resources.
However, disconnecting it doesnât mean that the function will not run again. It only means that Roblox will stop using resources until the event is connected again thus preventing memory leaks.
For a simplification of what it means to disconnect an event from a function, you cut the âwireâ(connection) leading from the input(event) to the output(function).
Usage areas of Connection:Disconnect() are such as acting like a debounce.
But that is exactly what Disconnect does and is for? Once you call Disconnect on an event connection, the corresponding function will not be called again the next (and following) times the event fires.
And Disconnecting everywhere an event that is called for
(given the button is going to be clicked several times)
will result in the button not producing any outcome , is that correct then ?
You can find that function from the object of RBXScriptConnection.
@XxELECTROFUSIONxX
The input will still work, but the connection is severed between, thus resulting no output. Letâs say you have multiple connections on one, and disconnect one. Only the disconnected will stop sending signals to its designated output and others will function without any additional issues.
Well canât we use Coroutines to suspend a function from being called?
Like I came up with this script which works, but donât know whether it can cause memory/data leakage or something
local button = script.Parent
button.MouseButton1Click:Connect(coroutine.wrap(function()
print("clicked")
end))
but the coroutine dies immediately , thus working only once
what does it depend on then if not at nothing at all, I mean what I get from what @emojipasta and @Operatik said, disconnect is mainly used in places where you can âseverâ the connection , that is where people wonât be using it or the event wont be called that often.
So it is not necessary at places, such as in a Gui where players would click it constantly , i.e to buy things from an in-game shop.
But what happens if you use that in a lot of places (9-20) gui buttons , will it keep listening for the event for every single button , hence causing memory leakage ?
Listening to a lot of events at once doesnât instantly cause any issues. Youâre safe to make hundreds of permanent event connections for your game.
It usually gets problematic when you dynamically create a large, indefinite amount of Instances and connect to their events dynamically as well. Picture this situation: You retrieve thousands of items from a text-format catalog (like a table, JSON file etc.) and create a new set of event connections for each one of the items (âsee more detailsâ, âpurchaseâ, etc.). The user may refresh the catalog to re-create those thousands of buttons. Hereâs where it (in theory) gets problematic. You would need to disconnect each connection again for a refresh.
However, this isnât actually a problem, because Roblox automatically disconnects all event connections when Destroying instances. Itâs just an example.
A better example: Every time a player chooses to spawn into the world from a main menu, you connect a few looping events (such as movement, camera translation, user input). In this case, you should disconnect all events after the player chooses to go back to the main menu. The events arenât automatically disconnected and since the player can thereotically respawn an infinite amount of times, you would create an infinite amount of connections, which causes the problems addressed before.
