sottili differenze tra JavaScript e Lua [chiuso]

Amo semplicemente JavaScript. È così elegante (immagina il suono silenzioso di un fanboy innamorato che sospira in sottofondo).

Quindi, recentemente ho giocato con Lua tramite il framework löve2d (bello!) - e penso che anche Lua sia fantastico. A mio modo di vedere, queste due lingue sono molto simili.

Ci sono differenze evidenti, come

• sintassi
• dominio problematico
• librerie
• tipi (un po ')

ma quali sono i più sottili? C'è qualcosa che un programmatore JavaScript darebbe per scontato che funzioni in Lua in modo leggermente diverso? Ci sono insidie ​​che potrebbero non essere ovvie per il programmatore esperto di una lingua che prova l'altra?

Ad esempio: in Lua, gli array e gli hash non sono separati (ci sono solo tabelle) - in JavaScript, sono array numerici e oggetti con hash. Ebbene, questa è una delle differenze più evidenti.

Ma ci sono differenze in ambito variabile, immutabilità o qualcosa del genere?

Altre differenze:

• Lua ha il supporto nativo per le coroutine .
  • AGGIORNAMENTO : JS ora contiene la parola chiave yield all'interno dei generatori, dandogli il supporto per le coroutine.
• Lua non converte tra i tipi per nessun operatore di confronto. In JS, solo ===e !==non digitare juggle.
• Lua ha un operatore di esponenziazione ( ^); JS no. JS utilizza operatori diversi, tra cui l'operatore condizionale ternario ( ?:vs and/or), e, come di 5,3, operatori bit a bit ( &, |ecc vs metamethods ).
  • AGGIORNAMENTO : JS ora ha l'operatore di esponenziazione **.
• JS ha incremento / decremento, operatori di tipo ( typeofe instanceof), operatori di assegnazione aggiuntivi e operatori di confronto aggiuntivi.
• In JS , i ==, ===, !=e !==operatori di precedenza inferiore >, >=, <, <=. In Lua, tutti gli operatori di confronto hanno la stessa precedenza .
• Lua supporta le chiamate di coda .
  • AGGIORNAMENTO : JS ora supporta le chiamate di coda .
• Lua supporta l' assegnazione a un elenco di variabili . Anche se non è ancora standard in Javascript , il motore JS di Mozilla (e, in una certa misura, Opera) ha supportato una funzionalità simile a partire da JS 1.7 (disponibile come parte di Firefox 2) con il nome di " assegnazione destrutturante ". La destrutturazione in JS è più generale, in quanto può essere utilizzata in contesti diversi dall'assegnazione, come definizioni e chiamate di funzioni e inizializzatori di loop . L'assegnazione di destrutturazione è stata un'aggiunta proposta a ECMAScript (lo standard linguistico dietro Javascript) per un po '.
  • AGGIORNAMENTO : La destrutturazione (e l'assegnazione della destrutturazione) fa ora parte delle specifiche per ECMAScript, già implementata in molti motori.
• In Lua , puoi sovraccaricare gli operatori .
• In Lua è possibile manipolare ambienti con getfenvesetfenv in Lua 5.1 o _ENVin Lua 5.2 e 5.3 .
• In JS , tutte le funzioni sono variadiche. In Lua , le funzioni devono essere dichiarate esplicitamente come variadiche .
• Foreachin JS esegue un ciclo sulle proprietà dell'oggetto. Foreach in Lua (che usa la parola chiave for) ripete gli iteratori ed è più generale.
  • AGGIORNAMENTO : JS ora ha anche Iterables , molti dei quali sono integrati nelle normali strutture di dati che ti aspetteresti, come Array. Questi possono essere ripetuti con la for...ofsintassi. Per oggetti normali, è possibile implementare le proprie funzioni iteratore. Questo lo avvicina molto a Lua.

• JS ha un ambito globale e funzionale. Lua ha un ambito globale e di blocco . Le strutture di controllo (ad esempio if, for, while) introdurre nuovi blocchi .

  • A causa delle differenze nelle regole di scoping, la referenziazione di una chiusura di una variabile esterna (chiamata "upvalues" nel gergo Lua) può essere gestita in modo diverso in Lua e in Javascript . Questo è più comunemente riscontrato con chiusure in forloop e coglie alcune persone di sorpresa. In Javascript , il corpo di un filefor ciclo non introduce un nuovo ambito, quindi tutte le funzioni dichiarate nel corpo del ciclo fanno tutte riferimento alle stesse variabili esterne . In Lua, ogni iterazione del forciclo crea nuove variabili locali per ogni variabile del ciclo.

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

    Il codice sopra è equivalente a:

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

    Di conseguenza, le funzioni definite in iterazioni separate hanno upvalues ​​differenti per ogni variabile del ciclo referenziato. Vedi anche le risposte di Nicolas Bola a Implementation of closures in Lua? e " Quali sono la semantica corretta di una chiusura su una variabile di ciclo? " e " La semantica del generico per ".

    AGGIORNAMENTO : JS ha ora un ambito di blocco. Variabili definite con leto constrispettano l'ambito del blocco.

• I letterali interi in JS possono essere in ottale.
• JS ha un supporto Unicode esplicito e internamente le stringhe sono codificate in UTF-16 (quindi sono sequenze di coppie di byte). Diverse funzioni JavaScript integrate utilizzano dati Unicode, come "pâté".toUpperCase()( "PÂTÉ"). Lua 5.3 e versioni successive hanno sequenze di escape di punti di codice Unicode in stringhe letterali (con la stessa sintassi delle sequenze di escape di punti di codice JavaScript) così come la utf8libreria incorporata , che fornisce il supporto di base per codifica UTF-8(come codificare punti di codice in UTF-8 e decodificare UTF-8 in punti di codice, ottenere il numero di punti di codice in una stringa e iterare su punti di codice). Le stringhe in Lua sono sequenze di singoli byte e possono contenere testo in qualsiasi codifica o dati binari arbitrari. Lua non ha funzioni integrate che utilizzano dati Unicode; il comportamento di string.upperdipende dalla locale C.
• In Lua , il not, or, andle parole chiave sono utilizzati al posto di JS 's !, ||, &&.
• Lua usa ~=per "non uguale", mentre JS usa !==. Ad esempio if foo ~= 20 then ... end,.
• Lua 5.3 e versioni successive utilizzano ~per XOR binario bit per bit, mentre JS utilizza ^.
• In Lua , qualsiasi tipo di valore (eccetto nile NaN) può essere utilizzato per indicizzare una tabella. In JavaScript , tutti i tipi non stringa (eccetto Symbol) vengono convertiti in stringhe prima di essere utilizzati per indicizzare un oggetto. Ad esempio, dopo la valutazione del seguente codice, il valore di obj[1]sarà "string one"in JavaScript, ma "number one"in Lua: obj = {}; obj[1] = "number one"; obj["1"] = "string one";.
• In JS , gli incarichi sono trattati come espressioni, ma in Lua non lo sono. Così, JS permette incarichi in condizioni di if, whilee do whiledichiarazioni, ma Lua non lo fa in if, whilee repeat untille dichiarazioni. Ad esempio, if (x = 'a') {}è JS valido, ma if x = 'a' do endè Lua non valido.
• Lua ha zucchero sintattico per dichiarare variabili di funzione blocchi ambito, funzioni che sono campi e metodi ( local function() end, function t.fieldname() end, function t:methodname() end). JS li dichiara con un segno di uguale ( let funcname = function optionalFuncname() {}, objectname.fieldname = function () {}).

Un paio di sottili differenze che ti colpiranno almeno una volta:

• Non uguale si scrive ~=in Lua. In JS lo è!=
• Gli array Lua sono basati su 1 : il loro primo indice è 1 anziché 0.
• Lua richiede i due punti piuttosto che un punto per chiamare i metodi dell'oggetto. Scrivi a:foo()invece di a.foo() ^†

^† puoi usare un punto se vuoi, ma devi passare la selfvariabile in modo esplicito. a.foo(a)sembra un po 'ingombrante. Vedere Programmazione in Lua per i dettagli.

Ad essere onesti sarebbe più facile elencare le cose che sono comuni a Javascript e Lua piuttosto che elencare le differenze. Sono entrambi linguaggi di scripting dinamicamente digitati, ma questo è quanto puoi davvero. Hanno una sintassi totalmente diversa, diversi obiettivi di progettazione originali, diverse modalità di funzionamento (Lua è sempre compilato in bytecode ed eseguito su Lua VM, Javascript varia), l'elenco potrebbe continuare all'infinito.

Gli array e gli oggetti JavaScript sono più vicini di quanto potresti pensare. È possibile utilizzare la notazione degli array per ottenere gli elementi di uno di essi e aggiungere indici non numerici agli array. I singoli elementi dell'array possono contenere qualsiasi cosa e l'array può essere scarso. Sono cugini quasi identici.

Dalla parte superiore della mia testa

Lua ...

1. supporta le coroutine
2. non ha restrizioni alla sola stringa / numero come chiave per una tabella. Tutto funziona.
3. la gestione degli errori è un po 'goffa. O non gestisci nulla o usi il metodo pcall
4. Penso di aver letto qualcosa sulle differenze nella portata lessicale e che Lua ha la migliore.
5. Se ricordo bene il supporto delle espressioni regolari in lua è limitato

Mi è piaciuta questa domanda e le risposte fornite. Ulteriori motivi per cui le due lingue sembrano più simili che non a me:

Entrambi assegnano funzioni alle variabili, possono creare funzioni al volo e definire chiusure.

Lua e JavaScript sono entrambi prototipi di linguaggi di base.

Un test rivela che l'attuale Javascript restituisce anche oggetti, o almeno stringhe da espressioni logiche come fa lua:

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