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

Harap » 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 mai-embed sa mga application, ngunit sapat na nagpapahayag upang masakop ang maraming istilo ng programming. Kung iniisip mo kung ano ba talaga ito, para saan ito ginagamit, at kung bakit pinipili ito ng napakaraming tool, narito ang isang praktikal at mahusay na dokumentado na gabay.

Bago pumasok sa paksa, ito ay nagkakahalaga ng pag-highlight ng dalawang pangunahing ideya: Ipinanganak si Lua noong 1993 sa Brazil (PUC-Rio, grupong TeCGraf) na may layuning maging magaan at mapalawak, at mula noong bersyon 5.0 ito ay ipinamamahagi sa ilalim ng Lisensya ng MIT (dating lisensyang BSD-type). Ang pagpapatupad nito ay hindi direktang binibigyang kahulugan ang pinagmulang teksto: nag-compile sa bytecode at pinapatakbo ito sa sarili nitong virtual machine; bilang karagdagan, mayroon LuaJIT para sa runtime compilation.

Ano ang Lua at saan ito nanggaling?

Ang ibig sabihin ng Lua ay "buwan" sa Portuguese at nilikha nina Roberto Ierusalimschy, Luiz Henrique de Figueiredo, at Waldemar Celes. Ang pokus nito ay napakalinaw mula sa simula: maging isang embeddable, portable at minimalist na wika, na may simpleng syntax na inspirasyon ng C at mga ideyang katulad ng Perl sa mga tuntunin ng pagpapalawak. Sa paglipas ng mga taon, itinatag nito ang sarili bilang isang scripting engine para sa mga video game, plugin, at mga naka-embed na system.

Mula sa pinagmulan nito, Ang kakayahang dalhin ay isang kinahuhumalingan: ipinatupad sa ISO C, ay tumatakbo kahit saan, mula sa malalaking server hanggang sa mga microcontroller na may ilang daang kilobytes lamang ng memorya. Ang mga naunang bersyon ay lisensyado sa ilalim ng lisensyang BSD-style, at Simula sa Lua 5.0, ginagamit nila ang MIT, ganap na tugma sa GPL.

Pilosopiya at disenyo: magaan, recessed at multi-paradigm

Pinipili ni Lua ang "kaunti, napakalakas na piraso." Ang konseptong pagkarga nito ay ibinubuod sa tatlong haligi: ang boards bilang ang tanging istraktura ng data, ang mga function bilang mga first-class na mamamayan at mga coroutine para sa kontrol ng daloy ng kooperatiba. Gamit ang mga base na ito, ang user mismo ay makakaangat mga module, bagay, kapaligiran at abstraction pinasadya

Madalas itong inilarawan bilang pamamaraan, ngunit natural na nagpapatibay mga functional na istilo (mga pagsasara, mas mataas na pagkakasunud-sunod), object-orientation (sa pamamagitan ng mga metatable at prototype) at diskarte na nakatuon sa data. Ang minimalism nito Hindi ito nagpapahiwatig ng katigasan: ang wika ay lumalawak at humuhubog sa pamamagitan ng muling pagtukoy ng mga pag-uugali sa pamamagitan ng mga metatable.

Mahahalagang syntax at pagpapatupad

Sa Lua, ang mga variable ay walang mga static na uri; ang uri ay taglay ng mga halaga. Mayroon itong walong pangunahing uri: kawalan, boolean, numero, pisi, mesa, tungkulin, data ng gumagamit y sinulid (coroutines). Bilang karagdagan, umamin ng kontroladong pamimilit sa pagitan ng mga numero at mga 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

Sa pamamagitan ng disenyo, Ang Lua ay dynamic na na-typePangunahing nagaganap ang mga awtomatikong conversion sa pagitan ng pisi y numero sa mga operasyong aritmetika o konteksto ng teksto. Isinasaalang-alang lamang ang mga kondisyon 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 ang: mesa (mga diksyonaryo/nag-uugnay na array), tungkulin (mga halaga ng unang klase), data ng gumagamit (C memory blocks) at sinulid (coroutines). Ang mga talahanayan ay magkakaiba, sinusuportahan nila ang anumang uri ng key maliban sa kawalan at bumubuo ng batayan ng mga kumplikadong istruktura tulad ng mga listahan, talaan, puno o kalat-kalat na matrice.

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).

Ang arkitektura na ito ay gumagawa nananatiling maliit ang binary size: Sa halip na i-load ang lahat, ang bawat module ay naglalantad lamang ng sapat at ang developer ang magpapasya kung ano ang isasama. Lexical visibility at ang paghihiwalay ng mga kapaligiran ay nagpapaliit ng mga side effect sa pagitan ng mga piraso ng code.

Mga function, pagsasara at chunks

Sa Lua, ang isang function ay isang halaga: itinalaga sa mga variable, ipinasa bilang argumento, at ibinalik bilang resulta. Walang mahigpit na arity: Kung mayroong masyadong maraming mga argumento, sila ay hindi pinapansin; kung sila ay nawawala, sila ay napuno ng kawalan. Kahit na ang mga tipak ay itinuturing bilang mga hindi kilalang function, na ginagawang madali i-encapsulate ang mga lokal na estado nang hindi nadudumihan 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, umuusad ang isang coroutine hanggang sa ito ay magbunga, nagbabalik ng mga halaga sa sinumang nagpatuloy nito, at sa paglaon ay nagpapatuloy sa mismong lugar kung saan ito tumigil. Para sa mga interactive na gawain, state-based AI, o simulation, ito ay isang napakahalagang tool dahil dito mababang gastos at kalinawan.

Mga Karaniwang Aklatan at Utility

Ang Lua ay may kasamang compact ngunit napakakapaki-pakinabang na hanay ng mga karaniwang aklatan: batayan (igiit, uri, pares, kailangan...), pisi (mga pattern, gsub, gmatch, format), mesa (ipasok, alisin, pag-uri-uriin, pagdugtong), matematika (trigonometry, exponentials, random), io (mga file), os (mga petsa, kapaligiran, mga proseso) at mag-alis ng mga insekto (mga kawit, bakas, inspeksyon). Idinisenyo ang mga ito upang masakop ang 80% ng mga tunay na pangangailangan minimal na 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.

Ginagawa nitong disenyo si Lua a general-purpose scripting engine para sa mga C/C++ na application: ang logic ay itinalaga kay Lua (madaling umulit at i-deploy) habang pinapanatili ang pagganap ng native core. Ang maliit na footprint (~25.000 C lines na pagpapatupad at mga binary sa pagkakasunud-sunod ng daan-daang KB) ay nakakatulong na isama ito kahit na sa mga katamtamang 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

Salamat sa iyong kagaanan, pagganap at permissive na lisensya, Paborito si Lua sa mga makina at mod. Mga platform tulad ng Roblox Nag-promote sila ng isang tipikal na variant (Luau); mga pamagat at engine tulad ng World of Warcraft, ang sandbox Garry's Mod (tungkol sa Half-Life 2), ang RTS Supreme Commander, bahagi de STALKER, LucasArts pakikipagsapalaran tulad ng Grim Fandango y Ang Pagtakas mula sa Monkey Island, Worms 4: Labanan, o mga balangkas tulad ng LÖVE2D ay nagpakita ng kanilang kapangyarihan sa mga script ng interface, lohika ng laro at mga mod.

Lumilitaw din sa Mga MMO at platform bilang lulod (na may malawak na pagpapasadya kasama ng XML), ragnarok online (Homunculus AI), mga server at uri ng mod Multi Theft Auto: San Andreas o LimangM, mga laro tulad ng Factorio (Mga mod na nakabatay sa Lua), Mga Hedgewar, Pagbabago, Pinakamababa (lumikha ng mga mod o buong laro), StepMania (mga animation at utos), at maging sa mga pamagat tulad ng Ang Pagbubuklod ni Isaac: muling pagsilang (Idinagdag ng Afterbirth+ DLC ang suporta sa Lua mod.)

Sa larangan ng mga kasangkapan at sistema, window manager bilang Ion y Kahanga-hangang gamitin ang Lua upang i-configure at i-extend, habang gusto ng mga application REAPER, Rockbox o ang DAW renoise Sinasamantala nila ito para mga script at malalim na pagpapasadya (sariling API, OSC, MIDI, mga menu, mga lumulutang na bintana, pinagsamang terminal). Ginamit din ito para sa iproseso ang data ng input, i-configure ang mga application, kontrolin ang hardware at i-automate ang mga gawain.

Pagganap, pagpapatupad, at pagkolekta ng basura

Nag-compile si Lua sa bytecode at tumatakbo sa isang mahusay na VM; para sa mahirap na mga senaryo, LuaJIT nagdaragdag ng runtime compilation. Ang basurero ay incremental mark-sweep type, configurable (pause at step multiplier) at mga suporta mga finalizer (__gc) para data ng gumagamit y mahihinang mga mesa (mga susi/halaga na hindi pumipigil sa memorya na mapalaya).

Ang kumbinasyong ito ng bilis at kontrol Isinasalin ito sa mga katanggap-tanggap na mababang latency para sa mga laro, plugin, at mga naka-embed na system. Ang kaunting bakas ng paa ay nagbibigay-daan dito na mai-deploy sa mga device na may napaka-limitadong mapagkukunan nang hindi sumusuko sa nagpapahayag na wika.

Paghahambing at pag-aaral ng disenyo

Hindi tulad ng mas mabibigat na wika, Inuuna ni Lua ang ekonomiya at interoperability. Hindi ito nilayon na palitan ang Python o JavaScript bilang isang "kabuuang ecosystem", ngunit sa halip ay maging pinakamahusay na pagpipilian kung kailan Nagbibigay ang mga ito ng pagiging simple, portable at extensibility sa C. Ang libro Programming sa Lua at ang mga teknikal na artikulo ay sumasalamin sa mga desisyon na 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 portable, Mag-migrate ng Lua app sa pagitan ng mga operating system karaniwang nangangailangan ng kaunting pagbabago. Sa mga console at device, may mga build para sa PSP, Wii o SEGA Saturn (na may mga partikular na aklatan), at mga homebrew na komunidad na gumamit ng Lua para dito pagiging simple.

Sa mga pribadong server at mod (hal., lulod), ginagamit ng mga tao ang Lua para sa lumikha ng mga system, script at extension mataas na antas. At kung lumipat ka sa mga malikhaing platform tulad ng Biyernes ng gabi funkin ', Ginagamit si Lua upang baguhin ang mga HUD, modcharts at mga dekorasyon ng eksena, na nagpapakita kung gaano ito kagaling mga dinamikong koreograpiya.

Mga lakas na nagpapaliwanag ng tagumpay nito

Ang gaan at bilis: napakaliit na binary, katamtamang paggamit ng memorya, at isang mahusay na interpreter/VM. Sa mga resource-constrained device, ang pagtitipid na ito ay gumagawa ng lahat ng pagkakaiba.

Napakahusay na C API: Ang pagrerehistro ng mga katutubong function at paglalantad ng mga istruktura ay diretso. Para sa mga kumplikadong, host-based na apps, si Lua ay ang perpektong pandikit sa pagitan ng katutubong core at mataas na antas na lohika.

Multiparadigm at modular: Gamit ang mga talahanayan, metatable, function at coroutine, bubuo ka ng kailangan mo, hindi hihigit at hindi bababa. yun well thought out minimum iwasan ang mga hindi kinakailangang gulong.

Komunidad at dokumentasyon: Maikling reference manual, mayaman sa mga halimbawa, at multilinggwal na materyal (Ingles, Espanyol, Portuges). Ang kultura ng "pag-unawa 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 sa binabawasan ang alitan sa pagitan ng disenyo at pagpapatupad: Ang pag-ulit sa Lua ay mabilis, ang mga script ay madaling ipamahagi at i-audit, at ang native na core ay protektado mula sa mga madalas na pagbabago. Higit pa rito, pagiging libreng software na may permissive na lisensya, perpektong akma sa mga komersyal na produkto at proyekto ng komunidad.

At mayroong isang mahalagang kadahilanan sa kultura: ang kalinawan ng wika Hinihikayat nito ang pag-aaral ng mga konsepto ng programming (mga function na mas mataas ang pagkakasunud-sunod, pagsasara, iterator) na pagkatapos ay inilapat sa iba pang mga kapaligiran. Para sa mga mixed team (design, scripting, engine), ito nagpapabilis ng paghahatid nang hindi isinakripisyo ang kalidad.

Pagkatapos suriin ang kasaysayan, disenyo at paggamit nito, madaling maunawaan kung bakit nakakuha si Lua ng isang espesyal na lugar: isang maliit na wika na gumagawa ng malalaking bagayMula sa mga video game at DAW hanggang sa IoT at mga floating window, ang kumbinasyon nito ng mga talahanayan at metatable, mga first-class na function, at coroutine ay nagreresulta sa malinis, modular, at mabilis na pagpapanatiling mga solusyon. Naghahanap ka man ng maaasahang scripting engine na isasama sa iyong mga application o isang simpleng wika para sa automation nang hindi sinasakripisyo ang kapangyarihan, si Lua ay isang pambihirang kasama.