ความแตกต่างเล็กน้อยระหว่าง JavaScript และ Lua [ปิด]

ฉันชอบ JavaScript มันดูหรูหรามาก (ลองนึกภาพเสียงอันเงียบสงบของแฟนบอย lovestruck ที่กำลังถอนหายใจอยู่เบื้องหลัง)

เมื่อเร็ว ๆ นี้ฉันได้เล่นกับ Lua ผ่านlöve2d framework (ดีมาก!) - และฉันคิดว่า Lua ก็ยอดเยี่ยมเช่นกัน อย่างที่ฉันเห็นสองภาษานั้นคล้ายกันมาก

มีความแตกต่างที่ชัดเจนเช่น

• วากยสัมพันธ์
• โดเมนปัญหา
• ห้องสมุด
• ประเภท (บิต)

แต่อันไหนละเอียดกว่ากัน? มีอะไรที่ตัวเข้ารหัส JavaScript จะยอมรับว่าทำงานใน Lua แตกต่างกันเล็กน้อยหรือไม่? มีข้อผิดพลาดใด ๆ ที่อาจไม่ชัดเจนสำหรับผู้มีประสบการณ์ของภาษาหนึ่งที่พยายามใช้อีกภาษาหนึ่งหรือไม่?

ตัวอย่างเช่นใน Lua อาร์เรย์และแฮชจะไม่แยกจากกัน (มีเฉพาะตาราง) - ใน JavaScript เป็นอาร์เรย์ที่เป็นตัวเลขและวัตถุที่แฮช นี่คือหนึ่งในความแตกต่างที่ชัดเจนมากขึ้น

แต่มีความแตกต่างในขอบเขตตัวแปรไม่เปลี่ยนรูปหรืออะไรทำนองนี้?

ความแตกต่างเพิ่มเติม:

• Luaมีการสนับสนุนพื้นเมืองสำหรับcoroutines
  • อัปเดต : ขณะนี้ JS มีคีย์เวิร์ดผลตอบแทนในเครื่องกำเนิดไฟฟ้าซึ่งให้การสนับสนุนโครูทีน
• Lua ไม่แปลงระหว่างประเภทสำหรับตัวดำเนินการเปรียบเทียบใด ๆ ใน JS เท่านั้น===และ!==อย่าพิมพ์เล่นกล
• Luaมีตัวดำเนินการยกกำลัง ( ^); JSไม่ JSใช้ประกอบการที่แตกต่างกันรวมทั้งผู้ประกอบการที่มีเงื่อนไข ternary ( ?:VS and/or) และเป็น 5.3 ผู้ประกอบการระดับบิต ( &, |ฯลฯ กับmetamethods )
  • อัปเดต : JS มีตัวดำเนินการเลขชี้กำลัง**แล้ว
• JSมีการเพิ่ม / ลดตัวดำเนินการประเภท ( typeofและinstanceof) ตัวดำเนินการกำหนดเพิ่มเติมและตัวดำเนินการเปรียบเทียบเพิ่มเติม
• ในJSที่==, ===, !=และ!==ผู้ประกอบการที่มีความสำคัญต่ำกว่า>, >=, ,< <=ใน Lua ทั้งหมดดำเนินการเปรียบเทียบมีความสำคัญเช่นเดียวกัน
• Luaสนับสนุนโทรหาง
  • อัปเดต : JS รองรับการโทรหางแล้ว
• Luaสนับสนุนที่ได้รับมอบหมายไปยังรายการของตัวแปร แม้ว่าจะยังไม่เป็นมาตรฐานในJavascriptแต่ JS engine ของ Mozilla (และ Opera's ในระดับหนึ่ง) ได้สนับสนุนคุณลักษณะที่คล้ายกันตั้งแต่ JS 1.7 (พร้อมใช้งานเป็นส่วนหนึ่งของ Firefox 2) ภายใต้ชื่อ " การกำหนดโครงสร้างการทำลาย " Destructuring ใน JS เป็นทั่วไปมากขึ้นเท่าที่จะสามารถนำมาใช้ในบริบทอื่น ๆ นอกเหนือจากที่ได้รับมอบหมายเช่นคำจำกัดความของฟังก์ชั่นและการโทรและinitializers ห่วง การกำหนดโครงสร้างการทำลายเป็นข้อเสนอเพิ่มเติมสำหรับ ECMAScript (มาตรฐานภาษาที่อยู่เบื้องหลัง Javascript) เป็นระยะเวลาหนึ่ง
  • อัปเดต : ตอนนี้การทำลายโครงสร้าง (และการกำหนดโครงสร้างการทำลาย) เป็นส่วนหนึ่งของข้อมูลจำเพาะสำหรับ ECMAScript ซึ่งมีการใช้งานแล้วในหลายเครื่องยนต์
• ในLuaคุณสามารถโอเวอร์โหลดตัวดำเนินการได้
• ในLuaคุณสามารถจัดการกับสภาพแวดล้อมที่มีgetfenvและsetfenvใน Lua 5.1 หรือ_ENVในLua 5.2และ5.3
• ในJSฟังก์ชันทั้งหมดจะแปรผัน ในLua , ฟังก์ชั่นจะต้องมีการประกาศอย่างชัดเจนว่า variadic
• ForeachในJSลูปเหนือคุณสมบัติของวัตถุ ForeachในLua (ซึ่งใช้คีย์เวิร์ดfor) วนซ้ำบนตัวทำซ้ำและเป็นเรื่องทั่วไป
  • อัปเดต : ขณะนี้JS มีIterablesเช่นกันซึ่งหลาย ๆ อย่างสร้างขึ้นในโครงสร้างข้อมูลปกติที่คุณคาดหวังเช่นArray. สิ่งเหล่านี้สามารถวนซ้ำได้ด้วยfor...ofไวยากรณ์ สำหรับออบเจ็กต์ทั่วไปเราสามารถใช้ฟังก์ชันตัววนซ้ำของตัวเองได้ สิ่งนี้ทำให้ใกล้ชิดกับ Lua มากขึ้น

• JS มีขอบเขตทั่วโลกและฟังก์ชัน Luaมีทั่วโลกและบล็อกขอบเขต โครงสร้างการควบคุม (เช่นif, for, while) แนะนำใหม่บล็อก

  • เนื่องจากความแตกต่างในกฎระเบียบกำหนดขอบเขตอ้างอิงปิดของของตัวแปรด้านนอก (เรียกว่า "upvalues" ในการพูดจา Lua) อาจจะแตกต่างกันในการจัดการ Lua และJavascript สิ่งนี้มักเกิดขึ้นกับการปิดเป็นforลูปและดึงดูดบางคนด้วยความประหลาดใจ ในJavascriptเนื้อหาของforลูปจะไม่แนะนำขอบเขตใหม่ดังนั้นฟังก์ชันใด ๆ ที่ประกาศในเนื้อหาของลูปจึงอ้างอิงตัวแปรภายนอกที่เหมือนกันทั้งหมด ใน Lua การวนซ้ำแต่ละครั้งforจะสร้างตัวแปรโลคัลใหม่สำหรับตัวแปรลูปแต่ละตัว

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

    รหัสข้างต้นเทียบเท่ากับ:

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

    ด้วยเหตุนี้ฟังก์ชันที่กำหนดในการทำซ้ำแยกกันจึงมีการเพิ่มค่าที่แตกต่างกันสำหรับตัวแปรลูปที่อ้างอิงแต่ละตัว ดูคำตอบของ Nicolas Bola สำหรับการดำเนินการปิดใน Lua หรือไม่? และ " ความหมายที่ถูกต้องของการปิดทับตัวแปรลูปคืออะไร " และ " ความหมายของสามัญสำหรับ "

    UPDATE : JS มีขอบเขตบล็อกในขณะนี้ ตัวแปรที่กำหนดด้วยletหรือconstเคารพขอบเขตบล็อก

• ลิเทอรัลจำนวนเต็มในJSสามารถเป็นเลขฐานแปด
• JSมีการสนับสนุน Unicode อย่างชัดเจนและสตริงภายในถูกเข้ารหัสด้วยUTF-16 (ดังนั้นจึงเป็นลำดับของคู่ไบต์) ฟังก์ชัน JavaScript ในตัวต่างๆใช้ข้อมูล Unicode เช่น"pâté".toUpperCase()( "PÂTÉ") Lua 5.3ขึ้นไปมีลำดับการหลีกเลี่ยงจุดรหัส Unicode ในตัวอักษรสตริง (ที่มีไวยากรณ์เดียวกับลำดับการหลีกเลี่ยงจุดรหัส JavaScript) รวมทั้งutf8ไลบรารีในตัวซึ่งให้การสนับสนุนพื้นฐานสำหรับการเข้ารหัส UTF-8(เช่นการเข้ารหัสจุดรหัสลงใน UTF-8 และการถอดรหัส UTF-8 เป็นจุดรหัสการรับจำนวนจุดรหัสในสตริงและการทำซ้ำจุดรหัส) สตริงใน Lua เป็นลำดับของแต่ละไบต์และสามารถมีข้อความในการเข้ารหัสหรือข้อมูลไบนารีใดก็ได้ Lua ไม่มีฟังก์ชันในตัวที่ใช้ข้อมูล Unicode ลักษณะการทำงานstring.upperขึ้นอยู่กับภาษา C
• ในLuaที่not, or, andคำหลักที่มีการใช้ในสถานที่ของJS! 's ||, &&,
• Luaใช้~=สำหรับ "ไม่เท่ากัน" ขณะที่JS!==ใช้ ตัวอย่างเช่นif foo ~= 20 then ... end.
• Lua 5.3และการใช้งานขึ้น~สำหรับ XOR บิตไบนารีขณะJS^ใช้
• ในLuaสามารถใช้ค่าประเภทใดก็ได้ (ยกเว้นnilและNaN) เพื่อสร้างดัชนีตาราง ในJavaScriptประเภทที่ไม่ใช่สตริงทั้งหมด (ยกเว้น Symbol) จะถูกแปลงเป็นสตริงก่อนที่จะใช้ในการทำดัชนีวัตถุ ตัวอย่างเช่นหลังจากการประเมินผลของรหัสต่อไปนี้ค่าของการobj[1]จะเป็น"string one"ใน JavaScript แต่"number one"ใน obj = {}; obj[1] = "number one"; obj["1"] = "string one";Lua:
• ในJS การมอบหมายงานจะถือว่าเป็นนิพจน์ แต่ในLuaนั้นไม่ใช่ ดังนั้น JS ช่วยให้ได้รับมอบหมายในเงื่อนไขของif, whileและdo whileงบ แต่ Lua ไม่ได้ในif, whileและrepeat untilงบ ตัวอย่างเช่นif (x = 'a') {}เป็น JS ที่ถูกต้อง แต่if x = 'a' do endLua ไม่ถูกต้อง
• Luaมีน้ำตาลประโยคสำหรับประกาศบล็อกขอบเขตตัวแปรฟังก์ชั่นการทำงานที่มีเขตข้อมูลและวิธีการ ( local function() end, function t.fieldname() end, function t:methodname() end) JSประกาศสิ่งเหล่านี้ด้วยเครื่องหมายเท่ากับ ( let funcname = function optionalFuncname() {}, objectname.fieldname = function () {})

ความแตกต่างเล็กน้อยที่จะดึงดูดคุณอย่างน้อยหนึ่งครั้ง:

• สะกดไม่เท่ากัน~=ใน Lua ใน JS นั้นคือ!=
• อาร์เรย์ Lua เป็นแบบ 1 - ดัชนีแรกคือ 1 แทนที่จะเป็น 0
• Lua ต้องการเครื่องหมายจุดคู่แทนที่จะเป็นช่วงเวลาในการเรียก object method คุณเขียนa:foo()แทนa.foo() ^†

^†คุณสามารถใช้จุดได้หากต้องการ แต่ต้องส่งผ่านselfตัวแปรอย่างชัดเจน a.foo(a)ดูยุ่งยากเล็กน้อย ดูการเขียนโปรแกรมใน Luaสำหรับรายละเอียด

พูดตามตรงมันจะง่ายกว่าที่จะแสดงรายการสิ่งที่เป็นเรื่องธรรมดาของ Javascript และ Lua มากกว่าการแสดงความแตกต่าง ทั้งสองเป็นภาษาสคริปต์ที่พิมพ์แบบไดนามิก แต่นั่นก็เท่าที่คุณจะทำได้ พวกเขามีไวยากรณ์ที่แตกต่างกันโดยสิ้นเชิงเป้าหมายการออกแบบดั้งเดิมที่แตกต่างกันโหมดการทำงานที่แตกต่างกัน (Lua ถูกรวบรวมเป็น bytecode เสมอและทำงานบน Lua VM, Javascript แตกต่างกันไป) รายการจะดำเนินต่อไป

อาร์เรย์และวัตถุ JavaScript อยู่ใกล้กว่าที่คุณคิด คุณสามารถใช้สัญกรณ์อาร์เรย์เพื่อรับองค์ประกอบขององค์ประกอบใดองค์ประกอบหนึ่งและคุณสามารถเพิ่มดัชนีที่ไม่ใช่ตัวเลขให้กับอาร์เรย์ได้ องค์ประกอบอาร์เรย์แต่ละรายการสามารถเก็บอะไรก็ได้และอาร์เรย์สามารถเบาบาง พวกเขาเกือบจะเหมือนลูกพี่ลูกน้องกัน

ปิดด้านบนของหัวของฉัน

ลัวะ ...

1. รองรับcoroutines
2. ไม่มีข้อ จำกัด เพียงแค่สตริง / ตัวเลขเป็นกุญแจสำหรับตาราง ทุกอย่างใช้งานได้
3. การจัดการข้อผิดพลาดค่อนข้างเงอะงะ ไม่ว่าคุณจะไม่จัดการอะไรเลยหรือใช้วิธีpcall
4. ฉันคิดว่าฉันอ่านบางอย่างเกี่ยวกับความแตกต่างในขอบเขตคำศัพท์และ Lua มีสิ่งที่ดีกว่า
5. หากฉันจำได้ว่าการรองรับนิพจน์ทั่วไปใน lua ถูก จำกัด

ฉันชอบคำถามนี้และคำตอบที่ให้ไว้ เหตุผลเพิ่มเติมที่ทั้งสองภาษาดูเหมือนไม่เหมือนกันสำหรับฉัน:

ทั้งสองกำหนดฟังก์ชันให้กับตัวแปรสามารถสร้างฟังก์ชันได้ทันทีและกำหนดการปิด

Lua และ JavaScript เป็นภาษาพื้นฐานต้นแบบ

การทดสอบแสดงให้เห็นว่า Javascript ปัจจุบันยังส่งคืนอ็อบเจ็กต์หรืออย่างน้อยก็สตริงจากนิพจน์ตรรกะเช่น lua ทำ:

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