diferenças subtis entre JavaScript e Lua [fechado]

StackOverflow https://stackoverflow.com/questions/1022560

  •  06-07-2019
  •  | 
  •  

Pergunta

Eu simplesmente amo JavaScript. É tão elegante (imagine o som tranquilo de suspiro apaixonado fanboy no fundo).

Então, recentemente eu ter jogado com Lua através do löve2d quadro (bom!) - e eu acho que Lua também é grande . Eles maneira que eu vejo, essas duas línguas são muito similar.

Existem diferenças óbvias, como

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

mas que são os mais sutis? Existe alguma coisa que um programador JavaScript levaria para concedido que as obras em Lua apenas ligeiramente diferente? Há algum armadilhas que podem não ser óbvio para o codificador experiente de uma língua tentando o outro?

Por exemplo: na Lua, arrays e hashes não são separados (há apenas mesas) - em JavaScript, são Arrays numéricos e objetos de hash. Bem, esta é uma das diferenças mais óbvias.

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

Foi útil?

Solução

Mais algumas diferenças:

  • Lua tem suporte nativo para coroutines .
    • Atualizar :. JS agora contém a palavra-chave de rendimento dentro de geradores, dando-lhe suporte para coroutines
  • Lua não converte entre os tipos para todos os operadores de comparação. Em JS, única === e !== não digite juggle.
  • Lua tem um operador de exponenciação (^); JS não. JS usa operadores diferentes, incluindo o operador condicional ternário (?: vs and/or), e, a partir de 5,3, operadores de bits (&, |, etc vs metamétodos ).
    • Atualizar :. JS tem agora a ** operador de exponenciação
  • JS tem aumentar / diminuir, operadores de tipo (typeof e instanceof), operadores de atribuição adicionais e operadores de comparação adicional.
  • Em JS , os operadores ==, ===, != e !== são de precedência inferior >, >=, <, <=. Na Lua, todos os operadores de comparação são os mesma precedência .
  • Lua cauda chama .
  • Lua atribuição a uma lista de variáveis ??. Embora ainda não é padrão em Javascript , o motor do Mozilla JS (e Opera de, até certo ponto) apoiou um recurso semelhante desde JS 1.7 (disponível como parte do Firefox 2) sob o nome " desestruturação atribuição ". Desestruturação em JS é mais geral, uma vez que pode ser utilizado em outras do que a atribuição contextos, tais como definições de funções e chamadas e initializers laço . desestruturação atribuição tem sido uma proposta além de ECMAScript (a linguagem padrão para trás Javascript) por algum tempo.
    • Atualizar :. Desestruturação (e atribuição desestruturação) agora faz parte da especificação para ECMAScript - já implementado em muitos motores
  • No Lua , você pode sobrecarga operadores .
  • Em Lua , você pode manipular ambientes com getfenv e setfenv em Lua 5.1 ou _ENV em Lua 5.2 5.3 .
  • Em JS , todas as funções estão variádica. Em Lua , as funções devem estar explicitamente declarado como variádica .
  • Foreach em JS laços mais propriedades do objeto. Foreach em Lua (que usar a palavra-chave for) faz um loop sobre iteradores e é mais geral.
    • Atualizar : JS tem Iterables agora também, muitos dos quais são incorporadas as estruturas de dados regulares que você esperaria, como Array. Estes podem ser enrolada ao longo com a sintaxe for...of. Para objetos regulares, pode-se implementar suas próprias funções de iterador. Isto traz-lo muito mais perto de Lua.

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

    • Devido às diferenças nas regras de escopo, referenciação de um encerramento de uma variável externa (chamados "upvalues" em Lua linguagem) podem ser tratados de forma diferente em Lua e em Javascript . Esta é mais comumente experientes com fechamentos em for laços e capturas algumas pessoas por surpresa. Em Javascript , o corpo de um loop for não introduz um novo escopo, então qualquer função declarada no corpo do laço toda referência a mesmas variáveis ??externas . Na Lua, cada iteração do loop for cria novas variáveis ??locais para cada variável 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 uma consequência, as funções definidas nas iterações separados têm diferentes upvalues ??para cada variável de contagem referenciado. Veja também as respostas de Nicolas Bola para de encerramentos em Lua? e " Quais são a semântica correta de um fecho sobre uma variável loop? ", e " a semântica do genérico para ".

      Atualizar : JS tem escopo de bloco agora. As variáveis ??definidas com escopo bloco let ou const respeito.

  • literais inteiro no JS pode ser em octal.
  • JS tem apoio explícito Unicode, e internamente cordas são codificados em UTF-16 (de modo que eles são sequências de pares de bytes). Vários dados Unicode embutidos funções JavaScript utilizar, como "pâté".toUpperCase() ("PÂTÉ"). Lua 5.3 e até têm sequências de escape ponto de código Unicode em strings literais (com a mesma sintaxe de seqüências de escape do ponto de código JavaScript), bem como o built-in biblioteca utf8, que fornece suporte básico para o UTF-8 (tais como pontos de código que codifica para UTF-8 e descodificar UTF-8 em pontos de código, recebendo o número de pontos de código em uma corda, e interagindo sobre pontos de código). Cordas em Lua são sequências de bytes individuais e podem conter texto, em qualquer codificação ou arbitrário da bináriota. não Lua não tem nenhum funções internas que usam dados Unicode; o comportamento de string.upper depende do locale C.
  • Em Lua , os not, or, palavras-chave and são usadas no lugar de JS 's !, ||, &&.
  • Lua usos ~= para "não igual", enquanto que JS usa !==. Por exemplo, if foo ~= 20 then ... end.
  • Lua 5.3 e até uso ~ para XOR bit a bit binário, enquanto que JS usos ^.
  • Em Lua , qualquer tipo de valor (exceto nil e NaN) pode ser usado para indexar uma tabela. Em JavaScript , todos os tipos não-cordas (exceto Symbol) são convertidos para cadeias antes de ser usado para indexar um objeto. Por exemplo, após a avaliação do código a seguir, o valor de obj[1] será "string one" em JavaScript, mas "number one" na Lua:. obj = {}; obj[1] = "number one"; obj["1"] = "string one";
  • Em JS , as atribuições são tratados como expressões, mas no Lua não são. Assim, JS permite atribuições em condições de if, while e declarações do while, mas Lua não em declarações if, while e repeat until. Por exemplo, if (x = 'a') {} é JS válidas, mas if x = 'a' do end é inválido Lua.
  • Lua tem açúcar sintático para declarar variáveis ??de 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 declara estes com um sinal de igual (let funcname = function optionalFuncname() {}, objectname.fieldname = function () {}).

Outras dicas

Um par de diferenças sutis que vai pegar você pelo menos uma vez:

  • ~= Não igual está escrito em Lua. Em JS é !=
  • são 1-baseado - seu primeiro índice é 1 vez que 0.
  • Lua requer uma vírgula em vez de um período para chamar métodos de objetos. Você escreve a:foo() vez de a.foo() †

† você pode usar um período, se quiser, mas tem que passar a variável self explicitamente. a.foo(a) parece um complicado bit. Consulte Programming in Lua para mais detalhes.

Para ser honesto, seria mais fácil listar as coisas que são comuns a Javascript e Lua do que a lista as diferenças. Ambos são linguagens de script dinamicamente digitados, mas isso é quase tão longe quanto você pode ir realmente. Eles têm sintaxe totalmente diferente, diferentes objetivos de design originais, diferentes modos de operação (Lua está sempre compilado para bytecode e executados na Lua VM, Javascript varia), a lista vai sobre e sobre.

matrizes e objetos JavaScript são mais perto do que você imagina. Você pode usar a notação de matriz para obter os elementos de qualquer um deles, e você pode adicionar índices não-numéricos para matrizes. os elementos de matriz individuais podem conter qualquer coisa, e a matriz pode ser escassa. Eles são primos quase idênticos.

Em cima da minha cabeça

Lua ...

  1. coroutines
  2. não tem nenhuma restrição para apenas corda / número como chave para uma mesa. Tudo funciona.
  3. a manipulação de erro é um pouco desajeitado. Ou você não lidar com qualquer coisa ou usar o pcall método
  4. Eu acho que eu li algo sobre as diferenças no âmbito lexical e que Lua tem a melhor.
  5. Se bem me lembro apoio de expressão corretamente regular na lua é limitado

Eu gostei desta pergunta e as respostas dadas. razões adicionais as duas línguas parecem mais semelhantes do que não para mim:

Ambos funções atribuir a variáveis, pode construir funções na mosca, e definir encerramentos.

Um teste revela que a corrente Javascript também retorna objetos, ou pelo menos cordas de expressões lógicas como lua faz: 

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

Lua e JavaScript são duas línguas de base protótipo.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top