Ano ang Lua: kasaysayan, disenyo, paggamit sa totoong buhay, at mga pangunahing tampok ng wika

Informatec Digital » Mga wika » Ano ang Lua: kasaysayan, disenyo, paggamit sa totoong buhay, at mga pangunahing tampok ng wika

Ang Lua ay isa sa mga wikang nakakagulat sa balanse nito : maliit, mabilis, at idinisenyo upang maisama sa mga aplikasyon, ngunit sapat na nagpapahayag upang masakop ang maraming istilo ng programming. Kung nagtataka ka kung ano talaga ito, para saan ito ginagamit, at kung bakit napakaraming tool ang pumipili nito, narito ang isang praktikal at mahusay na dokumentadong gabay.

Bago tayo dumako sa mga detalye, mahalagang linawin ang dalawang mahahalagang punto: Ang Lua ay nilikha noong 1993 sa Brazil (PUC-Rio, TeCGraf group) na may layuning maging magaan at maaaring palawakin, at simula noong bersyon 5.0, ipinamahagi na ito sa ilalim ng lisensya ng MIT (dati, isang lisensyang parang BSD). Ang pagpapatupad nito ay hindi direktang binibigyang-kahulugan ang pinagmulang teksto: kino-compile ito sa bytecode at isinasagawa ito sa sarili nitong virtual machine; bilang karagdagan, mayroong LuaJIT para sa runtime compilation.

Ano ang Lua at saan ito nanggaling?

Ang Lua ay nangangahulugang "buwan" sa Portuges at nilikha nina Roberto Ierusalimschy, Luiz Henrique de Figueiredo, at Waldemar Celes. Napakalinaw ng pokus nito mula pa sa simula: ang maging isang embeddable, portable, at minimalist na wika , na may simpleng syntax na inspirasyon ng C at extensibility na katulad ng Perl. Sa paglipas ng mga taon, itinatag nito ang sarili bilang isang scripting engine para sa mga video game, plugin, at embedded system.

Mula sa umpisa nito, ang pagiging madaling dalhin ay isang pangunahing pokus : ipinapatupad sa ISO C , tumatakbo ito halos kahit saan, mula sa malalaking server hanggang sa mga microcontroller na may ilang daang kilobyte lamang ng memorya. Ang mga unang bersyon ay lisensyado sa ilalim ng lisensyang istilong BSD, at simula noong Lua 5.0, ginamit nila ang lisensya ng MIT , na ganap na sumusunod sa GPL.

Pilosopiya at disenyo: magaan, recessed at multi-paradigm

Inuuna ng Lua ang "kakaunti at napakalakas na mga piraso." Ang konseptwal na balangkas nito ay nakabuod sa tatlong haligi : mga talahanayan bilang nag-iisang istruktura ng datos, mga tungkulin bilang mga first-class citizen, at mga coroutine para sa collaborative flow control. Gamit ang mga pundasyong ito, maaaring bumuo ang mga gumagamit ng mga pasadyang module, object, environment, at abstraction .

Madalas itong inilalarawan bilang prosedural, ngunit natural lamang itong gumagamit ng mga istilo ng paggana (mga pagsasara, mga utos na mas mataas ang antas), mga pamamaraang nakatuon sa object (sa pamamagitan ng mga metatable at prototype), at isang pamamaraang nakabatay sa datos. Ang minimalismo nito ay hindi nagpapahiwatig ng pagiging matigas: ang wika ay lumalawak at umaangkop sa pamamagitan ng muling pagbibigay-kahulugan sa mga pag-uugali sa pamamagitan ng mga metatable.

Mahahalagang syntax at pagpapatupad

Sa Lua, ang mga variable ay walang mga static na uri ; ang kanilang mga halaga ay mga nakatalagang uri. Nagbibigay ito ng walong pangunahing uri : nil , boolean , number , string , table , function , userdata , at thread (coroutines). Bukod pa rito, sinusuportahan nito ang kontroladong pamimilit sa pagitan ng mga numero at string sa runtime.

Ang wika ay nakaayos sa mga chunks (mga piraso ng code) na binago ng compiler sa mga anonymous na function; nakakatulong ito i-encapsulate ang estado tumatakbo ngayon nang walang aksidenteng "magic globals". Ang mga komento ay minarkahan ng -- at sumusuporta sa mga literal na string na may mahabang quote o bracket; mga operator isama ang arithmetic, relational, short-circuit logic (and, or, not), pagsasama-sama (..) at haba (#).

Tungkol sa kontrol ng daloy, nahanap namin if/elseif/else, while, repeat until (ginagarantiya ng katawan kahit isang beses lang) at dalawang variant ng for: ayon sa numero (na may simula, wakas at hakbang) at generic (tulad ng mga iterator pairs o ipairs). Ang mga lokal na pahayag limitahan ang leksikal na saklaw at pagbabalik nagbibigay-daan sa maramihang mga halaga.

Mga uri ng data at pamimilit

Ayon sa disenyo, ang Lua ay dynamic na naka-type . Ang mga awtomatikong conversion ay pangunahing nangyayari sa pagitan ng string at numero sa mga operasyon sa aritmetika o konteksto ng teksto. Ang mga conditional statement ay itinuturing lamang ang false at nil bilang false ; lahat ng iba pa ay totoo (kabilang ang 0 at ang walang laman na string).

Kabilang sa mga pangunahing uri ng datos ang talahanayan (mga diksyunaryo/mga associative array), function (mga first-class value), userdata (mga C memory block), at thread (mga coroutine). Ang mga talahanayan ay heterogeneous , tumatanggap ng anumang uri ng susi maliban sa nil , at bumubuo ng batayan ng mga kumplikadong istruktura tulad ng mga listahan, talaan, puno, at sparse array.

Mga talahanayan at metatable: ang puso ng wika

Ang talahanayan ay ang tanging istraktura ng data at ginagamit para sa lahat: mula sa isang simpleng array ({10,20,30}) sa mga katalogo, bagay, module, at kapaligiran. Access sa t y t.x ay katumbas kapag ang susi ay isang pangalan. Pinapayagan ng mga konstruktor na may mga braces napaka compact na mga expression ng initialization.

may mga metatable se muling tukuyin ang mga pag-uugali ng mga operator at access: __add, __eq, __lt, __concat, __len, __index, __newindex, __call, atbp. Na nagbibigay-daan sobrang pasanin karagdagan, paghahambing, pagsasama-sama, o kung paano tumugon sa pag-access sa isang nawawalang field, bukod sa iba pa. Kaya, maaari kang bumuo mga klase ng kumplikadong numero, proxy, validator o wrapper na may ilang linya lang.

Mga module at kapaligiran

Ang pag-andar require naglo-load ng isang module (isang tipak na, kapag naisakatuparan, karaniwang nagbabalik ng mesa may mga function at constants). Sa panloob, kino-compile ni Lua ang code sa isang function at isinasagawa ito sa loob nito kapaligiran, ibinabalik ang resulta nito upang magamit muli. Ang mga pandaigdigang variable ay "live" sa isang talahanayan, naa-access bilang _G at, sa mas modernong mga bersyon, sa pamamagitan ng nakikitang kapaligiran ng function (_ENV).

Pinapanatili ng arkitekturang ito na maliit ang laki ng binary : sa halip na i-load ang lahat, inilalantad lamang ng bawat module kung ano ang kinakailangan, at ang developer ang magpapasya kung ano ang isasama. Binabawasan ng lexical visibility at paghihiwalay ng kapaligiran ang mga side effect sa pagitan ng mga piraso ng code.

Mga function, pagsasara at chunks

Sa Lua, ang isang function ay isang halaga : ito ay itinatalaga sa mga variable, ipinapasa bilang isang argumento, at ibinabalik bilang resulta. Walang matibay na arity: ang mga karagdagang argumento ay hindi pinapansin ; ang mga nawawalang argumento ay pinupuno ng zero . Kahit ang mga chunks ay itinuturing na mga anonymous function, na ginagawang madali ang pag-encapsulate ng lokal na estado nang hindi dinudumihan ang pandaigdigang kapaligiran.

Bilang syntactic asukal, ang operator : (colon) ay nagbibigay-daan sa iyo na tukuyin at tawagan ang "mga pamamaraan" sa pamamagitan ng pagpasa self implicitly: obj:metodo(x) katumbas obj.metodo(obj, x). Ang mga pagsasara Kinukuha nila ang mga upvalue, na isang napakalakas na batayan para sa pagbuo ng mga iterator, pabrika, at malinis na API.

Object-orientation "ang Lua way"

Bagama't wala itong klase, Ipinapatupad ni Lua ang OOP gamit ang mga talahanayan at metatableAng pinaka-kalat na ginagamit na pattern __index Upang magtalaga sa isang prototype: Iniimbak ng mga bagay ang kanilang estado at hanapin ang kanilang mga pamamaraan sa "template" (ang talahanayan ng prototype). Ang isang constructor ay madaling magtalaga ng metatable at magbalik ng mga bagong pagkakataon.

Pinagsasama mga konstruktor, __index at asukal:, isang pragmatikong OOP ang nakuha: mga pamamaraan na may self, pseudoinheritance (chained prototypes), posibilidad ng overwriting at nababaluktot na komposisyon. Isa itong simple at napakaepektibong diskarte para sa mga plugin, laro, o mga script ng configuration.

Coroutines: cooperative multitasking

ang mga coroutine Nag-aalok sila ng napakahusay na kontrol sa daloy: maaari silang maging yield y resume sa mga partikular na punto, pinapanatili ang kanilang baterya. Nagtatrabaho sila bilang kooperatiba na multi-threading, perpekto para sa logic ng laro, reaktibong sistema, simpleng tagaplano o mga tamad na iterator. Bukod pa rito, pinapayagan nila ang eleganteng paglipat sa pagitan ng Lua at host code (hal., C/C++).

Sa praktikal na termino, ang isang coroutine ay tumatakbo hanggang sa matapos ito , na nagbabalik ng mga halaga sa taong nag-restart nito, at pagkatapos ay nagpapatuloy kung saan ito tumigil. Para sa mga interactive na gawain, stateful AI, o mga simulation, ito ay isang napakahalagang tool dahil sa mababang gastos at kalinawan nito.

Mga Karaniwang Aklatan at Utility

Ang Lua ay may kasamang maliit ngunit kapaki-pakinabang na hanay ng mga karaniwang aklatan: basic (assert, type, pairs, require…), string (patterns, gsub, gmatch, format), table (insert, remove, sort, concat), math (trigonometry, exponentials, random), io (files), os (dates, environment, processes), at debug (hooks, traces, inspection). Ang mga ito ay dinisenyo upang masakop ang 80% ng mga pangangailangan sa totoong mundo na may kaunting bakas ng paa.

Sistema mga pattern ng string nag-aalok ng mahusay na paghahanap, pagkuha, at pagpapalit nang hindi gumagamit ng ganap na regular na mga expression; na may mga tampok tulad ng gmatch o gsub Karamihan sa mga tipikal na kaso ng pagpoproseso ng teksto ay nalutas sa simpleng paraan. maikli.

Naka-embed sa C/C++ at integration API

Ang isa sa mga malakas na punto ay ang nito API sa C. Lumilikha ang host ng a lua_State, mag-load ng mga tipak (lua_load), humihingi ng mga function (lua_pcall upang maisagawa ang protektado), mga rehistro katutubong pag-andar naa-access mula sa Lua at naglilipat ng data sa isang virtual stackMay mga kagamitan para sa paghawak ng error, pagkolekta ng basura, mga metatable, at "data ng gumagamit" na naglalantad sa mga istruktura ng C-world.

Dahil sa disenyong ito, ang Lua ay isang pangkalahatang-gamit na scripting engine para sa mga aplikasyon ng C/C++: ang lohika ay itinatalaga sa Lua (madaling i-iterate at i-deploy) habang pinapanatili ang pagganap ng katutubong kernel. Ang maliit nitong footprint (implementasyon na ~25.000 linya ng C at binaries sa daan-daang KB) ay nakakatulong na maisama ito kahit sa mga simpleng device.

Lua sa IoT at microcontrollers (ESP8266/NodeMCU)

Ang Lua ay isang mahusay na akma para sa IoT dahil sa pagiging simple nito at mabilis na ikot ng pag-unlad. NodeMCU para sa ESP8266 nag-aalok ng firmware na nagpapatakbo ng Lua, at may mga tool tulad ng Lua Uploader o ESPlorer Maaari kang mag-upload ng mga script, magbukas ng console, mga snippet ng pagsubok, at mag-debug kaagad. Ang file init.lua kadalasan simulan ang lohika ng device (hal. pag-blink ng LED o pag-configure ng GPIO).

Ang posibilidad ng unti-unting isagawa ang mga bahagi ng code, nang hindi muling kino-compile ang lahat, ginagawang napakakomportableng mag-eksperimento: magdeklara ng mga variable, gumawa ng a print(a+b), toggle pin, atbp. Para sa mga nagmumula sa Arduino, ang daloy na ito ay maliksi at didactic, at kadalasan ay sapat na ang maliliit na pagbabago upang mai-port ang mga script sa iba pang mga katugmang device.

Mga kilalang gamit sa mga video game at software

Dahil sa magaan nitong katangian, pagganap, at mapagpahintulot na paglilisensya , ang Lua ay paborito sa mga engine at mod. Ang mga platform tulad ng Roblox ay nag-promote ng isang typed variant (Luau); ang mga titulo at engine tulad ng World of Warcraft , ang sandbox game na Garry's Mod (batay sa Half-Life 2), ang RTS Supreme Commander , bahagi ng STALKER , ang mga pakikipagsapalaran ng LucasArts tulad ng Grim Fandango at Escape from Monkey Island , Worms 4: Mayhem , at ang mga framework tulad ng LÖVE2D ay nagpakita ng kapangyarihan nito para sa interface scripting, game logic, at mga mod.

Lumalabas din ito sa mga MMO at plataporma tulad ng Tibia (na may malawak na pagpapasadya kasama ng XML), Ragnarok Online (homunculus AI), mga server at mod tulad ng Multi Theft Auto: San Andreas o FiveM , mga laro tulad ng Factorio (mga mod na nakabatay sa Lua), Hedgewars , Transformice , Minetest (lumikha ng mga mod o buong laro), StepMania (mga animation at command), at maging sa mga titulo tulad ng The Binding of Isaac: Rebirth (dinagdagan ng DLC ​​Afterbirth+ ng suporta sa Lua mod).

Sa larangan ng mga tool at system, ang mga window manager tulad ng Ion at Awesome ay gumagamit ng Lua para sa configuration at extension, habang ang mga application tulad ng REAPER , Rockbox , at Renoise DAW ay ginagamit ito para sa scripting at deep customization (custom API, OSC, MIDI, menus, floating windows, integrated terminal). Ginagamit din ito upang iproseso ang input data , i-configure ang mga application, kontrolin ang hardware, at i-automate ang mga gawain.

Pagganap, pagpapatupad, at pagkolekta ng basura

Nagko-compile ang Lua sa bytecode at tumatakbo sa isang mahusay na VM; para sa mga mahihirap na senaryo, nagdaragdag ang LuaJIT ng runtime compilation. Ang garbage collector ay incremental, flag-sweep , configurable (pause at step multiplier), at sumusuporta sa mga finalizer (__gc) para sa data ng user at mga weak table (mga key/value na hindi pumipigil sa memory release).

Ang kombinasyon ng bilis at kontrol ay nagreresulta sa mababang antas ng latency na katanggap-tanggap para sa mga laro, plugin, at mga naka-embed na system. Ang minimal na footprint nito ay nagbibigay-daan sa pag-deploy sa mga device na may limitadong resources nang hindi isinasakripisyo ang mga kakayahang magpahayag.

Paghahambing at pag-aaral ng disenyo

Hindi tulad ng mas mabibigat na wika, inuuna ng Lua ang ekonomiya at interoperability . Hindi nito nilalayon na palitan ang Python o JavaScript bilang isang "kabuuang ecosystem," kundi maging ang pinakamahusay na opsyon kapag ang pagiging simple, portability, at extensibility sa C ang susi . Ang aklat na Programming in Lua at mga teknikal na artikulo ay sumisiyasat sa mga desisyong nagpapaliwanag sa eleganteng disenyo nito.

Ang mga nagmula sa Pascal, C o mga wika na may malinaw na syntax ay hinahanap isang makinis na kurba ng pagpasok: mga bloke na may do ... end, nababasang mga kondisyon, 20 mahusay na tinukoy na mga keyword, at ang pattern local para limitahan ang mga epektoAng "glue" nito na may C at flexible table semantics ay naghihikayat sa pagbuo mula sa ibaba pataas lamang kung ano ang kinakailangan.

Madalas na mga kaso at anekdota

Sa usapin ng kadalian sa paglipat, ang paglipat ng isang Lua app sa pagitan ng mga operating system ay karaniwang nangangailangan ng kaunting pagbabago. Sa mga console at device, may mga build para sa PSP , Wii , at SEGA Saturn (na may mga partikular na library), at ginamit ng mga komunidad ng homebrew ang Lua dahil sa pagiging simple nito.

Sa mga pribadong server at mod (halimbawa, Tibia ), ginagamit ng mga tao ang Lua upang lumikha ng mga high-level na sistema, script, at extension . At kung nagtatrabaho ka sa mga malikhaing platform tulad ng Friday Night Funkin' , ginagamit ang Lua upang baguhin ang mga HUD, modchart , at mga dekorasyon ng eksena, na nagpapakita ng kakayahang umangkop nito para sa dynamic na koreograpiya.

Mga lakas na nagpapaliwanag ng tagumpay nito

Magaan at mabilis : napakaliit na binary, kaunting konsumo ng memorya, at mahusay na interpreter/VM. Sa mga device na limitado ang resource, ang pagtitipid na ito ang may malaking papel.

Napakahusay na C API : ang pagrehistro ng mga katutubong function at paglalantad ng mga istruktura ay madali. Para sa mga kumplikadong app, na ginawang "hosts," ang Lua ang mainam na pandikit sa pagitan ng katutubong kernel at high-level na lohika.

Multi-paradigm at modular : gamit ang mga table, meta-table, function, at coroutine, bubuuin mo nang eksakto kung ano ang kailangan mo, walang sobra, walang kulang. Ang pinag-isipang minimum na ito ay nakakaiwas sa hindi kinakailangang komplikasyon.

Komunidad at dokumentasyon : isang maigsi at sangguniang manwal, maraming halimbawa, at mga materyales sa iba't ibang wika (Ingles, Espanyol, Portuges). Ang kulturang "unawain kung paano ito gumagana" ay isinasalin sa malinaw at matatag na code.

Mga detalye ng syntax at mga operator na dapat tandaan

Mga lohikal na operator na may maikling circuit na nagbabalik ng mga operand (hindi lamang mga boolean): a and b y a or b maaaring magbalik ng mga hindi boolean na halaga, lubhang kapaki-pakinabang para sa mga default na takdang-aralin (x = x or {}).

Pagsasama sa .., haba na may # (sa mga string at sa "array-type" na mga talahanayan), exponentiation na may ^, at mga nauunang katulad sa C na may mga partikularidad tulad ng tamang pagkakaugnay sa .. y ^. Ang mga pattern ng chain Nag-aalok sila ng maginhawang pagkuha at paghahanap nang walang mga panlabas na dependency.

Bakit pinipili ito ng napakaraming makina at kasangkapan?

Dahil binabawasan nito ang alitan sa pagitan ng disenyo at pagpapatupad : mabilis ang pag-iterate sa Lua, madaling ipamahagi at i-audit ang mga script, at protektado ang katutubong kernel mula sa mga madalas na pagbabago. Bukod pa rito, bilang libreng software na may lisensyang nagpapahintulot , perpektong akma ito sa mga komersyal na produkto at mga proyekto ng komunidad.

At mayroong isang mahalagang salik sa kultura: ang kalinawan ng wika ay naghihikayat sa pag-aaral ng mga konsepto ng programming (mga higher-order function, closure, iterator) na maaaring ilapat sa ibang mga kapaligiran. Para sa mga halo-halong pangkat (disenyo, scripting, engine), pinapabilis nito ang mga paghahatid nang hindi isinasakripisyo ang kalidad.

Matapos tuklasin ang kasaysayan, disenyo, at gamit nito, madaling maunawaan kung bakit nakakuha ng espesyal na lugar ang Lua: isang maliit na wika na gumagawa ng malalaking bagay . Mula sa mga video game at DAW hanggang sa IoT at mga floating windows, ang kombinasyon nito ng mga table at metatable, mga primera klaseng function, at mga coroutine ay nagreresulta sa malinis, modular, at madaling mapanatiling solusyon. Kung naghahanap ka ng isang maaasahang scripting engine na maisasama sa iyong mga application o isang simpleng wika para sa automation nang hindi isinasakripisyo ang lakas, ang Lua ay isang pambihirang kasosyo.