diferenças sutis entre JavaScript e Lua [fechado]

Eu simplesmente amo JavaScript. É tão elegante (imagine o som quieto de fanboys apaixonados suspirando ao fundo).

Então, recentemente eu brinquei com Lua através da estrutura löve2d (legal!) - e acho que Lua também é ótima. Na minha opinião, essas duas línguas são muito parecidas.

Existem diferenças óbvias, como

• sintaxe
• domínio do problema
• bibliotecas
• tipos (um pouco)

mas quais são os mais sutis? Existe algo que um codificador JavaScript levaria como certo que funciona em Lua apenas um pouco diferente? Existem armadilhas que podem não ser óbvias para o codificador experiente de um idioma que tenta o outro?

Por exemplo: em Lua, matrizes e hashes não são separados (existem apenas tabelas) - em JavaScript, eles são matrizes numéricas e objetos com hash. Bem, essa é uma das diferenças mais óbvias.

Mas existem diferenças no escopo variável, imutabilidade ou algo assim?

Mais algumas diferenças:

• Lua tem suporte nativo para corotinas .
  • UPDATE : JS agora contém a palavra-chave yield dentro de geradores, dando suporte a corotinas.
• Lua não converte entre tipos para nenhum operador de comparação. Em JS, apenas ===e !==não digite malabarismo.
• Lua possui um operador de exponenciação ( ^); JS não. JS utiliza operadores diferentes, incluindo o operador condicional ternário ( ?:vs and/or), e, a partir de 5.3, operadores de bits ( &, |, etc. vs metamétodos ).
  • UPDATE : JS agora tem o operador de exponenciação **.
• JS tem incremento / decremento, digite operadores ( typeofeinstanceof ), operadores de designação adicionais e operadores de comparação adicionais.
• Em JS , as ==, ===, !=e !==os operadores são de preferência menor do que >, >=, <, <=. Em Lua, todos os operadores de comparação têm a mesma precedência .
• Lua suporta chamadas de cauda .
  • UPDATE : JS agora suporta chamadas de cauda .
• Lua suporta a atribuição a uma lista de variáveis . Embora ainda não seja padrão em Javascript , o mecanismo JS da Mozilla (e o Opera, em certa medida) suporta um recurso semelhante desde o JS 1.7 (disponível como parte do Firefox 2) sob o nome " atribuição de desestruturação ". A reestruturação no JS é mais geral, pois pode ser usada em contextos diferentes da atribuição, como definições de funções e chamadas e inicializadores de loop . A atribuição de desestruturação é uma adição proposta ao ECMAScript (o padrão de idioma por trás do Javascript) por um tempo.
  • ATUALIZAÇÃO : A reestruturação (e a atribuição de desestruturação) agora fazem parte das especificações do ECMAScript - já implementadas em muitos mecanismos.
• Em Lua , você pode sobrecarregar os operadores .
• Em Lua , você pode manipular ambientes com getfenvesetfenv em Lua 5.1 ou _ENVem Lua 5.2 e 5.3 .
• Em JS , todas as funções são variadas. Em Lua , as funções devem ser explicitamente declaradas como variáveis .
• Foreachno JS faz um loop sobre as propriedades do objeto. O Foreach em Lua (que usa a palavra-chave for) faz um loop sobre os iteradores e é mais geral.
  • UPDATE : JS também possui Iterables , muitos dos quais são incorporados às estruturas de dados regulares que você esperaria, como Array. Estes podem ser repetidos com a for...ofsintaxe. Para objetos regulares, é possível implementar suas próprias funções de iterador. Isso o aproxima muito de Lua.

• JS tem escopo global e de função. Lua tem escopo global e de bloco . As estruturas de controle (por exemplo if, for, while) introduzir novos blocos .

  • Devido a diferenças nas regras de escopo, a referência de fechamento de uma variável externa (chamada "upvalues" na linguagem Lua) pode ser tratada de maneira diferente em Lua e em Javascript . Isso geralmente ocorre com fechamentos em forloops e pega algumas pessoas de surpresa. Em Javascript , o corpo de um forloop não apresenta um novo escopo; portanto, todas as funções declaradas no corpo do loop referenciam as mesmas variáveis ​​externas . Em Lua, cada iteração do forloop cria novas variáveis ​​locais para cada variável do loop.

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

    O código acima é equivalente a:

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

    Como conseqüência, as funções definidas em iterações separadas têm valores superiores diferentes para cada variável de loop referenciada. Veja também as respostas de Nicolas Bola para Implementação de fechamentos em Lua? e " Quais são as semânticas corretas de um fechamento sobre uma variável de loop? " e " A semântica do genérico para ".

    UPDATE : JS agora tem escopo de bloco. Variáveis ​​definidas com letou constrespeitam o escopo do bloco.

• Literais inteiros em JS podem estar em octal.
• O JS possui suporte explícito ao Unicode e as seqüências internas são codificadas em UTF-16 (portanto, são seqüências de pares de bytes). Várias funções JavaScript internas usam dados Unicode, como "pâté".toUpperCase()( "PÂTÉ"). Lua 5.3 e superior têm seqüências de escape de ponto de código Unicode em literais de cadeia de caracteres (com a mesma sintaxe que as seqüências de escape de ponto de código JavaScript), bem como a utf8biblioteca interna, que fornece suporte básico para a codificação UTF-8(como codificar pontos de código em UTF-8 e decodificar UTF-8 em pontos de código, obter o número de pontos de código em uma string e iterar sobre pontos de código). Strings em Lua são sequências de bytes individuais e podem conter texto em qualquer codificação ou dados binários arbitrários. Lua não possui nenhuma função interna que use dados Unicode; o comportamento de string.upperdepende da localidade C.
• Na Lua , o not, or, andpalavras-chave são usadas no lugar de JS s' !, ||, &&.
• Lua usa ~=para "diferente de", enquanto JS usa !==. Por exemplo if foo ~= 20 then ... end,.
• Lua 5.3 e superior usam ~XOR bit a bit binário, enquanto JS usa ^.
• Em Lua , qualquer tipo de valor (exceto nile NaN) pode ser usado para indexar uma tabela. No JavaScript , todos os tipos que não são de seqüência de caracteres (exceto o símbolo) são convertidos em seqüências de caracteres antes de serem usados ​​para indexar um objeto. Por exemplo, após a avaliação do código a seguir, o valor obj[1]será "string one"em JavaScript, mas "number one"em Lua: obj = {}; obj[1] = "number one"; obj["1"] = "string one";.
• Em JS , atribuições são tratadas como expressões, mas em Lua elas não são. Assim, JS permite atribuições em condições de if, whilee do whiledeclarações, mas Lua não faz em if, whilee repeat untildeclarações. Por exemplo, if (x = 'a') {}é JS válido, mas if x = 'a' do endé Lua inválido.
• Lua tem açúcar sintático para declarar variáveis da função de escopo de bloco, funções que são campos, e métodos ( local function() end, function t.fieldname() end, function t:methodname() end). JS os declara com um sinal de igual ( let funcname = function optionalFuncname() {}, objectname.fieldname = function () {}).

Algumas diferenças sutis que o capturam pelo menos uma vez:

• Diferente é escrito ~=em Lua. Em JS é!=
• As matrizes Lua são baseadas em 1 - seu primeiro índice é 1 em vez de 0.
• Lua requer dois pontos em vez de um período para chamar métodos de objeto. Você escreve em a:foo()vez de a.foo() ^†

^† você pode usar um período se quiser, mas precisa passar a selfvariável explicitamente. a.foo(a)parece um pouco pesado. Veja Programando em Lua para detalhes.

Para ser sincero, seria mais fácil listar as coisas comuns ao Javascript e Lua do que listar as diferenças. Ambas são linguagens de script de tipo dinâmico, mas isso é o mais longe possível. Eles têm uma sintaxe totalmente diferente, diferentes objetivos de design original, diferentes modos de operação (Lua é sempre compilado no bytecode e executado na Lua VM, o Javascript varia), a lista continua.

Matrizes e objetos JavaScript estão mais próximos do que você imagina. Você pode usar a notação de matriz para obter os elementos de qualquer um deles e adicionar índices não numéricos às matrizes. Elementos individuais da matriz podem conter qualquer coisa, e a matriz pode ser esparsa. Eles são primos quase idênticos.

Em cima da minha cabeça

Lua ...

1. suporta corotinas
2. não tem restrição para apenas string / número como chave para uma tabela. Tudo funciona.
3. o tratamento de erros é um pouco desajeitado. Ou você não lida com nada ou usa o método pcall
4. Acho que li algo sobre diferenças no escopo lexical e que Lua tem o melhor.
5. Se bem me lembro, o suporte à expressão regular em lua é limitado

Gostei desta pergunta e das respostas fornecidas. Razões adicionais para as duas línguas parecerem mais parecidas comigo:

Ambos atribuem funções a variáveis, podem criar funções rapidamente e definir fechamentos.

Lua e JavaScript são linguagens básicas de protótipo.

Um teste revela que o Javascript atual também retorna objetos, ou pelo menos seqüências de caracteres de expressões lógicas como lua:

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