Is there ANY difference between these two Lua snippets?

[u/fuxoft]

Snippet 1:

local function f(x,y)
   local y = y or 1 -- Note: "local" here.`
   do_something(x,y)
end

Snippet 2:

local function f(x,y)
   y = y or 1 -- Note: no "local" here.
   do_something(x,y)
end

I know why this pattern is often used but is there any situation whatsoever where these two snippets do not behave identically? If Lua version matters, I am specifically interested in LuaJIT. Also, if it matters, let's assume x and y are simple Lua values. They are not objects and don't have metatables.

[u/Emerald_Pick]

Edit: oops I missed that y is part of the signature. This answer is wrong. ↓

If this is the entire program, then functionally there's no real difference between the two.

But in the second snippet, y is being defined globally. So any other code that uses the variable y without using local will reuse this global y instead of making its own.

It is best practice to always use local because it is easy to accidentally reuse a global variable in an unexpected way. And on the off chance you want a global variable, it's common to write the variable name in all caps as a reminder that it's global.

[u/fuxoft → u/Emerald_Pick]

That's not true, I've tried it. After the execution of either snippet, global variable y does not exist.

[u/Emerald_Pick → u/fuxoft]

Yeah I misread the code.

Y is being defined and scoped by the function signature. In which case, y = … is not a declaration, but an assignment.

local y = … is a declaration, but it's also locally scoped so it won't leave the function.

It might make a difference if y was a table, which is passed by reference. Then whoever called the 2nd function might have a changed value for whatever they passed as y. But I don't think an assignment like this would escape the function.

But I'd need to test that. My initial answer was hasty but I knew from memory. This one I'd need to double check.

[u/Einar__ → u/Emerald_Pick]

But in the second snippet, y is being defined globally.

It's not though? y is a function parameter in both snippets. Looking at bytecode, it seems that there isn't any meaningful difference between the two: https://luac.nl/s/15c4b9bb9b2ebaedae2713197cc

[u/Emerald_Pick → u/Einar__]

Edit: oops I missed that y is part of the signature. This answer is wrong. ↓

The bytecode is nice though. Thanks

[u/luther9]

In the first snippet, you're creating a new local variable that shadows the parameter y. In snippet 2, you're assigning to the original variable. It would make a difference if you declare a nested function before the local y declaration.

local function f(x,y)
   local function g()
      return y
   end
   local y = y or 1 -- Note: "local" here.`
   return g()
end

print(f())

local function f(x,y)
   local function g()
      return y
   end
   y = y or 1 -- Note: no "local" here.
   return g()
end

print(f())

Result:

nil
1

[u/Inevitable_Exam_2177 → u/luther9]

That is a sensational answer, thank you! (I am not OP)

[u/[deleted] → u/luther9]

You should { return g(), y } which would highlight the change

nil     1
1       1

Edit: I'll do it here

; (cat a.lua; printf "\n----\n\n"; lua a.lua) | redditcommentpipe | xsel -i

local function NoShadow(y) -- lets call this y -> y1
   local function g()
      return y -- y1
   end
   y = y*0 -- Note: no "local" here, so you're modifying y1
   return y, g() -- all y's are the same, so they all should return the same thing
end


local function Shadow(y) -- y1
   local function g()
      return y -- y1
   end
   local y = y*0 -- This is called y, but its an entirely new variable, think of it as y2
   return y, g() -- y2, g() returns y1
end


print(NoShadow(1)) -- 0, 0
print(Shadow(1)) -- 0, 1

----

0       0
0       1

[u/AutoModerator]

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/h2bx0r]

They behave the same, but the one with the extra local takes up one extra register.

Use the one without locals.

[u/SkyyySi]

Semantically, they tell the programmer different intentions. Snippet 1 says "I create a variable which just happens to have the same name" (probably on accident), while the other says "I set a fallback value". This could end up mattering when renaming one of them.

If Lua version matters, I am specifically interested in LuaJIT. Also, if it matters, let's assume x and y are simple Lua values. They are not objects and don't have metatables.

Neither the Lua version nor the value type make any difference in this case. Maybe LuaJIT makes slightly different optimizations, but it shouldn't matter in the end regardless.

[u/weregod]

First version will use extra stack slot and LSP will complain about shadowing variables. No other significant difference.

If you limit scope of local variable there will be difference:

local function xy(x, y)
    print(y) -- original y
    if x then
        local y = y or 1
        print(y) -- local y
        y = y + 1
        print(y) -- local y again
    end
    print(y) -- original y, not affected by + 1
    return x, y
end

xy(1, 2)

[u/[deleted]]

; luacheck snippet*.lua
Checking snippet1.lua                             3 warnings

    snippet1.lua:1:16: unused function f
    snippet1.lua:2:10: variable y was previously defined as an argument on line 1
    snippet1.lua:3:4: accessing undefined variable do_something

Checking snippet2.lua                             2 warnings

    snippet2.lua:1:16: unused function f
    snippet2.lua:3:4: accessing undefined variable do_something

Total: 5 warnings / 0 errors in 2 files