Mi a Lua: a nyelv története, felépítése, valós felhasználási módjai és főbb jellemzői

Informatec Digital » Idiómák » Mi a Lua: a nyelv története, felépítése, valós felhasználási módjai és főbb jellemzői

A Lua egyike azoknak a nyelveknek, amelyek meglepően kiegyensúlyozottak : kicsi, gyors és alkalmazásokba ágyazható, mégis elég kifejező ahhoz, hogy több programozási stílust is lefedjen. Ha azon tűnődsz, hogy pontosan mi is ez, mire használják, és miért választják annyi eszközben, itt egy praktikus és jól dokumentált útmutató.

Mielőtt belemennénk a részletekbe, érdemes két kulcsfontosságú pontot tisztázni: a Luát 1993-ban hozták létre Brazíliában (PUC-Rio, TeCGraf csoport) azzal a céllal, hogy könnyű és bővíthető legyen, és az 5.0-s verzió óta MIT licenc alatt terjesztik (korábban BSD-szerű licenc). A végrehajtása nem értelmezi közvetlenül a forrásszöveget: bájtkódra fordul , és a saját virtuális gépében hajtja végre; ezen felül létezik a LuaJIT a futásidejű fordításhoz.

Mi a Lua és honnan származik?

A Lua portugálul „holdat” jelent , és Roberto Ierusalimschy, Luiz Henrique de Figueiredo és Waldemar Celes alkotta meg. A kezdetektől fogva egyértelmű volt a célja: egy beágyazható, hordozható és minimalista nyelv legyen , egyszerű, C ihlette szintaxissal és a Perlhez hasonló bővíthetőséggel. Az évek során videojátékok, bővítmények és beágyazott rendszerek szkriptmotorjává vált.

A kezdetektől fogva a hordozhatóság volt a fő szempont : ISO C nyelven implementálva gyakorlatilag bárhol fut, a nagy szerverektől kezdve a mindössze néhány száz kilobájt memóriával rendelkező mikrovezérlőkig. A korai verziók BSD-stílusú licenc alatt voltak licencelve, a Lua 5.0 óta pedig az MIT licencet használják , amely teljes mértékben GPL-kompatibilis.

Filozófia és dizájn: könnyű, süllyesztett és többparadigmás

A Lua „néhány, nagyon hatékony elemet” helyez előtérbe. Koncepcionális keretrendszere három pillérben foglalható össze : a táblázatok mint egyedüli adatstruktúra, a függvények első osztályú polgárokként, valamint a közös folyamatvezérléshez szükséges korutinok . Ezekkel az alapokkal a felhasználók egyéni modulokat, objektumokat, környezeteket és absztrakciókat hozhatnak létre .

Gyakran procedurálisnak írják le, de természetes módon alkalmaz funkcionális stílusokat (lezárások, magasabb szintű parancsok), objektumorientált megközelítéseket (metatáblákon és prototípusokon keresztül), valamint adatvezérelt megközelítést. Minimalizmusa nem jelent merevséget: a nyelv a viselkedés metatáblákon keresztüli újradefiniálásával bővül és alkalmazkodik.

Alapvető szintaxis és végrehajtás

A Lua-ban a változóknak nincsenek statikus típusaik ; az értékeikhez típus tartozik. Nyolc alaptípust biztosít : nil , boolean , number , string , table , function , userdata és thread (korutinok). Továbbá támogatja a számok és karakterláncok közötti szabályozott kényszerített műveletet futásidejűleg.

A nyelv szervezett darabok (kódrészletek), amelyeket a fordító anonim függvényekké alakít; ez segít magába foglalja az államot mostantól véletlenszerű „mágikus globálisak” nélkül fut. A megjegyzések vannak jelölve -- és támogatja a hosszú idézőjelekkel vagy zárójelekkel ellátott karakterlánc literálokat; operátorok beleértve az aritmetikai, relációs és rövidzárlatos logikát (and, or, not), összefűzés (..) és hossz (#).

Az áramlásszabályozással kapcsolatban, találtunk if/elseif/else, while, repeat until (legalább egyszer garantált karosszéria) és két változata for: numerikus (kezdettel, véggel és lépéssel) és generikus (iterátorok, mint például pairs o ipairs). A helyi nyilatkozatok korlátozza a lexikai terjedelmet és visszatérés több értéket is engedélyez.

Adattípusok és kényszerítés

A Lua tervezésénél fogva dinamikusan típusos . Az automatikus konverziók elsősorban karakterlánc és szám között történnek aritmetikai műveletekben vagy szöveges környezetekben. A feltételes utasítások csak a hamis és a nil értékeket tekintik hamisnak ; minden más igaz (beleértve a 0-t és az üres karakterláncot is).

A kulcsfontosságú adattípusok közé tartoznak a table (szótárak/asszociatív tömbök), function (első osztályú értékek), userdata (C memóriablokkok) és thread (korutinok). A táblák heterogének , bármilyen kulcstípust elfogadnak a nil kivételével , és összetett struktúrák, például listák, rekordok, fák és ritka tömbök alapját képezik.

Táblázatok és metatáblák: a nyelv lelke

A tábla az egyetlen adatstruktúra és mindenre használják: egy egyszerű tömbtől ({10,20,30}) katalógusokhoz, objektumokhoz, modulokhoz és környezetekhez. Hozzáférés a következőkhöz: t y t.x ekvivalens, ha a kulcs egy név. A zárójeles konstruktorok lehetővé teszik nagyon kompakt kifejezések az inicializálás.

Con metatáblák se újraértelmezni a viselkedéseket kezelők és hozzáférések: __add, __eq, __lt, __concat, __len, __index, __newindex, __callstb. Ez lehetővé teszi túlterhelés összeadás, összehasonlítás, összefűzés, vagy hogyan reagáljunk egy hiányzó mező elérésére, többek között. Így építhet komplex számok osztályai, proxyk, validatorok vagy wrapperek mindössze néhány sorral.

Modulok és környezetek

A funkció require betölt egy modult (egy chunk-ot, amely végrehajtáskor általában egy táblázatot ad vissza függvényekkel és konstansokkal). A Lua belsőleg függvényké fordítja a kódot, és végrehajtja azt a saját környezet, visszaadva az eredményét újrafelhasználásra. A globális változók egy táblázatban „élnek”, amelyek a következőképpen érhetők el: _G és modernebb változatokban a függvény látható környezetén keresztül (_KÖRNYEZET).

Ez az architektúra alacsonyan tartja a bináris fájlok méretét : ahelyett, hogy mindent betöltene, minden modul csak a szükségeseket teszi elérhetővé, és a fejlesztő dönti el, hogy mit tartalmazzon. A lexikai láthatóság és a környezetek elkülönítése minimalizálja a kódrészletek közötti mellékhatásokat.

Függvények, lezárások és chunkok

A Lua-ban egy függvény egy érték : változókhoz rendelődik, argumentumként átadódik, és eredményeként tér vissza. Nincs merev aritás: a plusz argumentumokat figyelmen kívül hagyja ; a hiányzó argumentumokat nil- lel tölti ki . Még a chunkokat is anonim függvényekként kezeli, így könnyen beágyazható a lokális állapot a globális környezet szennyezése nélkül.

Szintaktikus cukorként az operátor : (kettőspont) lehetővé teszi „metódusok” definiálását és meghívását a következőképpen: self hallgatólagosan: obj:metodo(x) egyenértékű obj.metodo(obj, x). A lezárások Felértékelődéseket rögzítenek, ami nagyon erős alapot jelent iterátorok, gyárak és tiszta API-k építéséhez.

Objektumorientáltság „a Lua módszerrel”

Bár nincsenek ilyen jellegű osztályai, A Lua táblázatok és metatáblák segítségével valósítja meg az OOP-t.A legelterjedtebb mintahasználatok __index Prototípusnak delegálás: Az objektumok tárolják az állapotukat és a metódusaikat a „sablonban” (a prototípus táblában) keresik ki. Egy konstruktor könnyen hozzárendelheti a metatáblát és új példányokat adhat vissza.

Kombinálás konstruktorok, __index és sugar:, egy pragmatikus OOP-t kapunk: metódusok a következővel: self, pszeudoöröklődés (láncolt prototípusok), felülírás lehetősége és rugalmas összetételEz egy egyszerű és nagyon hatékony megközelítés bővítményekhez, játékokhoz vagy konfigurációs szkriptekhez.

Korutinok: kooperatív multitasking

az korutinok Nagyon finom áramlásszabályozást kínálnak: lehetnek yield y resume meghatározott pontokon, így kímélve az akkumulátorukat. Úgy működnek, mint kooperatív többszálú feldolgozás, ideális játéklogikához, reaktív rendszerekhez, egyszerű tervezőkhöz vagy lusta iterátorokEzenkívül lehetővé teszik az elegáns váltást a Lua és a gazdakód (pl. C/C++) között.

Gyakorlati szempontból egy korutin addig fut, amíg le nem áll , értékeket ad vissza az újraindító személynek, majd onnan folytatja, ahol abbahagyta. Interaktív feladatokhoz, állapotalapú mesterséges intelligenciához vagy szimulációkhoz nagyon értékes eszköz az alacsony költsége és az áttekinthetősége miatt.

Standard könyvtárak és segédprogramok

A Lua egy kompakt, de nagyon hasznos szabványos könyvtárkészlettel rendelkezik: basic (assert, type, pairs, require…), string (patterns, gsub, gmatch, format), table (insert, remove, sort, concat), math (trigonometria, exponenciálisok, random), io (files), os (dates, environment, processes) és debug (hookok, trace-ek, inspection). Ezeket úgy tervezték, hogy a valós igények 80%-át lefedjék minimális helyigénnyel.

Rendszer húrmintákat hatékony keresést, rögzítést és cserét kínál teljes reguláris kifejezések használata nélkül; olyan funkciókkal, mint a gmatch o gsub A szövegfeldolgozás legtöbb tipikus esetét egyszerű módon oldják meg. tömör.

C/C++-ba ágyazva és integrációs API-ban

Az egyik erőssége az, hogy API C-benA házigazda létrehoz egy lua_State, betölti a darabokat (lua_load), függvényeket hív meg (lua_pcall védett), regiszterek végrehajtásához natív funkciók elérhető a Lua-ból, és adatokat mozgat át egy virtuális veremLéteznek segédprogramok a hibakezeléshez, a szemétgyűjtéshez, a metatáblákhoz és a „felhasználói adatokhoz”, amelyek felfedik a C-világ struktúráit.

Ez a kialakítás a Luát általános célú szkriptmotorrá teszi C/C++ alkalmazásokhoz: a logika a Luára van delegálva (könnyen iterálható és telepíthető), miközben megőrzi a natív kernel teljesítményét. Kis helyigénye (implementáció ~25 000 sor C kóddal és több száz KB-os binárisok) segít integrálni még szerényebb eszközökön is.

Lua az IoT-ben és a mikrovezérlőkben (ESP8266/NodeMCU)

A Lua nagyszerűen illeszkedik az IoT-hez az egyszerűsége és a gyors fejlesztési ciklusa miatt. NodeMCU ESP8266-hoz egy Lua-t futtató firmware-t kínál, és olyan eszközökkel, mint a Lua feltöltő o ESPlorer Feltölthetsz szkripteket, megnyithatsz egy konzolt, tesztelhetsz kódrészleteket és menet közben hibakereshetsz. A fájl init.lua általában indítsa el a logikát az eszköz állapotát (pl. LED villogtatása vagy GPIO konfigurálása).

La posibilidad de kódrészleteket fokozatosan hajt végre, anélkül, hogy mindent újra kellene fordítani, nagyon kényelmessé teszi a kísérletezést: változók deklarálása, egy print(a+b), kapcsolócsapok stb. Az Arduino-ból érkezők számára ez a folyamat a következő agilis és didaktikus, és gyakran apró változtatások is elegendőek ahhoz, hogy a szkripteket más kompatibilis eszközökre portolják.

Figyelemre méltó felhasználási módok videojátékokban és szoftverekben

Könnyű súlyának, teljesítményének és megengedő licencelésének köszönhetően a Lua kedvelt játékmotorok és modok terén. Olyan platformok, mint a Roblox , egy típusos változatot (Luau) népszerűsítettek; olyan címek és motorok, mint a World of Warcraft , a Garry's Mod sandbox játék (a Half-Life 2 alapján), az RTS Supreme Commander , a STALKER része , a LucasArts kalandjai, mint a Grim Fandango és az Escape from Monkey Island , a Worms 4: Mayhem , valamint olyan keretrendszerek, mint a LÖVE2D, bebizonyították erejét a kezelőfelület szkriptelése, a játéklogika és a modok terén.

Olyan MMO-kban és platformokon is megjelenik , mint a Tibia (széleskörű testreszabási lehetőségekkel az XML mellett), a Ragnarok Online (homunculus AI), szervereken és modokban, mint a Multi Theft Auto: San Andreas vagy a FiveM , játékokban, mint a Factorio (Lua-alapú modok), a Hedgewars , a Transformice , a Minetest (modok vagy teljes játékok létrehozása), a StepMania (animációk és parancsok), sőt olyan címekben is, mint a The Binding of Isaac: Rebirth (az Afterbirth+ DLC-hez Lua mod támogatás is járt).

Az eszközök és rendszerek birodalmában az olyan ablakkezelők , mint az Ion és az Awesome, a Lua-t használják konfigurációhoz és bővítéshez, míg az olyan alkalmazások, mint a REAPER , a Rockbox és a Renoise DAW szkripteléshez és mélyreható testreszabáshoz (egyéni API, OSC, MIDI, menük, lebegő ablakok, integrált terminál). Használták bemeneti adatok feldolgozására , alkalmazások konfigurálására, hardver vezérlésére és feladatok automatizálására is.

Teljesítmény, megvalósítás és szemétgyűjtés

A Lua bájtkódra fordul és egy hatékony virtuális gépen fut; igényes forgatókönyvekhez a LuaJIT futásidejű fordítást ad hozzá. A szemétgyűjtő inkrementális, flag-sweep , konfigurálható (szüneteltetés és lépésszorzó), és támogatja a véglegesítőket (__gc) a felhasználói adatokhoz és a gyenge táblákhoz (kulcsok/értékek, amelyek nem akadályozzák a memória felszabadítását).

A sebesség és a vezérelhetőség ezen kombinációja alacsony késleltetési szintet eredményez, amely elfogadható játékok, bővítmények és beágyazott rendszerek számára. Minimális helyigénye lehetővé teszi a nagyon korlátozott erőforrásokkal rendelkező eszközökön való telepítést anélkül, hogy a kifejezőképesség rovására menne.

Tervezési összehasonlítás és tanulás

A nehezebb nyelvekkel ellentétben a Lua a gazdaságosságot és az interoperabilitást helyezi előtérbe . Nem célja, hogy a Pythont vagy a JavaScriptet „teljes ökoszisztémaként” helyettesítse, hanem inkább az, hogy a legjobb választás legyen, amikor az egyszerűség, a hordozhatóság és a C nyelven való bővíthetőség kulcsfontosságú . A „Programming in Lua” című könyv és a technikai cikkek részletesen bemutatják azokat a döntéseket, amelyek elegáns kialakítását magyarázzák.

Akik Pascalból, C-ből vagy világos szintaxissal rendelkező nyelvekből származnak, azok sima belépési görbe: blokkok do ... end, olvasható feltételes utasítások, 20 jól definiált kulcsszó és a minta local mert korlátozza a mellékhatásokatA C-vel való „ragasztása” és a rugalmas táblaszemantika arra ösztönzi a felhasználókat, hogy csak a legszükségesebbeket építsék alulról felfelé.

Gyakori esetek és anekdoták

A hordozhatóság szempontjából egy Lua alkalmazás operációs rendszerek közötti migrálása általában minimális változtatásokat igényel. Konzolokon és eszközökön léteznek verziók PSP-re , Wii-re és SEGA Saturnra (speciális könyvtárakkal), és a házi készítésű közösségek az egyszerűsége miatt használják a Luát.

Privát szervereken és modokon (például a Tibia ) a Lua-t használják magas szintű rendszerek, szkriptek és bővítmények létrehozására. És ha olyan kreatív platformokon dolgozol, mint a Friday Night Funkin' , a Lua-t használják HUD-ok, moddiagramok és jelenetek dekorációinak módosítására, demonstrálva sokoldalúságát a dinamikus koreográfia terén.

Erősségek, amelyek magyarázzák a sikert

Könnyű és gyors : nagyon kis bináris fájlok, minimális memóriaigény és hatékony interpreter/virtuális gép. Erőforrás-korlátos eszközökön ez a takarékosság mindent eldönt.

Kiváló C API : a natív függvények regisztrálása és a struktúrák megjelenítése egyszerű. Összetett alkalmazások esetén, "hosztokká" konvertálva, a Lua ideális kapocs a natív kernel és a magas szintű logika között.

Többparadigmás és moduláris : táblázatok, metatáblák, függvények és korutinok segítségével pontosan azt építheted fel, amire szükséged van, se többet, se kevesebbet. Ez a jól átgondolt minimum elkerüli a felesleges bonyolultságot.

Közösség és dokumentáció : egy tömör referencia kézikönyv, számos példa és anyagok több nyelven (angol, spanyol, portugál). A „megértsük, hogyan működik” kultúra világos és robusztus kódot eredményez.

Szintaxis részletek és operátorok, amelyeket meg kell jegyezni

Logikai operátorok rövidzárlattal operandusokat adnak vissza (nem csak logikai értékeket): a and b y a or b nem logikai értékeket is visszaadhat, ami nagyon hasznos az alapértelmezett értékadásoknál (x = x or {}).

Összefűzés a következővel: .., hossz #-tal (karakterláncokban és „tömb típusú” táblázatokban), hatványozás ^-vel, és a C-hez hasonló precedensek olyan sajátosságokkal, mint a jobboldali asszociativitás a .. y ^. A lánc minták Kényelmes rögzítést és keresést kínálnak külső függőségek nélkül.

Miért választja ezt annyi motor és szerszám?

Mert csökkenti a tervezés és a végrehajtás közötti súrlódást : a Lua-ban történő iteráció gyors, a szkriptek könnyen terjeszthetők és auditálhatók, és a natív kernel védve van a gyakori változtatásoktól. Továbbá, mivel szabad szoftver, engedékeny licenccel , tökéletesen illeszkedik a kereskedelmi termékekbe és a közösségi projektekbe.

És van egy fontos kulturális tényező: a nyelv érthetősége ösztönzi a programozási koncepciók (magasabb rendű függvények, lezárások, iterátorok) elsajátítását, amelyeket aztán más környezetekben is alkalmazni lehet. Vegyes csapatok (tervezés, szkriptelés, motor) esetében ez felgyorsítja a szállítást a minőség feláldozása nélkül.

Miután megismerkedtünk a történetével, felépítésével és felhasználási módjaival, könnyű megérteni, miért érdemelt ki a Lua különleges helyet: egy kis nyelv, amely nagy dolgokat csinál . A videojátékoktól és a DAW-któl az IoT-ig és a lebegő ablakokig, a táblázatok és metatáblák, az első osztályú függvények és a korutinok kombinációja letisztult, moduláris és könnyen karbantartható megoldásokat eredményez. Ha megbízható szkriptmotort keres az alkalmazásaiba integráláshoz, vagy egyszerű automatizálási nyelvet a teljesítmény feláldozása nélkül, a Lua kivételes partner.