perbedaan halus antara JavaScript dan Lua [tertutup]

Saya sangat menyukai JavaScript. Ini sangat elegan (bayangkan suara tenang dari fanboy kekasih mendesah di latar belakang).

Jadi, baru-baru ini saya bermain dengan Lua melalui kerangka löve2d (bagus!) - dan menurut saya Lua juga hebat. Menurut saya, kedua bahasa itu sangat mirip.

Ada perbedaan yang jelas, seperti

• sintaksis
• domain masalah
• perpustakaan
• jenis (sedikit)

tetapi mana yang lebih halus? Apakah ada sesuatu yang akan diterima begitu saja oleh pembuat kode JavaScript yang bekerja di Lua hanya sedikit berbeda? Apakah ada kesulitan yang mungkin tidak terlihat jelas oleh pembuat kode berpengalaman dari satu bahasa yang mencoba bahasa lainnya?

Sebagai contoh: di Lua, array dan hash tidak terpisah (hanya ada tabel) - dalam JavaScript, mereka adalah Array numerik dan Objek yang di-hash. Nah, inilah salah satu perbedaan yang lebih jelas.

Tetapi apakah ada perbedaan dalam lingkup variabel, kekekalan atau sesuatu seperti ini?

Beberapa perbedaan lagi:

• Lua memiliki dukungan asli untuk coroutine .
  • UPDATE : JS sekarang berisi kata kunci hasil di dalam generator, memberikan dukungan untuk coroutine.
• Lua tidak mengkonversi antar tipe untuk operator pembanding manapun. Di JS, hanya ===dan !==jangan ketik juggle.
• Lua memiliki operator eksponen ( ^); JS tidak. JS menggunakan operator yang berbeda, termasuk operator kondisional terner ( ?:vs and/or), dan, sebagai 5,3, operator bitwise ( &, |, dll vs metamethods ).
  • UPDATE : JS sekarang memiliki operator eksponen **.
• JS memiliki increment / decrement, operator tipe ( typeofdan instanceof), operator penugasan tambahan, dan operator perbandingan tambahan.
• Di JS , yang ==, ===, !=dan !==operator dari diutamakan rendah dari >, >=, <, <=. Di Lua, semua operator pembanding memiliki prioritas yang sama .
• Lua mendukung panggilan ekor .
  • UPDATE : JS sekarang mendukung panggilan ekor .
• Lua mendukung penugasan ke daftar variabel . Meskipun belum standar dalam Javascript , mesin JS Mozilla (dan Opera, sampai batas tertentu) telah mendukung fitur serupa sejak JS 1.7 (tersedia sebagai bagian dari Firefox 2) dengan nama " tugas penghancuran ". Destrukturisasi di JS lebih umum, karena dapat digunakan dalam konteks selain tugas, seperti definisi & panggilan fungsi dan penginisialisasi loop . Tugas penghancuran telah menjadi tambahan yang diusulkan untuk ECMAScript (standar bahasa di belakang Javascript) untuk sementara waktu.
  • PEMBARUAN : Destrukturisasi (dan tugas penghancuran) sekarang menjadi bagian dari spesifikasi untuk ECMAScript - sudah diterapkan di banyak mesin.
• Di Lua , Anda dapat membebani operator .
• Di Lua , Anda bisa memanipulasi lingkungan dengan getfenvdansetfenv di Lua 5.1 atau _ENVdi Lua 5.2 dan 5.3 .
• Di JS , semua fungsi variadic. Dalam Lua , fungsi harus secara eksplisit dideklarasikan sebagai variadic .
• Foreachdi JS loop di atas properti objek. Foreach di Lua (yang menggunakan kata kunci for) melakukan loop di atas iterator dan lebih umum.
  • PEMBARUAN : Sekarang JS memiliki Iterabel , banyak di antaranya dibangun ke dalam struktur data reguler yang Anda harapkan, seperti Array. Ini dapat diulang dengan for...ofsintaks. Untuk Objek biasa, seseorang dapat mengimplementasikan fungsi iteratornya sendiri. Ini membuatnya lebih dekat dengan Lua.

• JS memiliki ruang lingkup global dan fungsi. Lua memiliki cakupan global dan blok . Struktur kontrol (misalnya if, for, while) memperkenalkan baru blok .

  • Karena perbedaan dalam aturan pelingkupan, referensi closure dari variabel luar (disebut "upvalues" dalam bahasa Lua) dapat ditangani secara berbeda di Lua dan Javascript . Hal ini paling sering dialami dengan penutupan dalam forloop , dan mengejutkan beberapa orang. Dalam Javascript , badan forperulangan tidak memperkenalkan ruang lingkup baru, jadi fungsi apa pun yang dideklarasikan dalam badan perulangan semuanya merujuk pada variabel luar yang sama . Dalam Lua, setiap iterasi dari forloop membuat variabel lokal baru untuk setiap variabel loop.

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

    Kode di atas sama dengan:

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

    Akibatnya, fungsi yang ditentukan dalam iterasi terpisah memiliki nilai naik yang berbeda untuk setiap variabel loop yang dirujuk. Lihat juga jawaban Nicolas Bola atas Pelaksanaan penutupan di Lua? dan " Apa semantik yang benar dari closure atas variabel loop? ", dan " Semantik Generik untuk ".

    UPDATE : JS memiliki cakupan blok sekarang. Variabel ditentukan dengan letatau mengikuti constlingkup blok.

• Literal integer di JS bisa dalam oktal.
• JS memiliki dukungan Unicode eksplisit, dan string internal dikodekan dalam UTF-16 (jadi itu adalah urutan pasangan byte). Berbagai fungsi JavaScript bawaan menggunakan data Unicode, seperti "pâté".toUpperCase()( "PÂTÉ"). Lua 5.3 dan yang lebih baru memiliki urutan pelolosan titik kode Unicode dalam string literal (dengan sintaks yang sama seperti urutan pelolosan titik kode JavaScript) serta utf8pustaka bawaan, yang menyediakan dukungan dasar untuk pengkodean UTF-8(seperti mengenkode poin kode ke dalam UTF-8 dan mendekode UTF-8 menjadi poin kode, mendapatkan jumlah poin kode dalam sebuah string, dan melakukan iterasi pada poin kode). String dalam Lua adalah urutan byte individu dan dapat berisi teks dalam pengkodean apa pun atau data biner sembarang. Lua tidak memiliki fungsi built-in yang menggunakan data Unicode; perilaku string.upperbergantung pada lokal C.
• Dalam Lua , yang not, or, andkata kunci yang digunakan di tempat JS 's !, ||, &&.
• Lua menggunakan ~=untuk "tidak sama", sedangkan JS menggunakan !==. Misalnya if foo ~= 20 then ... end,.
• Lua 5.3 dan up digunakan ~untuk XOR bitwise biner, sedangkan JS menggunakan ^.
• Dalam Lua , semua tipe nilai (kecuali nildan NaN) dapat digunakan untuk mengindeks sebuah tabel. Dalam JavaScript , semua jenis non-string (kecuali Simbol) diubah menjadi string sebelum digunakan untuk mengindeks objek. Sebagai contoh, setelah evaluasi kode berikut, nilai obj[1]akan "string one"di JavaScript, tetapi "number one"di Lua: obj = {}; obj[1] = "number one"; obj["1"] = "string one";.
• Di JS , penugasan diperlakukan sebagai ekspresi, tetapi di Lua tidak. Dengan demikian, JS memungkinkan tugas dalam kondisi if, whiledan do whilepernyataan, tapi Lua tidak di if, while, dan repeat untilpernyataan. Misalnya, if (x = 'a') {}adalah JS yang valid, tetapi if x = 'a' do endLua tidak valid.
• Lua memiliki sintaksis gula untuk mendeklarasikan variabel fungsi blok-scoped, fungsi yang bidang, dan metode ( local function() end, function t.fieldname() end, function t:methodname() end). JS mendeklarasikan ini dengan tanda sama dengan ( let funcname = function optionalFuncname() {}, objectname.fieldname = function () {}).

Beberapa perbedaan halus yang akan menarik perhatian Anda setidaknya satu kali:

• Tidak sama dilafalkan ~=dalam Lua. Di JS itu!=
• Lua array berbasis-1 - indeks pertamanya adalah 1, bukan 0.
• Lua membutuhkan titik dua daripada titik untuk memanggil metode objek. Anda menulis a:foo()alih-alih a.foo() ^†

^† Anda dapat menggunakan titik jika Anda mau, tetapi harus meneruskan selfvariabel secara eksplisit. a.foo(a)terlihat agak rumit. Lihat Pemrograman di Lua untuk detailnya.

Sejujurnya akan lebih mudah untuk membuat daftar hal-hal yang umum pada Javascript dan Lua daripada membuat daftar perbedaannya. Keduanya adalah bahasa skrip yang diketik secara dinamis, tetapi sejauh itu yang Anda bisa lakukan. Mereka memiliki sintaks yang sangat berbeda, tujuan desain asli yang berbeda, mode operasi yang berbeda (Lua selalu dikompilasi ke bytecode dan dijalankan pada Lua VM, Javascript bervariasi), daftarnya terus berlanjut.

Array dan objek JavaScript lebih dekat dari yang Anda kira. Anda dapat menggunakan notasi array untuk mendapatkan elemen dari salah satunya, dan Anda dapat menambahkan indeks non-numerik ke array. Elemen array individu bisa menampung apa saja, dan array bisa jarang. Mereka adalah sepupu yang hampir identik.

Dari atas kepala saya

Lua ...

1. mendukung coroutine
2. tidak memiliki batasan hanya string / angka sebagai kunci untuk tabel. Semuanya bekerja.
3. penanganan kesalahan agak kikuk. Entah Anda tidak menangani apa pun atau menggunakan metode pcall
4. Saya rasa saya membaca sesuatu tentang perbedaan dalam lingkup leksikal dan bahwa Lua memiliki yang lebih baik.
5. Jika saya ingat dengan benar dukungan ekspresi reguler di lua terbatas

Saya menyukai pertanyaan ini dan jawaban yang diberikan. Alasan tambahan mengapa kedua bahasa itu tampak lebih mirip bagi saya:

Keduanya menetapkan fungsi ke variabel, dapat membangun fungsi dengan cepat, dan menentukan closure.

Lua dan JavaScript adalah bahasa dasar prototipe.

Sebuah tes mengungkapkan bahwa Javascript saat ini juga mengembalikan objek, atau setidaknya string dari ekspresi logika seperti yang dilakukan lua:

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