diferenças sutis entre JavaScript e Lua [fechado]


121

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?


8
Para aqueles que, como eu, estavam procurando uma comparação geral e terminaram aqui por acidente, a seguir é uma boa visão geral: phrogz.net/lua/LearningLua_FromJS.html
Tao

Esta é uma série de três partes, explicando todas as diferenças que você precisa saber para começar: oreilly.com/learning/...
charAt

Respostas:


189

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 .
  • 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 () {}).

6
em Lua, operadores lógicos (e, ou) retornam um dos argumentos. todas as funções podem ser chamadas com qualquer número de parâmetros; mas são ajustados para o número necessário (a menos que você use the ... 'args extras')
Javier

1
@RCIX: veja luaconf.h (e no Lua 5.2, também lparser.c e llimits.h). Valores / função locais máximos = 200 em Lua 5.1 e Lua 5.2. Upvalues ​​máximos / função = 60 em Lua 5.1, 255 em Lua 5.2 (e essa contagem também inclui upvalues ​​"herdados por" fechamentos criados dentro da função).
precisa saber é o seguinte

8
Eu acho que você pode adicionar matrizes baseadas em 1 à lista, pode ser bastante irritante quando você não está acostumado.
Yann

2
Somente nil e false são falsos em Lua - assim, por exemplo, 0 é verdadeiro em Lua, mas não em js. Sobre o suporte a Unicode: Lua 5.3 adiciona suporte explícito a UTF-8, e as versões mais antigas de Lua são amigáveis ​​aos buffers UTF-8 mantidos em cadeias (por exemplo, você pode usar Unicode em padrões de pesquisa de cadeias). O suporte Js ao UTF-8 não é perfeito, pois o V8 usa internamente uma representação antiga de 16 bits, portanto, suas seqüências unicode podem acabar com pares substitutos (surpresa!) Que não seriam necessários no bom e velho UTF-8 (e ganharam isso acontece em Lua).
Tyler

4
Adorei essa lista, mas não vejo como ~=pode provocar erros sutis . Pode provocar erros de sintaxe , mas eles não são nada sutis.
Kikito

12

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.


5
usando o para a anotação faz parecer que a.foo()morreu xD
DarkWiiPlayer

11

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.


8
absolutamente. os objetivos muito diferentes incluem uma alta prioridade para ter uma linguagem limpa. Javascript tem muita bagagem histórica, Lua lança continuamente qualquer coisa indesejada.
Javier

3
+1. Eu nem vejo como eles são semelhantes, exceto pelo fato de que ambos são usados ​​para scripts (o que é óbvio demais).
Sasha Chedygov 21/06/2009

13
-1 (se eu pudesse) Eles são muito parecidos no design de idiomas. Lua simplesmente tem mais recursos e é menor (também mais rápido?). Eu acho que você confunde design de linguagem com opções de implementação.
JPC

Sim, ambos são protótipo OOP (mesmo que não seja explicitamente declarado usando prototypeobjetos de palavra - chave ou nomeação de objetos, apesar do fato de serem exatamente essas tabelas lua), com funções de cidadão de primeira classe, apesar de não serem funcionais no sentido tradicional (imutabilidade , desenvolvimento declarativo etc.),
Bojan Markovic 13/01

2
Claro, existem diferenças sintáticas e, se você olhar superficialmente, pode concluir que os idiomas são diferentes. No entanto em ter exatamente o mesmo tipo principal de dados (objeto / table) ea mesma forma de implementar classes e inherritance (algo que muito poucas outras línguas compartilham) torna incrivelmente perto em espírito. O design do programa JS não trivial seria praticamente o mesmo de um programa Lua.
Alex Gian

7

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.


1
Alguém pode ter primos idênticos?
jameshfisher

Eles têm a mesma estrutura de dados, a única diferença é o descritor de tipo, para que você possa diferenciá-los.
Lilith River

5
Uma declaração mais precisa seria: Arrays são objetos com comportamento especial de seu membro "length".
tzenes 14/09/11

@eegg: claro, Cathy e Patty .
Outis

3

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

Lua faz têm escopo lexical. JavaScript possui apenas escopo de função. bem, no Mozilla e Rhino, agora você pode usar 'let' em vez de 'var' e obter um escopo lexical adequado; mas ainda não é portátil.
Javier

1
A biblioteca de cadeias padrão de Lua inclui funções limitadas de correspondência de padrões; mas há também o LPEG (também uma biblioteca), que oferece um sistema de correspondência muito mais poderoso, facilmente utilizável para uma gramática completa.
Javier

Afirmei que LUA tem o escopo lexical "melhor" do que o javascript, não que não possua.
jitter

1
LPEG é uma biblioteca adicional que significa suporte núcleo regex é limitado a me
jitter

existe alguma restrição entre as chaves de seqüência de caracteres e as teclas numéricas, o uso de ambas na mesma tabela fica confuso muito rápido, pois # retorna o comprimento da tabela, não pela quantidade de índices numerados, que entra em conflito com qualquer entrada do dicionário (indexação nula após enumerada índices de tabela)
Weeve Ferrelaine 01/01

3

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.


1

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


1
Essa é a semelhança óbvia entre os dois idiomas, este e seu uso de tabelas / hashes como o principal tipo de dados. Se você desenvolvesse um programa Javascript idiomaticamente, adotaria praticamente a mesma abordagem que faria em Lua. Você não faria o mesmo em qualquer outro idioma (a menos que seja um idioma baseado na herança de protótipo e tabelas). Esta é uma enorme semelhança. O restante, detalhes sobre sintaxe menor e assim por diante, são bastante pedantes em comparação.
Alex Gian #

1
As diferenças importantes são que o Jaavscript não suporta corotinas, não é muito acoplado ao C e não é realmente adequado como uma linguagem incorporada. (Quantas microcontroladores são programados em JavaScript?) Javascript também é muito mais confuso, com toneladas de pegadinhas legados e Wats ( destroyallsoftware.com/talks/wat ) - a partir de 1:40. Lua teve uma disciplina espartana bastante imposta. Javascript, é claro, é muito forte no navegador.
Alex Gian

1

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();
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.