subtle differences between javascript and Lua

Question

i simply love javascript ... it's so elegant (imagine the quiet sound of lovestruck fanboy sighing in the background).

so, recently i have played with Lua via the löve2d framework (nice!) - and i think Lua is also great. they way i see it, those two languages are very similar.

there are obvious differences, like

• syntax
• problem domain
• libraries
• types (a bit)

but which are the more subtle ones? is there anything a javascript coder would take for granted that works in Lua just slightly different? are there any pitfalls that may not be obvious to the experienced coder of one language trying the other one?

for example: in Lua, arrays and hashes are not separate (there are only tables) - in javascript, they are numerical Arrays and hashed Objects. well, this is one of the more obvious differences.

but are there differences in variable scope, immutability or something like this?

Answer 1

To be honest it would be easier to list the things which are common to Javascript and Lua than to list the differences. They are both dynamically-typed scripting languages, but that's about as far as you can go really. They have totally different syntax, different original design goals, different modes of operation (Lua is always compiled to bytecode and run on the Lua VM, Javascript varies), the list goes on and on.

Answer 2

Off the top of my head

Lua ...

1. supports coroutines
2. has no restriction to just string/number as key for a table. Everything works.
3. the error handling is somewhat clumsy. Either you don't handle anything or use the pcall method
4. I think I read something about differences in the lexical scope and that Lua has the better one.
5. If I recall correctly regular expression support in lua is limited

Answer 3

Some more differences:

• Lua has native support for coroutines.
• Lua doesn't convert between types for any comparison operators. In JS, only '===' and '!==' don't type juggle.
• Lua has an exponentiation operator (^); JS doesn't. JS has many more operators, including the ternary conditional operator (?:), increment/decrement, bitwise operators, type operators (typeof and instanceof), additional assignment operators and additional comparison operators.
• In JS, the equals and not equals operators are of lower precedence than less than et al. In Lua, all comparison operators are the same precedence.
• Lua supports tail calls.
• Lua supports assignment to a list of variables.
• In Lua, you can overload operators.
• In Lua, you can manipulate environments with getfenv & setfenv.
• In JS, all functions are variadic. In Lua, functions must be explicitly declared as variadic.
• JS has global and function scope. Lua has global and block scope.
• Foreach in JS loops over object properties. Foreach in Lua loops over iterators and is more general.
• Integer literals in JS can be in octal.
• JS has explicit Unicode support.
• In lua, ~ is used in place of !. (as in, if foo ~= 20 then ... end) (technically syntax but it's a subtle point that still catches me occasionally sometimes)
• In lua, the not/or/and keywords are used in place of !/||/&&. (also syntax but sometimes forget about this too)

Answer 4

JavaScript arrays and objects are closer than you might think. You can use array notation to get at the elements of either of them, and you can add non-numeric indices to arrays. Individual array elements can hold anything, and the array can be sparse. They are nearly identical cousins.

Answer 5

Lua and JavaScript are both prototype base languages.