Local Variable Optimization

[Beoko]

I've been curious about this for a while now. Assuming scope is not an issue, would it be faster to do:

local Variable1, Variable2

local function Func()
   Variable1 = something...
   Variable2 = something else...
end

Or:

local function Func()
   local Variable1 = something...
   local Variable2 = something else...
end

Or, would the speed be equal? Also, would the first method be more memory efficient than the second method?

[Arrowmaster]

It depends entirely on where you are going to use the variables.

[Graveeater]

The following example would probably be more helpful:

for k,v in pairs(largeTable) do
    local var = someFunc(k,v)
    -- do something with var
end

compared to

local var
for k,v in pairs(largeTable) do
    var = someFunc(k,v)
    -- do something with var
end

I suppose the second example will be faster, but I am not sure. In a compiled language, these probably would not matter at all.

[Arrowmaster]

No you are wrong.

[Flickor]

There would be two reasons why you should use the local variable outside the function:
1. If that function is called VERY often (like from a onupdate script or a heavy event like CLEU or UNIT_AURA)
2. If you are going to use the same variable in multiple functions or somewhere else in your code.

[Beoko]

Originally Posted by Arrowmaster

No you are wrong.

Why is he wrong, though?

Originally Posted by Flickor

There would be two reasons why you should use the local variable outside the function:
1. If that function is called VERY often (like from a onupdate script or a heavy event like CLEU or UNIT_AURA)
2. If you are going to use the same variable in multiple functions or somewhere else in your code.

I'm aware of the purpose for declaring it outside or inside of the function. I'm not aware of the actual amount of time/memory I would save by doing one or the other. I'm assuming the time will be negligible, but would the memory be? Am I assuming incorrectly? Pie or cake?

[Tekkub]

Don't concern yourself with memory for locals, it doesn't involve gc. Just declare the variable within the scope you need it.

[Farmbuyer]

Originally Posted by Beoko

Why is he wrong, though?

For some reason Arrow gets a free pass on these forums to be a complete dick without ever getting called on it.

I'm assuming the time will be negligible, but would the memory be? Am I assuming incorrectly? Pie or cake?

The two examples in Graveater's post are not quite the same, primarily because the 'var' reference in the second example is not cleared. In the first example, once var goes out of scope at the end of the function call, whatever memory it was referencing will be available for garbage collection. Not so at the end of the second example. [edit: talking about whatever's returned from "someFunc", not the local variable itself]

You could adjust the second example to be

local var
for k,v in pairs(largeTable) do
    var = someFunc(k,v)
    -- do something with var
    var = nil
end

and then it would be functionally equivalent to the first... but then you haven't gained anything over the first, and lost some clarity in the process.

[Beoko]

Thanks for the replies. That's about all I needed to know.

[Xinhuan]

Originally Posted by Graveeater

The following example would probably be more helpful:

for k,v in pairs(largeTable) do
    local var = someFunc(k,v)
    -- do something with var
end

compared to

local var
for k,v in pairs(largeTable) do
    var = someFunc(k,v)
    -- do something with var
end

I suppose the second example will be faster, but I am not sure. In a compiled language, these probably would not matter at all.

All locals in a function are allocated memory in the stack. Scope is merely a matter of compiler issue, and doesn't apply in compiled code.

In your first example, the function containing your loop will allocate 8 bytes of memory for "var". That 8 bytes of memory exists until your function returns and the stack unwinds, but according to language rules, "var" is only accessible inside your for-loop's block of code.

In your second example, the same 8 bytes of memory also exists until your function returns and the stack unwinds, but according to language rules, "var" is accessible from the point it is declared until the end of the containing block of code.

In essence, there is no performance difference. [Note that I've not talked about upvalues (referring to local variables outside of the function you are in) such as file-scope variables].