diferencias sutiles entre JavaScript y Lua

Presta atención ya que en esta sección encontrarás la respuesta que buscas.Esta reseña fue aprobado por nuestros expertos para garantizar la calidad y exactitud de nuestro contenido.

Solución:

Algunas diferencias más:

• Lua tiene soporte nativo para corrutinas.
  • ACTUALIZAR: JS ahora contiene la palabra clave yield dentro de los generadores, lo que le da soporte para corrutinas.
• 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, incluido el operador condicional ternario (?: vs and/or) y, a partir de 5.3, operadores bit a bit (&, |, etc. vs metamétodos).
  • ACTUALIZAR: JS ahora tiene el operador de exponenciación **.
• JS tiene incremento / decremento, operadores de tipo (typeof y instanceof), operadores de asignación adicionales y operadores de comparación adicionales.
• En JS, los ==, ===, != y !== Los operadores tienen menor precedencia que >, >=, <, <=. En Lua, todos los operadores de comparación tienen la misma precedencia.
• Lua admite llamadas de cola.
  • ACTUALIZAR: 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) con 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 a la asignación, como definiciones y llamadas de funciones e inicializadores de bucle. La tarea de desestructuración ha sido una adición propuesta a ECMAScript (el estándar de lenguaje detrás de Javascript) por un tiempo.
  • ACTUALIZAR: La desestructuración (y la asignación de desestructuración) ahora es parte de la especificación de ECMAScript, ya implementada en muchos motores.
• En Lua, puede sobrecargar a los operadores.
• En Lua, puedes manipular entornos con getfenv y setfenv en Lua 5.1 o _ENV en Lua 5.2 y 5.3.
• En JS, todas las funciones son variadas. En Lua, las funciones deben declararse explícitamente como variadic.
• Foreach en JS recorre las propiedades del objeto. Foreach en Lua (que usa la palabra clave for) recorre iteradores y es más general.
  • ACTUALIZAR: JS ahora también tiene iterables, muchos de los cuales están integrados en las estructuras de datos regulares que esperaría, como Array. Estos se pueden enrollar con el for...of sintaxis. Para los objetos regulares, se pueden 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. Estructuras de control (p. Ej. if, for, while) introducir nuevos bloques.

  • Debido a las diferencias en las reglas de alcance, la referencia de un cierre a una variable externa (llamada "upvalues" en el lenguaje de Lua) puede manejarse de manera diferente en Lua y en Javascript. Esto se experimenta más comúnmente con cierres en for bucles y pilla a algunas personas por sorpresa. En Javascript, el cuerpo de un for El bucle 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 for bucle 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 separadas tienen diferentes valores ascendentes para cada variable de ciclo referenciada. Ver también las respuestas de Nicolás Bola a ¿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 del genérico para".

    ACTUALIZAR: JS tiene alcance de bloque ahora. Variables definidas con let o const respetar el alcance del bloque.

• Literales enteros en JS puede estar en octal.
• JS tiene soporte explícito Unicode e internamente las cadenas están codificadas en UTF-16 (por lo que son secuencias de pares de bytes). Varias funciones de JavaScript integradas utilizan datos Unicode, como "pâté".toUpperCase() ("PÂTÉ"). Lua 5.3 y hasta tienen secuencias de escape de puntos de código Unicode en string literales (con la misma sintaxis que las secuencias de escape de puntos de código JavaScript) así como utf8 biblioteca, 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, obteniendo el número de puntos de código en un stringe iterando 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 funciones integradas que usen datos Unicode; el comportamiento de string.upper depende de la configuración regional de C.
• En Lua, los not, or, and se utilizan palabras clave en lugar de JS's !, ||, &&.
• Lua usos ~= para "no es igual", mientras que JS usos !==. Por ejemplo, if foo ~= 20 then ... end.
• Lua 5.3 y hasta uso ~ para XOR binario bit a bit, mientras que JS usos ^.
• En Lua, cualquier tipo de valor (excepto nil y NaN) se puede utilizar para indexar una tabla. En JavaScript, todos nostring los tipos (excepto Symbol) se convierten en cadenas antes de usarse para indexar un objeto. Por ejemplo, después de la evaluación del siguiente código, el valor de obj[1] estarán "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 son. Así, 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 no es válido Lua.
• Lua tiene azúcar sintáctico para declarar variables de función con alcance de bloque, 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 sorprenderán al menos una vez:

• No es igual se deletrea ~= en Lua. En JS es !=
• Las matrices Lua se basan 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. Usted escribe a:foo() en lugar de a.foo()^†

^† puede usar un punto si lo desea, pero debe pasar el self variable explícitamente. a.foo(a) parece un poco engorroso. Consulte Programación en Lua para obtener más detalles.

Para ser honesto, 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 escritos dinámicamente, pero eso es lo más lejos que puede llegar. 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.

Si piensas que ha sido útil nuestro artículo, agradeceríamos que lo compartas con más entusiastas de la programación y nos ayudes a dar difusión a esta información.

---

---

Utiliza Nuestro Buscador