Lua

Lua
Nyelvóra funkcionális programozási nyelv , objektumorientált programozási nyelv , szkriptnyelv , többparadigmás programozási nyelv , kötelező programozási nyelv , procedurális programozási nyelv , prototípus-orientált programozási nyelv [d] , értelmezett programozási nyelv , fordított programozási nyelv , szabad szoftver és fájlformátum
Megjelent 1993 [2]
Szerző Roberto Jeruzalimski ,
Valdemar Selish,
Luis Enrique de Figueiredo
Fejlesztő Robert Jeruzalimsky [1]
Fájlkiterjesztés _ .lua[3] [4] ,.luna,.lunairevagy.anair
Kiadás 5.4.4 (2022. január 26.)
Típusrendszer dinamikus , erős , kacsa
Befolyásolva C++ , Clu , Simple Object Language [d] , DEL , Snobol , Modula , Modula-2 and Scheme
befolyásolta JavaScript
Engedély MIT engedély [5] [6]
Weboldal lua.org ​(  angol) ​(  port)
OS többplatformos [7]
 Médiafájlok a Wikimedia Commons oldalon

A Lua ( lua ,  port.  -  „hold” [8] ) egy szkript programozási nyelv , amelyet a Rio de Janeiro-i Katolikus Egyetem ( Brazília ) Tecgraf ( Computer Graphics Technology Group ) részlege fejlesztett ki . A nyelvi tolmács egy ingyenes , nyílt forráskódú C nyelvi tolmács .

Ideológiáját és megvalósítását tekintve a Lua nyelv áll a legközelebb a JavaScript -hez , különösen az OOP prototípus modelljét valósítja meg , de különbözik Pascal-szerű szintaxisban, valamint erősebb és rugalmasabb konstrukciókban. A Lua jellemzője, hogy nagyszámú szoftverentitást implementál minimális szintaktikai eszközökkel. Tehát minden összetett, felhasználó által definiált adattípus ( tömbök , struktúrák , halmazok , sorok , listák ) a táblázatmechanizmuson és az objektum-orientált programozási mechanizmusokon keresztül valósul meg , beleértve a többszörös öröklődést is  , metatáblázatok használatával , amelyek szintén felelősek a túlterhelési műveletekért és számos egyéb funkció.

A Lua olyan felhasználók számára készült, akik nem professzionális programozók, ennek eredményeként nagy figyelmet fordítanak a tervezés egyszerűségére és a könnyű tanulásra. A nyelvet széles körben használják replikálható szoftverek létrehozására (például az Adobe Lightroom csomag grafikus felülete van beleírva ). Számos játékban (beleértve a Garry's Mod- t is ) a szintek és bővítmények programozási nyelveként is előtérbe került [9] .

Történelem

A nyelvet a brazil Rio de Janeiro Katolikus Egyetem Tecgraf részlege (számítógépes grafikai technológiai csoport) fejlesztette ki, a nyelv története 1993-ig nyúlik vissza. A nyelv szerzői Roberto Jeruzalimski , Luiz Henrique de Figueiredo és Waldemar Celes . A Lua szabadon terjesztett, nyílt forráskódú C nyelven .

Amint Luis Enrique de Figueiredo megjegyezte, a Lua az egyetlen olyan, fejlődő országban kifejlesztett programozási nyelv , amely világszerte elismerést kapott, ami különösen a HOPL konferenciára [10] szóló meghívóban nyilvánult meg .

A nyelv történeti szülői a SOL (Simple Object Language) és DEL (Data-Entry Language) [11] konfigurációs és adatleíró nyelvek voltak, amelyeket egymástól függetlenül fejlesztettek ki a Tecgrafnál 1992-1993 között, hogy némi rugalmasságot adjon két különálló nyelvhez. projektek (mindkettő interaktív grafikai alkalmazás volt a Petrobras tervezési igényeihez ). A SOL-ból és a DEL-ből hiányzott minden vezérlőkonstrukció, és a Petrobras úgy érezte, egyre nagyobb szükség van a teljes programozás hozzáadására.

Ahogy a nyelv szerzője írja a The Evolution of Lua című könyvében : [12]

1993-ban az egyetlen igazi versenyző a Tcl volt , amelyet kifejezetten alkalmazásokba való beágyazásra terveztek. A Tcl-nek azonban ismeretlen szintaxisa volt, hiányzott az adatleírás megfelelő támogatása, és csak Unix platformokon futott . Nem vettük figyelembe a Lisp -et vagy a Scheme -et barátságtalan szintaxisuk miatt. A Python még gyerekcipőben járt. A Tecgrafnál akkoriban uralkodó barkácsoló légkörben természetes volt, hogy úgy döntöttünk, saját forgatókönyvi nyelvet fejlesztünk. Tekintettel arra, hogy a felhasználók többsége nem volt professzionális programozó, a nyelvnek kerülnie kellett a tekervényes szintaxist és szemantikát. Az új nyelv implementációjának könnyen hordozhatónak kellett lennie , mivel a Tecgraf ügyfelei nagyon változatos platformokkal rendelkeztek. Végül, mivel azt vártuk, hogy más Tecgraf termékeknek is szükségük lesz beágyazott szkriptnyelvre, az új nyelvnek követnie kell a SOL példáját, és C API -val rendelkező könyvtárként kell biztosítania .

A Lua 1.0 úgy lett megtervezve, hogy a jelenlegi könnyű és rugalmas stílustól némileg eltérő objektumkonstruktorok tartalmazzák a SOL nyelv szintaxisát (innen ered a Lua név: portugálul sol  - "sun", lua  - "hold") . A Lua vezérlőkonstrukciókat többnyire a Modula-2- ből kölcsönözték (ha, while, ismétlés/amíg), bár a Clu is befolyásolja őket ( párhuzamos hozzárendelés , többfunkciós visszatérési érték , mint egyszerűbb alternatíva a paraméterek hivatkozással vagy explicit mutatókkal történő átadására ), C++ ("Nagyszerű ötlet a helyi változókat csak akkor deklarálni , amikor szükség van rájuk"), Snobol és awk ( asszociatív tömbök ). A Lua készítői azt is elismerik, hogy a Lisp and Scheme ( linkelt lista ) egyetlen mindenütt jelenlévő adatstrukturáló mechanizmusa nagy hatással volt arra a döntésükre, hogy a táblákat választották a Lua elsődleges adatstruktúrájaként [13] .

A Lua 5.0-ig terjedő verziói a BSD licenchez hasonló licenc alatt jelentek meg . Az 5.0-s verziótól kezdődően a Lua az MIT licenc alatt kerül terjesztésre . Mindkét engedély megengedő és gyakorlatilag azonos.

Általános jellemzők

A Lua önálló szkriptnyelvként vagy alkalmazásba építve használható. Eredetileg úgy tervezték, hogy elég egyszerű és kompakt legyen ahhoz, hogy különféle platformokon elférjen, és elfogadható teljesítményt nyújtson. A tervezés során figyelembe vették a könnyű tanulás követelményeit és a nem professzionális programozók általi használat lehetőségét is.

A Lua egy eljárási , dinamikusan tipizált moduláris nyelv automatikus memóriakezeléssel . Tartalmazza a funkcionális és objektumprogramozási stílusok támogatására szolgáló alapvető elemeket . Így a Lua többparadigmás nyelvnek nevezhető . A beépített párhuzamos programozási eszközök lehetővé teszik többszálú programok írását kizárólag nyelvi eszközök használatával, az operációs rendszer API-jára vagy külső könyvtárakra való hivatkozás nélkül. Mivel a Lua fő célja a beágyazás, hatékony többnyelvű interoperabilitással rendelkezik, elsősorban a C -könyvtárak hívására és a C-környezetben való munkára összpontosítva.

A nyelv kevés beépített adattípust támogat: logikai értékeket, számokat, karakterláncokat, függvényeket, adatfolyamokat. Nincsenek tipikus kombinált adatstruktúrák, például tömbök , halmazok , listák és rekordok , ezek mindegyike helyett egy alapvető Lua struktúra, a táblázat használatos (lásd alább). Egy külön típust userdatakifejezetten alacsony szintű programozásra és más nyelvű külső kóddal történő adatcserére terveztek. A Lua függvényei első osztályú objektumok, és paraméterként hozzárendelhetők és átadhatók. A lezárások támogatottak, lehetőség van magasabb rendű funkciók létrehozására. Az objektumrendszer prototípus, nincs kifejezett támogatása az öröklődésnek , de könnyen megvalósítható metatáblákkal .

Általában a Lua célja, hogy rugalmas metafunkciókat biztosítson, amelyek szükség szerint bővíthetők, ahelyett, hogy egy adott programozási paradigmára jellemző funkciókat biztosítanának. Ennek eredményeként az alapul szolgáló nyelv egyszerű és könnyen adaptálható a legtöbb alkalmazáshoz. Az alapvető szolgáltatások minimális készletével a Lua megpróbál egyensúlyt teremteni a teljesítmény és a méret között.

Szintaxis

A Lua szintaxisa többnyire késő Pascal-szerű nyelvekre épül, mint például a Modula-2 vagy az Oberon . A szövegbeviteli formátum szabad, a parancsokat a programszövegben tetszőleges szóköz karakter választja el. Megengedett, de nem kötelező pontosvessző használata a műveletek elválasztására.

A Robert Jeruzalimskinek adott interjújában megjegyezte, hogy a Lua szintaxis egy kompromisszum, amelyet meg kellett tennie, hogy megkönnyítse a nem professzionális programozók nyelvtanulását. A szintaxist "meglehetősen bőbeszédűnek" jellemezte, megjegyezve, hogy ő személy szerint egy tömörebb jelölést választott volna [10] .

Szókincs

A nyelv fő ábécéje az angol, más nyelvek karakterei is használhatók karakterlánc-literálokban. Az azonosítók állhatnak betűkből, számokból és aláhúzásjelekből, de nem kezdődhetnek számmal, és nem egyezhetnek meg valamelyik kulcsszóval. A nyelvi útmutató nem javasolja az aláhúzással kezdődő azonosítók használatát, mivel az ilyen azonosítókat rendszercélokra használják.

A nyelv megkülönbözteti a kis- és nagybetűket, minden kulcsszót kisbetűvel írunk, a csak betűkben eltérő azonosítókat másnak tekintjük. A következő 22 kulcsszó nem használható nevekre [14] :

és break do elseif end false goto for function if in local nil not vagy ismételje meg a return akkor igaz amíg míg

Megjegyzések

A megjegyzések a következő szintaxist használják, hasonlóan az Ada -hoz , az SQL -hez és a VHDL -hez :

-- Egy egyszerű egysoros megjegyzés a Lua nyelvben dupla mínuszjel kezdődik és a sor végéig tart. dim = { "one" , "two" , "three" } -- A soros megjegyzésnek nem kell a sor elején kezdődnie -- követhet más nyelvi konstrukciókat -- hogy megmagyarázza azokat. --[[A többsoros megjegyzés két egymást követő nyitó szögletes zárójellel kezdődik, amelyet két mínusz követ, és két egymást követő záró szögletes zárójellel folytatódik. Mint itt: ]] -- Érdekes hatás érhető el a soron belüli és többsoros megjegyzések kombinálásával: --[[ Az alábbi kód megjegyzésének törléséhez elegendő egy szóközt hozzáadni ebben a sorban a mínusz és a zárójelek közé. for i=1,#dim do print(dim[i]) end -- Ha a fenti mínuszjelek és zárójelek közé szóköz kerül, akkor --]] -- itt a többsoros megjegyzés vége a következőre változik normál vonal

Adattípusok

A Lua egy implicit dinamikus adattípus - definícióval rendelkező nyelv . Egy nyelvi változó bármilyen típusú értéket tartalmazhat. A Lua összes értéke változókban tárolható, függvényhívások argumentumaként használható , és a végrehajtás eredményeként visszaadható.

A Lua-ban nyolc fő típus létezik:

  • nulla (meghatározatlan)
  • logikai (boolean)
  • szám (numerikus)
  • karakterlánc _
  • függvény (függvény)
  • felhasználói adatok (felhasználói adatok)
  • szál (szál)
  • asztal (tábla)

nil  a nil [üres érték] értéktípus, amelynek fő tulajdonsága, hogy különbözik az összes többi értéktől, és a használható érték hiányát jelzi.

A logikai típus a false (false) és true (igaz) értékeket tartalmazza.

A számtípus általában valós számokat tartalmaz (dupla) . A Lua első verzióiban az egész számokat nem különítették el külön típusba; ezt a döntést az indokolja, hogy a valós ábrázolás lehetővé teszi az egész számok meglehetősen széles tartományának pontos ábrázolását. Az 5.3-as verziótól kezdve egész szám vagy valós szám formátumának explicit megadásának lehetősége bekerült. A számok belső ábrázolása megváltoztatható az értelmező felépítése során.

A karakterlánc típus karaktertömböket jelöl. A Lua karakterláncok bármilyen 8 bites karaktert tartalmazhatnak, beleértve a nullát ('\0'). A húrok változhatatlanok. A karakterlánc-literálok egyszeres vagy dupla idézőjelben írhatók, a szervizkarakterek szabványos C jelöléssel kerülnek bennük, bevezető fordított perjellel. A többsoros literálokat két egymást követő nyitó és két egymást követő záró szögletes zárójel határolja.

A nyelvbe nincs beépített Unicode támogatás, bár az UTF-8 karakterek használata karakterlánc-literálokban megengedett, és maga az UTF-8 reprezentációs rendszer is lehetővé teszi karakterláncok bevitelét, kiadását és részleges feldolgozását ebben a kódolásban a szabványos rendszereszközök segítségével. . A Lua legújabb verziói közé tartozik az utf8 könyvtár, amely fejlettebb UTF-8 támogatást biztosít, és vannak olyan külső gyártók könyvtárai, amelyek eszközöket biztosítanak a különböző kódolású Unicode karakterláncokkal való munkához.

A Lua függvényei teljes értékű objektumok, amelyek hozzárendelhetők, paraméterként átadhatók egy függvénynek, és az egyik értékként visszaadhatók. A száltípusnak korutinjai vannak, a userdata típust úgy tervezték, hogy a kódból más nyelven (főleg C/C++) kapott vagy adott külső adatokat reprezentáljon.

Műveletek

Feladat A hozzárendelés operátora a szimbólum =. A szkriptnyelvekhez hasonlóan, mint például a Perl , Python , Ruby és Icon , lehetővé teszi az egyidejű hozzárendelést . A legegyszerűbb esetben ez lehetővé teszi olyan kifejezések írását, mint: x , y = y , x Ellentétben például a Go -val, a párhuzamos hozzárendelés a Lua-ban nagyon liberális, nem szükséges, hogy a változók száma pontosan megegyezzen az értékek számával. Ha több érték van, mint változó, akkor az utolsó értékek el lesznek vetve, ha kevesebb az érték, akkor a lista utolsó változói nulla értéket kapnak. Összehasonlítások és logikai operátorok Összehasonlító operátorok: <, >, <=, >=, ==, ~= (az utolsó kettő az egyenlőség és az egyenlőtlenség összehasonlítását jelenti). Az egyenlőség és egyenlőtlenség összehasonlítása bármely adattípusra alkalmazható, mások csak karakterláncokra és számokra. Logikai operátorok: and, or, not - A logikai "és", "vagy" és "nem" bármilyen típusú értékre alkalmazható, és igaz vagy hamis értéket ad vissza. Ezen műveletek paramétereiben a nulla és a false értékek hamisnak minősülnek, minden más érték igaz. A C-től és számos más nyelvtől eltérően még a numerikus nulla (0) vagy egy üres karakterlánc ("") is "igaz" értéket jelent a logikai operátorok szempontjából. A bináris logikai operátorok kiértékelését hagyományosan az eredmény meghatározásáig végezzük, és az utolsó kiértékelt részkifejezés kerül visszaadásra. Ezért hármas operátorként használhatók ?:C-ben: -- hasonló ehhez: r = ( a < b)? f(a): f(b); C-ben r = ( a < b ) és f ( a ) vagy f ( b ) -- r az f() függvény értékét a két a és b érték közül a kisebbikből kapja, -- feltéve, hogy f(a) nem értéke nulla vagy hamis. Aritmetikai operátorok + - kiegészítés; - - kivonás; * - szorzás; / - osztály; - - egységes mínusz ; % - az osztály többi része; ^ - hatványozás.

Minden aritmetikai operátor támogatja a valós operandusokat, így kiszámítható eredményeket ad. Például x^0.5visszaadja a négyzetgyökét x, x^(-1/3) a kockagyökének reciprokát x. Az operátort %a következő határozza meg: a % b = a - math.floor(a / b) * b, ahol a függvény math.floor()az argumentumának egész részére értékelődik ki. Egész argumentumok esetén az eredménye teljesen normális. A valódi osztalék érdekében ne feledje, hogy a művelet nem hajtja végre a törtrész további kerekítését vagy eldobását, így az eredmény megtartja az osztalék töredékét. Például math.pi % 2nem 1, hanem 1.1415926535898. Ez a megvalósítás néhány további funkciót biztosít. Például xa három tizedesjegyre történő csonkoláshoz elegendő a kifejezést felvennix - x % 0.001

Táblázatok

A Lua-ban lévő táblázat egy dinamikus heterogén asszociatív tömb , azaz " " párok halmaza ключ-значение. A kulcsok bármilyen Lua típusú értékei lehetnek, kivéve a nil. A kulcsok Lua literálok (azonosítók) is lehetnek. Egy táblázatelemre írás nilegyenértékű az elem törlésével.

A táblázatok az egyetlen összetett adattípus a Lua-ban. Ezek képezik az alapját minden felhasználó által definiált adattípusnak, például struktúráknak , tömböknek , készleteknek és egyebeknek:

-- Általános tábla: üres = {} -- Üres táblázat üres [ 1 ] = "első" -- Üres egész indexű elem hozzáadása [ 3 ] = "második" -- Üres egész indexű elem hozzáadása [ "harmadik" ] = "harmadik" -- Elem hozzáadása a karakterlánc indexénél üres [ 1 ] = null -- Elem eltávolítása a táblázatból -- A klasszikus tömb karakterláncai alapértelmezés szerint 1 naptól kezdődő egész számokkal vannak indexelve1 = { " hétfő" , "kedd" , "szerda" , "csütörtök" , "péntek" , "szombat" , "vasárnap" } -- Tömb tetszőleges indexeléssel napok2 = {[ 0 ] = "vasárnap" , [ 1 ] = "hétfő" , [ 2 ] = "kedd" , [ 3 ] = "szerda" , [ 4 ] = "csütörtök" , [ 5 ] = "péntek" , [ 6 ] = "szombat" } -- Rekord (struktúra) - a különböző típusú értékeket literálok indexelték személy = { tabnum = 123342 , -- Személyi szám fio = "Ivanov Stepan Vasilyevich" , -- Teljes név post = "szerszámkészítő" , -- Beosztás fizetése = 25800,45 , -- Fizetési dátum = " 2013.10.23 " , -- Felvétel dátuma bdate = "1973.08.08" } -- Születési dátum pfio = személy . fio --Hivatkozás a szerkezeti elemre. -- A Set - indexek az értékek tárolására szolgálnak.workDays = {[ "Monday" ] = true , [ "Kedd" ] = true , [ "Wednesday" ] = true , [ "Chursday" ] = true , [ "Péntek" " ] = true } workDays [ "szombat" ] = true -- A munkanapok számához adja hozzá a szombatot is workDays [ "Wednesday" ] = null -- Szerdán már nem dolgozunk -- Ellenőrizze, hogy d munkanap- e, ha munkanapok [ d ] , majd kinyomtatás ( d .. " - munkanap" ) else print ( d .. " - szabadnap" ) vége

A multihalmazok (olyan halmazok, amelyek egynél több példányt tartalmazhatnak ugyanannak az elemnek) az előző példához hasonlóan valósulnak meg, csak az értékek nem logikaiak, hanem egész számok - a készletben lévő megfelelő elemek számának számlálói. A csatolt listák ábrázolhatók kételemes tömbök tömbjeként, amelyek értéket és hivatkozást tartalmaznak a következő elemre. A többdimenziós tömbök tömbök tömbjeként valósíthatók meg. A bonyolultabb struktúrák, mint a sorok, gráfok, hálózatok is táblák alapján valósulnak meg, a konkrét megvalósítási módot a feladat határozza meg.

Lezárások

A Lua támogatja a lezárások koncepcióját , például:

függvény makeaddfunc ( x ) - Egy új névtelen függvényt ad vissza, amely hozzáadja x-et az argumentum visszatérési függvényéhez ( y ) - Ha olyan x változóra hivatkozunk, amely kívül esik az aktuális hatókörön - és amelynek élettartama rövidebb, mint ennek az anonim függvénynek . - - Lua bezárást hoz létre. return x + y end end plustwo = makeaddfunc ( 2 ) -- azaz plustwo = function(y) return 2 + y end print ( plustwo ( 5 )) -- 7 nyomtatás

Minden egyes híváskor makeaddfuncegy új lezárás jön létre a változó számára x, így minden visszaadott névtelen függvény a saját paraméterére fog hivatkozni x. Mint minden más Lua objektum, a bezárás élettartamát a szemétgyűjtő kezeli.

A programozás eszközei és módszerei

Metatables

A metatable mechanizmus számos olyan funkciót biztosít, amelyet más nyelvek külön szintaktikai mechanizmusok bevezetésével biztosítanak. A metatáblák szerkezetüket tekintve közönséges Lua táblák, amelyekre a nyelv összes szabálya és korlátozása vonatkozik. Sajátosságuk az alkalmazásukban rejlik. A metatábla további metaadatokat tárol a típusokhoz és objektumokhoz, vagyis a hozzájuk tartozó paraméterekről és funkciókról szóló információkat. A metatáblákban tárolt információkat a Lua interpreter használja, használatuk lehetővé teszi a programobjektumok funkcionalitásának megváltoztatását, bővítését.

A Lua metatáblázata bármilyen típusú értékhez társítható. A skaláris adattípusok (a felhasználói adatok és a táblák kivételével) mindegyik típushoz közös metatáblázattal rendelkeznek. Egy típus táblázatai és értékei userdataminden esetben egyedi metatábla hivatkozásokkal rendelkeznek. A táblák kivételével minden típusú metatáblázat módosítása csak külső C kódon keresztül lehetséges. Csak a táblázat metatáblái érhetők el közvetlenül a Lua-ból.

A nulláról készített Lua tábláknak nincs metatáblája (a metatábla hivatkozása nulla). De metatábla hozzá bármikor létrehozható, vagy másik táblából is beszerezhető. A beépített függvény getmetatable(t)a t tábla metatábláját adja vissza, a függvény pedig setmetatable(t, m)beállítja a t táblát m metatáblára.

A metatáblázatok esetében a nyelvi tolmács által használható mezők készlete van dokumentálva. E mezők különleges szerepének jelzésére egy speciális elnevezési szabályt fogadtak el rájuk: azonosítóik két aláhúzással kezdődnek. E mezők némelyike ​​a metatábla által hivatkozott objektum speciális tulajdonságaira vonatkozó információkat tartalmaz. Például az opció __modeadott esetben gyengévé tehet egy táblát , vagyis olyan táblát, amelynek az objektumhivatkozásai mind gyenge hivatkozások . De a legtöbb lehetséges metatábla mező értéke az úgynevezett metametódusok , vagyis hivatkozások olyan függvényekre, amelyeket az értelmező bizonyos feltételek mellett meghív. A metametódusok értelmező általi használatának általános logikája a következő: amikor az értelmező olyan művelettel találkozik a programban, amely nincs definiálva az operandus objektumhoz, akkor hozzáfér az operandushoz társított metatáblához, megkeresi benne a megfelelő metamódszert és meghívja azt.

--[[ Összeadási művelet létrehozása táblákhoz ]] -- Operandusok t1 = { 1 , 2 , 3 } t2 = { 10 , 20 , 30 } -- Metatábla létrehozása mt = {} -- A "__add" mt metametódus írása a metatáblába . __add = függvény ( a , b ) local res = {} k számára párban ( a ) do res [ k ] = a [ k ] + b [ k ] end return res end -- Metatábla kötése a t1 táblához setmetatable ( t1 , mt ) -- A táblázat hozzáadása most már érvényes művelet t3 = t1 + t2 -- metatábla összekapcsolása t3 - mal a __tostring setmetatable ( t3 , { __tostring = függvény ( t ) local res = " \ n " for _ , v párokban ( t ) metamódszerrel do res = res .. tostring ( v ) .. "-" end return res .. " \n " end }) -- Ez a következőt írja ki: "11-22-33-" for _ , v in ipairs ( t3 ) do io.write ( v , "," ) end print ( tostring ( t3 )) -- "11,22,33"

A Lua támogatja a metametódusokat minden aritmetikai és összehasonlító művelethez, így ezek felhasználhatók a programozó által létrehozott objektumok aritmetikai végrehajtására. A szabványosokon kívül használhatjuk az úgynevezett "könyvtár" metamódszereket is, amelyeket nem a nyelv magja, hanem konkrét könyvtárak támogatnak. A fenti példában ez __tostringa karakterlánc-könyvtár által támogatott metamódszer; ez a módszer a táblát karaktersorozattá alakítja.

A terület a legnagyobb érdeklődésre számot tartó __index. Akkor hívják meg, ha az értelmező megpróbál beolvasni egy táblázatelemet, de nem találja. A mező __indexhivatkozhat táblára vagy metódusra. Az első esetben az értelmező, aki nem találja a kívánt értéket a főtáblázatban, megkeresi a táblázatban __index. A másodikban a tábla elérése helyett ez a metódus kerül meghívásra. Táblázatok vagy metamódszerek megadásával egy adott mezőhöz a Lua öröklést valósíthat meg, elrejtheti az objektumadatokat, nyomon követheti a táblaadatokon végzett műveleteket és még sok mást.

Objektumorientált programozás

Az OOP alapja a Lua-ban táblázatok. A tábla elvileg az OOP értelemben vett objektum, mivel tartalmazhat azonosítókkal megnevezett mezőket, és ezekben a mezőkben tetszőleges értékeket (objektumtulajdonságokat) és az objektum viselkedését megvalósító függvényeket (objektum metódusokat) tárolhat. A Lua által biztosított szintaktikai cukor egy része ismerősebbé teszi az objektumok leírását és kezelését a hagyományos OOP nyelvekben jártas programozók számára. A Lua-ban nincs „ osztály ” fogalma , ezért egy külön objektum van leírva, és minden mező és metódus kifejezetten erre utal. A tulajdonságok leírása az azonosítókulcsos táblaelemekhez hasonlóan történik, a metódusok leírása funkciómezők. A klasszikus Oberonhoz hasonlóan a metódusok leírása is explicit jelzést tartalmaz az úgynevezett "vevő" első paraméterében - egy olyan paraméter, amely a metódus meghívásakor arra az objektumra utal, amelyre meghívják. De a táblamezőre való szabványos hivatkozáson kívül egy ponton keresztül, amely megköveteli a címzett kifejezett megadását a metódushívásban, a Lua egy további szintaxist is támogat: amikor a metódus fejléce " Объект:метод" formában van írva a metódushívásban vagy leírásban. , akkor a címzett nincs megadva. Ugyanakkor a módszer törzsében továbbra is elérhető a következő néven self:

-- Object Account = { -- Object "számla" id , név , egyenleg = 0 , -- objektum tulajdonságai: szám, név, egyenleg jóváírás = függvény ( self , v ) -- "költség" metódus - leírás az objektumon belül explicit, amely megadja a címzettet , ha self . egyensúly < v akkor hiba "Nem elegendő egyenleg" end self . egyensúly = én . egyenleg - v vége } függvény Számla : debet ( v ) -- "bejövő" metódus - külső rövidített leírás (ön nincs megadva) self . egyensúly = én . egyensúly + v vége Fiók . debet ( számla , 10000 ) -- módszerhívásos változat Számla : jóváírás ( 5000 ) -- módszerhívás - rövid verzió

Az öröklődés, beleértve a többszörös öröklődést is, metatáblázatokkal és metamódszerekkel valósítható meg. Emellett metamódszerekkel megvalósíthatja az adatok elrejtését és a táblaobjektum mezőihez való vezérelt hozzáférést. Ha összehasonlítja ezt a megközelítést más nyelvekkel, ahol a fentiek mindegyike speciális nyelvi eszközökkel valósul meg, akkor láthatja, hogy a Lua implementáció bonyolultabb és gondosabb kódolást igényel, de nagyobb rugalmasságot biztosít és leegyszerűsíti a tolmácsot.

Kódpéldák

Klasszikus program " Helló, világ!" » Luában így néz ki:

print ( "Hello World!" )

A faktoriális  egy példa a rekurzív függvényre:

függvény faktoriális ( n ) ha n == 0 akkor return 1 else return n * faktoriális ( n - 1 ) end end

Hurok számlálóval :

i = 1 esetén 5 do -- utasítások/műveletek vége

A függvényekkel, mint első osztályú objektumokkal való munkavégzést a következő példa mutatja be, amely módosítja a nyomtatási függvény viselkedését:

do local oldprint = print -- Az aktuális nyomtatási függvény mentése oldprint függvényként print ( s ) -- A nyomtatási függvény újradefiniálása ha s == "foo" then oldprint ( "bar" ) else oldprint ( s ) end end end

Minden jövőbeli hívás printát lesz irányítva az új funkcióra, és a Lua lexikális kontextus támogatásának köszönhetően a régi nyomtatási funkció csak az új, módosított nyomtatási funkción keresztül lesz elérhető. A Lua támogatja a lezárásokat is , amint azt fentebb a kapcsolódó részben leírtuk.

A Lua kulcsfontosságú jellemzője a bővíthető szemantika, és a metatábla mechanizmus sok lehetőséget ad a Lua táblák egyedi viselkedésének testreszabására. A következő példa egy "végtelen" táblát mutat be. Bármelyiknél megadja a -edik Fibonacci-számot a memoization segítségével . fibs[n]

fibs = { 1 , 1 } -- A fibs[1] és fibs[2] kezdeti értékei. setmetatable ( fibs , { __index = function ( név , n ) -- A függvény hívása, ha a fibs[n] nem létezik. name [ n ] = név [ n - 1 ] + név [ n - 2 ] -- Fibek kiszámítása és memorizálása [n] .return name [ n ] end })

A Lua azt is lehetővé teszi, hogy logikai operátorokat használjon andhármas konstrukciókor bevitelére , mint például a C# -ban, vagy hivatkozzon a meglévő objektumok egyikére.

do local num = tonumber ( io.read ()) -- Írja be a konzolból bevitt információkat egy változóba, és alakítsa át egész típusú nyomtatásra ( num == 1 és "Helyes számot adott meg" vagy "Beírta a rossz szám" ) -- Ha a num változó 1

Meglévő tábla elérése és az érték lekérése az első indexnél:

do local tbl = nil local tbl2 = { 1 } print ( ( tbl vagy tbl2 )[ 1 ] ) -- Az 1 - es szám kerül kinyomtatásra , mert a tbl2 tábla index 1 végén ez az érték

Függvény meghívása a meglévő táblák egyikéből:

do local tbl = nil local tbl2 = {} tbl2 . DoSomething = function () print ( "Csinálj valamit" ) end ( tbl vagy tbl2 ). DoSomething () vége

Megvalósítás

Sok értelmezett programozási nyelvhez hasonlóan a Lua implementációnak külön fordítója van a forrásnyelvtől a végrehajtható bájtkódig, valamint egy virtuális gép a generált bájtkód végrehajtásához. Ráadásul a bájtkód nem a veremgép parancsai, hanem egy bizonyos, több regiszterrel rendelkező virtuális processzor parancsai, ami növeli a végrehajtás hatékonyságát. A szabványos Lua virtuális gép memóriafoglalást használ a szemétgyűjtéssel (hasonlóan a Java-hoz vagy a .NET-hez).

A Lua egyetlen karakterlánc -készletet használ , ami csökkenti a karakterláncok tárolására fordított memória többletköltségét.

Az időkritikus feladatokhoz létezik egy JIT - Lua fordító  - LuaJIT [15] . Kifejlesztésre került az llvm-lua [16] fordító is, amely az LLVM virtuális géphez kódot generál , amely lehetőséget ad a későbbi, nagyon hatékony gépi kóddá fordításra különféle architektúrájú processzorok számára.

Használat

Jelenleg különféle projektekben használják, ahol egy meglehetősen gyors és könnyen megtanulható script programozási nyelvet kell beépíteni - például játékfejlesztésben , ahol a Lua -t gyakran rétegként használják a játékmotor és a szkripthez szükséges adatok között. a tárgyak viselkedése és interakciója. Kompaktságának köszönhetően hordozható eszközökben is alkalmazható, különösen az egyik Texas Instruments grafikus számológép az ebben az eszközosztályban hagyományos BASIC helyett nyelvet használ .

Játékok

A LucasArts volt az első, aki bevezette a Lua nyelvet a számítógépes játékok fejlesztésébe, kezdve a Grim Fandango játékkal [17] . A nyelv szerzői beszámolójukban a HOPL konferenciánEmlékezzünk vissza, hogy 1997 januárjában üzenetet kaptak Bret Mogilefskytől, a Grim Fandango fő fejlesztőjétől, ahol azt írta, hogy miután olvasott a nyelvről egy 1996-os cikkben a Dr. Dobb's Journal , azt tervezi, hogy a házi készítésű SCUMM szkriptnyelvüket Lua -ra cserélik [18] . Ennek eredményeként megalkotta a GrimE játékmotort , amelyet a LucasArts egy későbbi küldetése is használ - Escape from Monkey Island .

2003-ban a GameDev.net felmérése szerint a Lua a játékfejlesztés legnépszerűbb szkriptnyelve [9] .

A Lua -val programozott játékra példa a World of Warcraft [19] [20] . Az Enigma [21] kirakós játék szintjei Lua nyelven vannak leírva .

Számos ingyenes játékmotor áll rendelkezésre, amelyek Luában programozhatók, mint például a Defold [22][ a tény jelentősége? ] , a LÖVE arcade engine [23] [24] , a játéktervező Novashell [25] és a küldetésorientált (többnyire szöveg alapú ) HELYETTE [26] .

Az X-Plane repülésszimulátorban, a STALKER X -Ray motorjában is használják [27] .

A népszerű Minecraft játékhoz a ComputerCraft és a fejlettebb analóg OpenComputers módosításai készültek, amelyek Lua nyelven programozott számítógépeket adnak hozzá [28] .

A híres Garry's Mod játék programozott, és támogatja a Lua nyelven írt módosításokat is.

A Croteam csapata (a Serious Sam és a The Talos Principle fejlesztői ) a Serious Engine 3.5 óta [29] használja a Lua-t a szkriptelésben .

A GTA: San Andreas játékhoz a Lua nyelven írt módosításokat a Moonloader bővítmény támogatja. [30] A Multi Theft Auto a Lua szkriptet is támogatja.

A Roblox játékplatform a Lua-t használja játékkódoló nyelvként és játékkörnyezet-kezelésként [31] .

A Ficsit-Networks modot a Satisfactory játékközösség hozta létre , amely lehetővé teszi bármilyen művelet Lua nyelven történő programozását [32] .

A Factorio a Lua -t használja a modok létrehozásához. [33] [34]

A Dual Universe játékot játékon belüli mechanikára és játékblokkok programozására használják

LuaTeX

A LuaTeX számítógépes betűszedő , a pdfTeX kiterjesztett változata , a Lua-t használja beépített szkriptnyelvként [35] .

RPM

Az RPM csomagkezelő beépített Lua értelmezőt tartalmaz [36] .

IDE

A Lua számára legalább két "natív" fejlesztői környezet létezik, ezek a következők:

  • A ZeroBrane Studio [37]  egy többplatformos fejlesztői környezet, amelyet magában a Lua-ban írtak.
  • A Decoda egy C++ nyelven  írt Windows fejlesztői környezet, amely gazdag hibakeresési lehetőségekkel rendelkezik a Lua szkriptekhez, beleértve a futó alkalmazásokat is. 2018-ra a környezet legújabb kiadása 2014-ből származik, és béta verzió státuszú.

Ezenkívül a Lua-t néhány univerzális IDE támogatja, különösen:

  • Geany
  • Lua fejlesztői eszközök [ 38] Eclipse környezethez
  • EmmyLua beépülő modul az IntelliJ IDEA környezethez , amely szintén fel van szerelve menet közbeni szintaktikai ellenőrzéssel és fejlett típusú megjegyzésrendszerrel [39]

Volt egy Lua támogatási modul a NetBeans környezethez , de 2013-ban megszűnt, és csak a NetBeans 7.4-es és korábbi verzióihoz érhető el. A beépülő modult a NetBeans 8 nem támogatja.

Lásd még

  • A Lua-t használó alkalmazások listája

Jegyzetek

  1. ↑ 1 2 https://www.lua.org/authors.html
  2. ↑ Lua: kb
  3. ↑ Lua 5.1 kézikönyv – 2019.
  4. ↑ Egy pillantás a Lua tervezésére  - [ New York] : Association for Computing Machinery , 2018. - ISSN 0001-0782 ; 1557-7317
  5. ↑ https://www.lua.org/license.html
  6. ↑ A lua nyílt forráskódú projekt az Open Hubon: Licencek oldala - 2006.
  7. ↑ https://www.lua.org/about.html
  8. ↑ Luáról . Lua.org. Letöltve: 2013. június 19. Az eredetiből archiválva : 2018. december 26..
  9. ↑ 1 2 Melyik nyelvet használod a szkriptekhez a játékmotorodban?. GameDev.net – Szavazási eredmények
  10. ↑ 1 2 Biancuzzi, Warden, 2011 , p. 216.
  11. ↑ Egy kiterjesztett nyelv evolúciója: Lua története (2001). Letöltve: 2016. augusztus 24. Az eredetiből archiválva : 2017. október 14..
  12. ↑ HOPL, 2007 , p. 2–1–2–26.
  13. ↑ Lua: bővíthető beágyazott nyelv. Néhány metamechanizmus számos funkciót helyettesít  (1996. december), 26–33. Az eredetiből archiválva: 2014. október 20. Letöltve: 2014. szeptember 20.
  14. ↑ Lua 5.1 kézikönyv . Letöltve: 2019. november 5. Az eredetiből archiválva : 2013. november 15.
  15. ↑ A LuaJIT projekt . Letöltve: 2009. május 18. Az eredetiből archiválva : 2009. április 16..
  16. ↑ llvm-lua. JIT/Statikus fordító a Lua számára LLVM használatával a háttérben. . Letöltve: 2009. január 21. Az eredetiből archiválva : 2009. január 22..
  17. ↑ Bret Mogilefsky. Lua a Grim Fandangóban . Letöltve: 2011. december 9. Az eredetiből archiválva : 2012. február 4..
  18. ↑ HOPL, 2007 , p. tizenegy.
  19. ↑ Paul Emmerich. A Lua kezdete a World of Warcraft kiegészítőkkel. - Apress , 2009. július. - ISBN 1430223715 .
  20. ↑ James Whitehead II, Bryan McLemore és Matthew Orlando. World of Warcraft programozás . - Wiley , 2008. május. - ISBN 0470229810 .
  21. ↑ Tom Gutschmidt. Ch. 8. A Lua Game Community → Game Engines // Játékprogramozás Python, Lua és Ruby segítségével . - Premier Press, 2003. - 472 p. - ISBN 1-59200-079-7 .
  22. ↑ Defold játékfejlesztési kézikönyv – Lua in Defold . Defold játékmotor. Letöltve: 2017. március 2. Az eredetiből archiválva : 2017. március 3.
  23. ↑ Dj Walker-Morgan. A H sebesség-útmutató Lua-hoz → Fejlesztés Luával . A H (2012. április 17.). Letöltve: 2015. február 26. Az eredetiből archiválva : 2015. február 26..
  24. ↑ Darmie Akinlaja. LÖVE a Lua játékprogramozáshoz. — Packt, 2013. — 106 p. — ISBN 978-1-78216-160-8 .
  25. ↑ Alan Thorne. 8. fejezet Novashell és 2D játékok // Cross Platform Game Development . - Jones & Bartlett Learning, 2008. - P.  225-264 . — 421 p. — ISBN 978-1-59822-056-8 .
  26. ↑ Pjotr ​​Kosik. HELYETTE: Hogyan kezdődött az egész  // IFPrint.org. - 2013. március 18. - Kiadás. 1 . — ISSN 2307-535X . Archiválva az eredetiből 2015. február 26-án.
  27. ↑ Ronnie Tucker. Full Circle Magazine #90: AZ UBUNTU LINUX KÖZÖSSÉG FÜGGETLEN MAGAZINJA . — Full Circle Magazin, 2014-10-31. - 50 s.
  28. ↑ Matthew Monk, Simon Monk. ComputerCraft: Lua programozás a Minecraftban . - CreateSpace Independent Publishing Platform, 2013-01-28. — 58 s. — ISBN 9781481927659 .
  29. ↑ Zero_Cool. Technológiatörténet - Komoly motor | történelem | GPU teszt . gamegpu.com. Letöltve: 2016. április 10. Az eredetiből archiválva : 2016. április 20.
  30. ↑ Kedvencek - Lua - ASI - MoonLoader  (orosz) , BlastHack - Csalás mint művészet . Az eredetiből archiválva : 2018. január 29. Letöltve: 2018. január 28.
  31. ↑ Ismerje meg a Robloxot | Kódolás és szkriptek . developer.roblox.com Letöltve: 2019. augusztus 23. Az eredetiből archiválva : 2019. augusztus 23.
  32. ↑ FicsIt-Networks :: Kielégítő módosítási  dokumentáció . docs.fixit.app . Letöltve: 2022. március 24.
  33. ↑ Modding - Factorio Wiki . wiki.factorio.com . Letöltve: 2022. június 1. Az eredetiből archiválva : 2022. június 1.
  34. ↑ API Docs | factorio . lua-api.factorio.com . Letöltve: 2022. június 1. Az eredetiből archiválva : 2022. május 18.
  35. ↑ CTAN : Luatex csomag  . Letöltve: 2019. február 6. Az eredetiből archiválva : 2019. február 7..
  36. ↑ Lua RPM  -ben . Letöltve: 2019. február 11. Az eredetiből archiválva : 2018. június 24.
  37. ↑ ZeroBrane Studio – Lua IDE/szerkesztő/hibakereső Windows, Mac OSX és Linux rendszerekhez . Letöltve: 2013. július 31. Az eredetiből archiválva : 2016. január 18..
  38. ↑ Lua fejlesztői eszközök . Letöltve: 2012. február 14. Az eredetiből archiválva : 2012. február 9..
  39. ↑ EmmyLua :: JetBrains Plugin  Repository . JetBrains Plugin Repository. Hozzáférés dátuma: 2018. február 26. Az eredetiből archiválva : 2018. február 27.

Irodalom

  • Roberto Jeruzsálem. Programozás Lua nyelven. - 3. kiadás. - DMK, 2014. - ISBN 9785940747673 . (eredeti: Roberto Ierusalimschy. Programozás Lua nyelven. - 3. kiadás. - 2012. - ISBN 9788590379850 . )
  • Ian Dees. Lua // Hét további nyelv hét hét alatt. Nyelvek, amelyek alakítják a jövőt / Bruce Tate, Fred Daoud, Jack Moffitt, Ian Dees. - A pragmatikus könyvespolc, 2015. - P. 1-48. — 320 s. — ISBN 978-1941222157 .
  • Mario Kasuba. Lua játékfejlesztési szakácskönyv. - Packt Publishing, 2015. - 402 p. — ISBN 978-1849515504 .
  • David Young. Játék AI programozás tanulása Lua segítségével. - Packt Publishing, 2014. - 352 p. — ISBN 978-1783281336 .
  • Jayant Varma. Ismerje meg a Lua alkalmazást az iOS játékfejlesztéshez . - Apress, 2012. - 410 p. — ISBN 9781430246626 .
  • Kurt Jung, Aaron Brown. A Lua programozás kezdete . - John Wiley & Sons, 2011. - 675 p. - (Programozótól programozóig). — ISBN 9781118079119 .
Nyelvtörténet
  • R. Ierusalimschy, LH de Figueiredo, W. Celes. A Lua evolúciója  // Proceedings of ACM HOPL III. 2-1-2-26. – 2007.
  • Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes. Egy kiterjesztett nyelv evolúciója: a Lua története . Reprint from Proceedings of V Brazilian Symposium on Programming Languages ​​(2001) B-14–B-28. Letöltve: 2011. december 9. Az eredetiből archiválva : 2012. február 4..
  • Federico Biancuzzi, Shane Warden. 7. fejezet Lua // Programozási úttörők. Beszélgetések a főbb programozási nyelvek alkotóival = A programozás ötletgazdái: Beszélgetések a főbb programozási nyelvek alkotóival. - Szimbólum, 2011. - S. 211-230. — 608 p. - 1500 példány.  — ISBN 9785932861707 .
  • Interjú Robert Yeruzalimskyvel a Computerworld számára a lua nyelvről

Lásd még

  • Mókus  - Lua-alapú programozási nyelv

Linkek

Lua oroszul

Kézikönyvek fordításai Cikkek és ismertetők
 Lua
FordítókKeretrendszerek és DLL -ekPortok és disztribúciókIdusAlkalmazások
 Programozási nyelvek