javascript - resumen - lista de codigos java script

sutiles diferencias entre JavaScript y Lua

Question

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

Así que, recientemente, he jugado con Lua a través del framework löve2d (¡agradable!) Y creo que Lua también es genial. De la forma en que lo veo, esos dos idiomas son muy similares.

Hay diferencias obvias, como

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

pero, ¿cuáles 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 así?

Answer 1

La parte superior de mi cabeza

Lua ...

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

Answer 2

Las matrices de JavaScript y los objetos están más cerca de lo que crees. 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 3

Lua y JavaScript son ambos lenguajes base de prototipos.

Answer 4

Me gustó esta pregunta y las respuestas proporcionadas. Razones adicionales por las 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.

Answer 5

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 6

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

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

^† puede usar un período si lo desea, pero tiene que pasar la variable self explícita. a.foo(a) parece un poco engorroso. Ver Programación en Lua para más detalles.

Answer 7

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

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

Answer 8

Algunas 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 corutinas.
• Lua no convierte entre tipos para ningún operador de comparación. En JS, solo === y !== no escribas malabares.
• Lua tiene un operador de exponenciación ( ^ ); JS no. JS utiliza diferentes operadores, incluido 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 incrementos / decrementos, operadores tipo ( typeof y instanceof ), operadores de asignación adicionales y operadores de comparación adicionales.
• En JS , los operadores == , === != Y !== tienen menor prioridad 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 soportado 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 a la asignación, como las definiciones de funciones y llamadas y los 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 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 de los objetos. Foreach en Lua (que usa la palabra clave for ) recorre 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 pueden enlazarse con el for...of sintaxis. Para objetos regulares, 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. Ej. if , for , while ) introducen nuevos blocks .

  • Debido a las diferencias en las reglas de alcance, la referencia de un cierre de una variable externa (llamada "valores ascendentes" en el lenguaje de Lua) puede tratarse de manera diferente en Lua y en Javascript . Esto se experimenta más comúnmente con cierres en bucles for , 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 a las mismas variables externas . 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 separadas tienen diferentes valores ascendentes 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 ciclo? " y " La semántica del genérico para ".

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

• Los literales enteros en JS pueden estar en octal.
• JS tiene soporte explícito de 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 , cualquier tipo de valor (excepto nil y NaN ) puede usarse para indexar una tabla; en JavaScript , los índices de objetos 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 , pero Lua no en if , while y repeat until statements. Por ejemplo, if (x = ''a'') {} es JS válido, pero if x = ''a'' do end no es válido Lua.