how could I use a single variable for multiple events without interference?

All I'd like to know is how to shorten this into a single variable for each event.

debounce1 = false
debounce2 = false
debounce3 = false

part.Touched:Connect(function()
	debounce1 = true
end)
part2.Touched:Connect(function()
	debounce2 = true
end)
part3.Touched:Connect(function()
	debounce3 = true
end)

This is what I am looking for:

debounce1 = false
part.Touched:Connect(function()
	debounce1 = true
end)
part2.Touched:Connect(function()
	debounce1 = true
end)
part3.Touched:Connect(function()
	debounce1 = true
end)

Although I am trying to figure out how to make it so that debounce1 only changes for that specific event and doesn't interfere with each other.

I've done a bit, tried to make a table to store each one then another table to load it specifically for the event, the problem with that was that the default values couldn't be changed unless it was changed in the event which in that case a loop would make it harder to code.

I tried making a function that returns values but then again, I couldn't change the original values, I tried making it specifically work

I'd like some ideas, thanks for the help and time.

The reason I asked this is because it would make my code neater and easier to read and also, it would reduce the memory consumption.

NOTE: Not 100% Sure If This Works & Is Efficient Of What You're Looking For

I re-thought of the table thought you had. If you use 3 tables one with false and one with true and one with nil, because why not, you can use the same debounce variable, but for different events.

Script Hierarchy

Module Script

local globalDebounce = {}

globalDebounce.TrueDebounce = true

globalDebounce.FalseDebounce = false

globalDebounce.NilDebounce = nil

return globalDebounce

ServerScript

local debounceModule = require(script.ModuleScript)
local trueDebounce = debounceModule.TrueDebounce
local falseDebounce = debounceModule.FalseDebounce
local nilDebounce = debounceModule.NilDebounce
local debounce

part.Touched:Connect(function()
	debounce = trueDebounce
	print(debounce)
end)

part2.Touched:Connect(function()
	debounce = falseDebounce
	print(debounce)
end)

part3.Touched:Connect(function()
	debounce = nilDebounce
	print(debounce)
end)

I'm trying my best, hope this is somewhat of what you're looking for or atleast giving you an idea of how to handle this situation.

~killerbrenden

I can think of two methods to go about this, one just syntactical difference and one with different logic. Either way, premature optimisation isn’t a good idea, you’re decreasing your productivity at the expense of negligible effects. Worry about optimisation that has major effects (concerning physics, etc.), not variable assignment.

Single line, multiple assignments

Just assign all variables one the same line, it makes it neater since like variables are assigned on the same line, which imposes a degree of separation:

local debounce1, debounce2, debounce3 = false, false,false

-- You can make this even shorter if you check for truthy values instead of just false:
local debounce1, debounce2, debounce3

part.Touched:Connect(function()
    debounce1 = true
end)
part2.Touched:Connect(function()
    debounce2 = true
end)
part3.Touched:Connect(function()
    debounce3 = true
end)

Tables and truthy checks

Since all keys in a table are given a value of nil by default, you don’t need to initialise any values and you can have one variable, but, you’ll have to use specific keys in specific events:

local debounce = {}

part.Touched:Connect(function()
    debounce[part1] = true -- You don’t need to map my instances but it’s more intuitive
end)
part2.Touched:Connect(function()
    debounce[part2] = true
end)
part3.Touched:Connect(function()
    debounce[part3]= true
end)