Localizing global functions?

[daylesan]

I see other addon devs do this and am wondering why. Here's an example from Omen

local GetNumRaidMembers, GetNumPartyMembers = GetNumRaidMembers, GetNumPartyMembers

Is this done to optimize performance?

[Haleth]

Yes, local function are used -slightly- faster than global functions. It's a very minimal difference though.

[Ketho]

I agree with Haleth, you get a minimal speed increase

Global variables would litter the global namespace and maybe even override another addon's variables ..

-- WowAce Globals can cause issues because they may overwrite other people's functions, as well as being general bad practice. By not using globals and instead using a namespace format, one can gain quite a bit anyway

As for the optimization by variable scoping: (bit offtopic)

Originally Posted by Mischback Keep scope as minimal as possible, just as Xinhuan said. Xinhuan aswell stated very clear, in which cases a larger scope is needed / can be useful. But the bottomline is: Small scope = good!

Edit:
Didn't see that the OP was talking about functions instead of variables ><

[Seerah]

Well, the name of a function *is* a variable.

local function foo() return end

is the same as

local foo = function() return end

and then you can even do stuff like this

local myvar = foo
myvar()

The optimizations you gain by using your own local scope of a global variable are so negligible that it's only really worth it for functions you call very often, as in an OnUpdate.

[hankthetank]

You save the time to lookup the global. It's a good tweak for performance critical parts of your code, that is OnUpdate or Combatlog handlers mostly. Some authors take this way too far though and local every global they use. I guess it's their justification for using buzzwords like lightweight.

[Duugu]

local tstarttime = GetTime()
for x = 1, 1000000 do
    UnitName("target")
end
print(GetTime()-tstarttime)

That one needs 0.162 seconds.

local UnitName = UnitName
local tstarttime = GetTime()
for x = 1, 1000000 do
     UnitName("target")
end
print(GetTime()-tstarttime)

That one needs 0.147 seconds.

A difference of 15 microseconds for 1 million (!) function calls.
I would say in terms of performance gains it's save to simply ignore the local function stuff.

[Xinhuan]

There is a second side effect to localizing global functions. And that is, if some other addon were to hook the function AFTER your addon has grabbed the local reference, when you call the local reference of the function, the hooked version doesn't get called.

[This does not apply to hooksecurefunc().]

Even if the gains are minuscule, its still a good programming practice to optimize when possible if it does not get in the way of code readability and maintenance.

[SDPhantom]

Originally Posted by Xinhuan There is a second side effect to localizing global functions. And that is, if some other addon were to hook the function AFTER your addon has grabbed the local reference, when you call the local reference of the function, the hooked version doesn't get called. [This does not apply to hooksecurefunc().]

From my tests, hooksecurefunc() actually does change the pointer for the function passed. It works exactly like a post-hook from the old days, only it's made specifically to bypass the taint system.