diferencias sutiles entre JavaScript y Lua

Question

Simplemente amo JavaScript. Es tan elegante (imagina el sonido silencioso de un fanático enamorado suspirando en el fondo).

Por lo tanto, recientemente he jugado con Lua a través del framework löve2d (¡agradable!) - y creo que Lua también es genial. Como yo lo veo, esos dos idiomas son muy similar.

Hay diferencias obvias, como

• sintaxis
• dominio del problema
• bibliotecas
• tipos (un poco)

pero que son los más sutiles? ¿Hay algo que un programador de JavaScript daría por sentado que funciona en Lua un poco diferente? ¿Hay dificultades que pueden no ser obvias para el codificador experimentado de un idioma que intenta el otro?

Por ejemplo: en Lua, las matrices y hashes no están separados (solo hay tablas) - en JavaScript, son Matrices numéricas y Objetos hash. Bueno, esta es una de las diferencias más obvias.

¿Pero hay diferencias en el alcance variable, la inmutabilidad o algo como esto?

Answer 1

Algunos más diferencias:

• Lua tiene soporte nativo para coroutines.
  • ACTUALIZACIÓN: JS ahora contiene la palabra clave yield dentro de los generadores, dándole soporte para coroutines.
• Luadoesn't convert entre los tipos de los operadores de comparación. En JS, solo === y !== no escriben malabares.
• Lua tiene un operador de exponenciación (^); JS no. JS utiliza diferentes operadores, incluyendo el operador condicional ternario (?: vs and/or), y, a partir de 5,3, operadores bit a bit (&, |, etc. vs. metamethods).
  • ACTUALIZACIÓN: JS ahora tiene el operador de exponenciación **.
• JS tiene incremento/decremento, los operadores de tipo (typeof y instanceof), operadores de asignación adicionales y operadores de comparación adicionales.
• En JS, los ==, ===, != y !== operadores son de menor precedencia que >, >=, <, <=. En Lua, todos los operadores de comparación son same precedence.
• Lua admite tail calls.
  • ACTUALIZACIÓN: JS ahora supports tail calls.
• Lua soportaassignment to a list of variables. Si bien todavía no es estándar en Javascript, el motor JS de Mozilla (y el de Opera, hasta cierto punto) ha admitido una característica similar desde JS 1.7 (disponible como parte de Firefox 2) bajo el nombre "destructuring assignment". La desestructuración en JS es más general, ya que se puede usar en contextos distintos a la asignación, como function definitions & calls y loop initializers. Destructuring assignment ha sido una adición propuesta a ECMAScript (el estándar de lenguaje detrás de Javascript) por un tiempo.
  • ACTUALIZACIÓN: La desestructuración (y asignación desestructurada) es ahora parte de la especificación de ECMAScript - ya implementada en muchos motores.
• En Lua, puede overload operators.
• En Lua, puede manipulate environments con getfenv & setfenv.
• En JS, todas las funciones son variadas. En Lua, las funciones deben ser explicitly declared as variadic.
• Foreach en JS bucles sobre las propiedades del objeto.Foreach en Lua (que usa la palabra clave for) pasa por encima de los iteradores y es más general.
  • ACTUALIZACIÓN: JS tiene Iterables ahora también, muchas de las cuales están incorporadas en las estructuras de datos regulares que cabe esperar, como Array. Estos pueden enlazarse con la sintaxis for...of. Para objetos regulares, uno puede implementar sus propias funciones de iterador. Esto lo acerca mucho más a Lua.

• JS tiene alcance global y de funciones. Lua tiene global and block scope. Las estructuras de control (por ejemplo, if, for, while) introducen el nuevo blocks.

  • Debido a las diferencias en las reglas de determinación del alcance, las referencias de un cierre de una variable externa (llamada "upvalues" en el lenguaje Lua) puede manejarse de manera diferente en Lua y en Javascript. Esto se experimenta más comúnmente con closures in for loops, y coge a algunas personas por sorpresa. En Javascript, el cuerpo de un bucle for no introduce un nuevo ámbito, por lo que cualquier función declarada en el cuerpo del bucle hace referencia al same outer variables. En Lua, cada iteración del bucle for crea nuevas variables locales para cada variable de bucle.

    local i='foo' 
    for i=1,10 do 
        -- "i" here is not the local "i" declared above 
        ... 
    end 
    print(i) -- prints 'foo' 
    

    El código anterior es equivalente a:

    local i='foo' 
    do 
        local _i=1 
        while _i<10 do 
        local i=_i 
        ... 
        _i=_i+1 
        end 
    end 
    print(i) 
    

    Como consecuencia, las funciones definidas en iteraciones independientes tienen diferentes upvalues ​​para cada variable de bucle de referencia. Ver también las respuestas de Nicolas Bola al Implementation of closures in Lua? y "What are the correct semantics of a closure over a loop variable?", y "The Semantics of the Generic for".

    ACTUALIZACIÓN: JS tiene alcance de bloque ahora. Las variables definidas con let o const respetan el alcance del bloque.

• literales enteros en JS pueden estar en octal.
• JS tiene compatibilidad explícita con Unicode.
• En Lua, ~ se usa en lugar de !. (como en, if foo ~= 20 then ... end) (sintaxis técnica, pero se pasa por alto fácilmente y causa errores sutiles).
• En Lua, las palabras clave not/or/and se usan en lugar de !/||/&& (también sintaxis pero también se olvidan fácilmente).
• En Lua, se puede usar cualquier tipo de valor (excepto nil y NaN) para indexar una tabla; en JavaScript, los índices de objeto se convierten en cadenas.
• En JS, las asignaciones se tratan como expresiones, pero en Lua no lo son.Por lo tanto, JS permite asignaciones en condiciones de if, while y do while declaraciones, pero Lua no en if, while y repeat until declaraciones. Por ejemplo, if (x = 'a') {} es JS válido, pero if x = 'a' do end es Lua no válido.

Answer 2

Para ser sincero, sería más fácil enumerar las cosas que son comunes a Javascript y Lua que enumerar las diferencias. Ambos son lenguajes de scripting de tipo dinámico, pero eso es lo más que puedes llegar realmente. Tienen una sintaxis totalmente diferente, diferentes objetivos de diseño originales, diferentes modos de operación (Lua siempre se compila en bytecode y se ejecuta en Lua VM, Javascript varía), la lista sigue y sigue.

Answer 3

De la parte superior de mi cabeza

Lua ...

1. apoya coroutines
2. tiene ninguna restricción a poco cadena/número como la clave para una tabla. Todo funciona.
3. el manejo de errores es algo torpe. O bien no maneja nada o usa el método pcall
4. Creo que leí algo acerca de las diferencias en el alcance léxico y que Lua tiene la mejor.
5. Si recuerdo correctamente soporte de expresiones regulares en Lua es limitado

Answer 4

Las matrices de JavaScript y los objetos están más cerca de lo que piensas. Puede usar la notación de matriz para obtener los elementos de cualquiera de ellos, y puede agregar índices no numéricos a las matrices. Los elementos de matriz individuales pueden contener cualquier cosa, y la matriz puede ser escasa. Son primos casi idénticos.

Answer 5

Un par de diferencias sutiles que te atrapará a cabo al menos una vez:

• No igual ~= se escribe en Lua. En JS es !=
• Lua arrays are 1-based - su primer índice es 1 en vez de 0.
• Lua requiere dos puntos en lugar de un período para llamar a métodos de objeto. Usted escribe a:foo() en lugar de a.foo()^{& dagger;}

^{& dagger;} puede usar un período si lo desea, pero debe pasar la variable self explícitamente. a.foo(a) parece un poco engorroso. Vea Programming in Lua para más detalles.

Answer 6

Lua y JavaScript son dos idiomas base de prototipo.

Answer 7

Me ha gustado esta pregunta y las respuestas proporcionadas. Otras razones las dos lenguas parecen más parecidos de lo que no me

:

Ambas funciones asignar a las variables, pueden construir funciones sobre la marcha, y definir los cierres.

Answer 8

Una prueba revela que la corriente Javascript también devuelve los objetos, o al menos las cadenas de expresiones lógicas como LUA:

function nix(){ 
    alert(arguments[0]||"0"); 
} 
nix();