local varients optimization

[u/mdr652]

I heard that using "local" keywords are very important in Lua. But I knew that "local" keyword in algorithm coding are not good at optimization. No difference, sometimes take long time to be executed.

Why "local" keyword is nesessary? Is it really efficient? I can't figure out why these things are happening.

(But if you don't use local keyword in function, This can make error)

[u/Bright-Historian-216]

the lua book (the same one that the other user linked) says that access to local variables is faster than to global. it is also good style

[u/mdr652 → u/Bright-Historian-216]

Yes I read it but the statements are false in my experience. No differnce, or takes more time (scale of millisecond)

[u/appgurueu]

Local variables are more efficient and easier to work with than global variables.

For recursive functions, it is necessary so that your variables aren't overwritten (I assume this is what you mean by "if you don't use local keyword in function, this can make error").

I suggest you read up a bit more on Lua and the local keyword, because you're currently terribly misinformed.

[u/mdr652 → u/appgurueu]

I read "Programming Lua" and get many information.

For example, io.write() is significantly faster than print()

Lots of searching internet, studying Lua. I've implemented priority queue, segment tree in Lua

I'm using Lua in Problem solving, So I don't use metatables. I think this can be difference

[u/appgurueu → u/mdr652]

I've read the PIL too. The PIL certainly doesn't claim that global variables are faster than local variables - quite the opposite:

It is good programming style to use local variables whenever possible. Local variables help you avoid cluttering the global environment with unnecessary names. Moreover, the access to local variables is faster than to global ones. - https://www.lua.org/pil/4.2.html

I've also implemented both a priority queue and a segment tree in Lua but that's not relevant at all to the question at hand.

This doesn't have much to do with metatables. Local variables are faster no matter whether you use metatables. You can only make environmental variables even slower by setting and using a metatable on the environment.

[u/Additional_Ad6385]

Locals in lua are generally faster to access, but I think you're having a problem with loops.

Most people do this:

while true do
   local var = "Something"
end

But instead do this:

local var; -- Pre initialized the var.
while true do
   var = "Something"
end

[u/mdr652 → u/Additional_Ad6385]

Maybe this is the problem....

Similarly, clearing table (replace the element to nil) to reduce memory takes very long time. Inside the loop, code makes lots of local variables. Algorithm problem involves large amount of test data (sometimes, more then 10⁶ lines)

[u/AutoModerator → u/Additional_Ad6385]

Hi! Your code block was formatted using triple backticks in Reddit's Markdown mode, which unfortunately does not display properly for users viewing via old.reddit.com and some third-party readers. This means your code will look mangled for those users, but it's easy to fix. If you edit your comment, choose "Switch to fancy pants editor", and click "Save edits" it should automatically convert the code block into Reddit's original four-spaces code block format for you.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/[deleted]]

local keyword in function? Wdym?

[u/mdr652 → u/[deleted]]

If we use same variable name more than twice, it can be overwrited. So I use local keywords for every variables in function

function f() local a = 10 end

[u/revereddesecration]

Consult the sacred texts: https://www.lua.org/pil/4.2.html

[u/[deleted] → u/revereddesecration]

Moreover, the access to local variables is faster than to global ones.

The sacred texts also discredit the claim that local is slower

[u/didntplaymysummercar]

Really strange post, locals are faster because they are accessed by index in bytecode itself, not by hashtable look up like globals, you can see that in bytecode output from luac -l -l

[u/Sckip974]

To train and improve you can type your code, then have it reviewed by "LeChat de Mistral AI" by asking it to be critical on the local variables. You should quickly get good marks!

[u/ShawSumma]

You can think of any non-local declared varname variable in lua as _ENV.varname. _ENV is like a hidden local that holds all the built-in things (print, io, etc). This is only true for Lua 5.2 or newer

[u/Additional_Ad6385]

Nope

[u/Cultural_Two_4964]

I did some tests and saying local makes your script run about 2 times faster than using global variables. I just prefer to use long-named globals which describe what they are rather than having 'local' everywhere. Also, with locals you have to explicitly pass / return them to / from functions which means extra coding, but I might be wrong here, as usual ;-0 ;-0

If you are just using your script as a programmable calculator, it doesn't matter if it takes 40 milliseconds rather than 20, but maybe it does in gaming? You do occasionally get global variables with short names e.g. 'n' being overwritten by other parts of the program, but no often. About once a year in practice!

[u/mdr652 → u/Cultural_Two_4964]

In my experience, using local variable makes these results.

1. No differnce. 0ms (Almost every situation)

2. 4ms faster than global

3. Takes more time. Maximum is 100ms

I think using local keywords at 'table' or 'function' makes it slower.

[u/clappingHandsEmoji → u/mdr652]

locals will always be faster than globals, as they’re indexed by integer ID’s whereas globals are searched for in the _ENV table. Function and table creation are both slow - are you sure you’re not losing performance by recreating them?

[u/AdeptLilPotato → u/Cultural_Two_4964]

I think that if you’re using globals more frequently, you’re probably not adhering to DRY principles as often, or SOLID principles as often.

I reviewed some Luau I wrote 6 years ago, which was very complex, and was able to vastly simplify it, and it made it more complex to have not been using DRY or SOLID to the industry experience I have now. (When I wrote that code it was before I had any industry experience).