diferencias sutiles entre JavaScript y Lua [cerrado]

Simplemente me encanta JavaScript. Es muy elegante (imagina el sonido tranquilo del fanboy enamorado suspirando en el fondo).

Entonces, recientemente he jugado con Lua a través del marco löve2d (¡genial!), Y creo que Lua también es genial. A mi modo de ver, esos dos idiomas son muy similares.

Hay diferencias obvias, como

• sintaxis
• dominio problemático
• bibliotecas
• tipos (un poco)

pero cuales son los más sutiles? ¿Hay algo que un codificador de JavaScript daría por sentado que funciona en Lua solo un poco diferente? ¿Hay alguna dificultad que puede no ser obvia para el codificador experimentado de un idioma que prueba el otro?

Por ejemplo: en Lua, las matrices y los 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 así?

Algunas diferencias más:

• Lua tiene soporte nativo para las corutinas .
  • ACTUALIZACIÓN : JS ahora contiene la palabra clave de rendimiento dentro de los generadores, lo que le da soporte para las rutinas.
• Lua no convierte entre tipos para ningún operador de comparación. En JS, solo ===y !==no escriba malabares.
• Lua tiene un operador de exponenciación ( ^); JS no lo hace. JS utiliza diferentes operadores, incluyendo el operador condicional ternario ( ?:vs and/or), y, a partir de 5.3, operadores bit a bit ( &, |, etc. vs. metamétodos ).
  • ACTUALIZACIÓN : JS ahora tiene el operador de exponenciación **.
• JS tiene incrementos / decrementos, operadores de tipo ( typeofy 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 tienen la misma precedencia .
• Lua admite llamadas de cola .
  • ACTUALIZACIÓN : JS ahora admite llamadas de cola .
• Lua admite la asignación a una lista de variables . Si bien aún 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 de " asignación de desestructuración ". La desestructuración en JS es más general, ya que se puede usar en contextos distintos de la asignación, como definiciones de funciones y llamadas e inicializadores de bucle . La asignación de desestructuración 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 la asignación de desestructuración) ahora es parte de la especificación para ECMAScript, ya implementada en muchos motores.
• En Lua , puede sobrecargar a los operadores .
• En Lua , puede manipular entornos con getfenvysetfenv en Lua 5.1 o _ENVen Lua 5.2 y 5.3 .
• En JS , todas las funciones son variadas. En Lua , las funciones deben declararse explícitamente como variables .
• Foreachen JS recorre las propiedades del objeto. Foreach en Lua (que usa la palabra clave for) recorre los iteradores y es más general.
  • ACTUALIZACIÓN : JS también tiene Iterables , muchos de los cuales están integrados en las estructuras de datos normales que esperaría, como Array. Estos se pueden enlazar con la for...ofsintaxis. Para objetos normales, uno puede implementar sus propias funciones de iterador. Esto lo acerca mucho más a Lua.

• JS tiene alcance global y funcional. Lua tiene alcance global y de bloque . Las estructuras de control (p if. Ej . for, while) Introducen nuevos bloques .

  • Debido a las diferencias en las reglas de alcance, la referencia de cierre de una variable externa (llamada "valores superiores" en lenguaje Lua) puede manejarse de manera diferente en Lua y en Javascript . Esto se experimenta con mayor frecuencia con los cierres en forbucles , y sorprende a algunas personas. En Javascript , el cuerpo de un forbucle no introduce un nuevo alcance, por lo que todas las funciones declaradas en el cuerpo del bucle hacen referencia a las mismas variables externas . En Lua, cada iteración del forciclo crea nuevas variables locales para cada variable del ciclo.

    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 separadas tienen valores ascendentes diferentes para cada variable de bucle referenciada. Ver también las respuestas de Nicolas Bola a la implementación de cierres en Lua? y " ¿Cuál es la semántica correcta de un cierre sobre una variable de bucle? " y " La semántica de lo genérico para ".

    ACTUALIZACIÓN : JS tiene alcance de bloque ahora. Variables definidas con leto constrespetan el alcance del bloque.

• Los literales enteros en JS pueden estar en octal.
• JS tiene soporte explícito de Unicode, y las cadenas internas están codificadas en UTF-16 (por lo que son secuencias de pares de bytes). Varias funciones de JavaScript incorporadas utilizan datos Unicode, como "pâté".toUpperCase()( "PÂTÉ"). Lua 5.3 y versiones posteriores tienen secuencias de escape de puntos de código Unicode en literales de cadena (con la misma sintaxis que las secuencias de escape de puntos de código JavaScript), así como la utf8biblioteca incorporada , que proporciona soporte básico para la codificación UTF-8(como codificar puntos de código en UTF-8 y decodificar UTF-8 en puntos de código, obtener el número de puntos de código en una cadena e iterar sobre puntos de código). Las cadenas en Lua son secuencias de bytes individuales y pueden contener texto en cualquier codificación o datos binarios arbitrarios. Lua no tiene ninguna función incorporada que use datos Unicode; el comportamiento de string.upperdepende de la configuración regional C.
• En Lua , la not, or, andpalabras clave se utilizan en lugar de JS s' !, ||, &&.
• Lua usa ~=para "no igual", mientras que JS usa !==. Por ejemplo, if foo ~= 20 then ... end.
• Uso de Lua 5.3 y versiones posteriores ~para XOR bitinario binario, mientras que JS usa ^.
• En Lua , cualquier tipo de valor (excepto nily NaN) se puede usar para indexar una tabla. En JavaScript , todos los tipos que no son cadenas (excepto el Símbolo) se convierten en cadenas antes de usarse para indexar un objeto. Por ejemplo, después de la evaluación del código siguiente, el valor de obj[1]será "string one"en JavaScript, pero "number one"en Lua: obj = {}; obj[1] = "number one"; obj["1"] = "string one";.
• En JS , las asignaciones se tratan como expresiones, pero en Lua no lo son. Por lo tanto, JS permite asignaciones en condiciones de if, whiley do whiledeclaraciones, pero no lo hace en Lua if, whiley repeat untildeclaraciones. Por ejemplo, if (x = 'a') {}es válido JS, pero if x = 'a' do endno es válido Lua.
• Lua tiene azúcar sintáctico para la declaración de variables de la función de bloque de ámbito, funciones que son campos, y métodos ( local function() end, function t.fieldname() end, function t:methodname() end). JS declara estos con un signo igual ( let funcname = function optionalFuncname() {}, objectname.fieldname = function () {}).

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

• No igual se deletrea ~=en Lua. En JS es!=
• Las matrices Lua están basadas en 1 : su primer índice es 1 en lugar de 0.
• Lua requiere dos puntos en lugar de un punto para llamar a métodos de objeto. Escribes en a:foo()lugar de a.foo() ^†

^† puede usar un punto si lo desea, pero tiene que pasar la selfvariable explícitamente. a.foo(a)se ve un poco engorroso. Vea Programación en Lua para más detalles.

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 secuencias de comandos de tipo dinámico, pero eso es lo más lejos que puedes llegar realmente. Tienen una sintaxis totalmente diferente, diferentes objetivos de diseño originales, diferentes modos de operación (Lua siempre se compila para bytecode y se ejecuta en Lua VM, Javascript varía), la lista sigue y sigue.

Las matrices y objetos de JavaScript 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.

La parte superior de mi cabeza

Lua ...

1. soporta corutinas
2. no tiene restricción para solo cadena / número como clave para una tabla. Todo funciona.
3. El manejo de errores es algo torpe. O no manejas nada o usas el método pcall
4. Creo que leí algo sobre las diferencias en el ámbito léxico y que Lua tiene el mejor.
5. Si recuerdo correctamente, el soporte de expresiones regulares en lua es limitado

Me gustó esta pregunta y las respuestas proporcionadas. Razones adicionales que los dos idiomas me parecen más parecidos que a mí:

Ambos asignan funciones a variables, pueden construir funciones sobre la marcha y definir cierres.

Lua y JavaScript son ambos lenguajes base prototipo.

Una prueba revela que Javascript actual también devuelve objetos, o al menos cadenas de expresiones lógicas como lo hace lua:

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