Lua

Lua
Kieliluokka toiminnallinen ohjelmointikieli , olioohjelmointikieli , komentosarjakieli , moniparadigmaohjelmointikieli , pakollinen ohjelmointikieli , proseduuriohjelmointikieli , prototyyppisuuntautunut ohjelmointikieli [d] , tulkittu ohjelmointikieli , käännetty ohjelmointikieli , vapaa ohjelmisto ja tiedostomuoto
Esiintyi 1993 [2]
Tekijä Roberto Jeruzalimski ,
Valdemar Selish,
Luis Enrique de Figueiredo
Kehittäjä Robert Jeruzalimsky [1]
Tiedostotunniste _ .lua[3] [4] ,.luna,.lunairetai.anair
Vapauta 5.4.4 (26. tammikuuta 2022)
Tyyppijärjestelmä dynaaminen , vahva , ankka
Vaikutettu C++ , Clu , Simple Object Language [d] , DEL , Snobol , Modula , Modula-2 and Scheme
vaikutti JavaScript
Lisenssi MIT-lisenssi [5] [6]
Verkkosivusto lua.org ​(  englanniksi) ​(  portti)
OS monialustainen [7]
 Mediatiedostot Wikimedia Commonsissa

Lua ( lua ,  port.  -  "moon" [8] ) on komentosarja - ohjelmointikieli , joka on kehitetty Rio de Janeiron katolisen yliopiston ( Brasilia ) Tecgraf-divisioonassa ( Computer Graphics Technology Group ) . Kielitulkki on ilmainen avoimen lähdekoodin C -kielen tulkki .

Ideologialtaan ja toteutukseltaan Lua-kieli on lähimpänä JavaScriptiä , erityisesti se toteuttaa myös OOP - prototyyppimallia , mutta eroaa Pascal-tyyppiseltä syntaksilta sekä tehokkaammilta ja joustavammilta rakenteilta. Lualle tyypillinen piirre on useiden ohjelmistokokonaisuuksien toteuttaminen minimaalisilla syntaktisilla keinoilla. Joten kaikki käyttäjän määrittämät yhdistetyt tietotyypit ( taulukot , rakenteet , joukot , jonot , luettelot ) toteutetaan taulukkomekanismin ja oliopohjaisten ohjelmointimekanismien kautta , mukaan lukien moniperinnön  , käyttämällä metataulukoita , jotka vastaavat myös ylikuormitustoiminnoista ja useita muita ominaisuuksia.

Lua on tarkoitettu käyttäjille, jotka eivät ole ammattiohjelmoijia, minkä seurauksena suunnittelun yksinkertaisuuteen ja oppimisen helppouteen kiinnitetään paljon huomiota. Kieltä käytetään laajasti replikoitavien ohjelmistojen luomiseen (esimerkiksi Adobe Lightroom -paketin graafinen käyttöliittymä on kirjoitettu siihen ). Sai myös aseman tasojen ja laajennusten ohjelmointikielenä monissa peleissä (mukaan lukien Garry's Mod ) [9] .

Historia

Kielen on kehittänyt Brasilian Rio de Janeiron katolisen yliopiston Tecgraf-divisioona (tietokonegrafiikkateknologiaryhmä), kielen historia ulottuu vuoteen 1993. Kielen kirjoittajat ovat Roberto Jeruzalimski , Luiz Henrique de Figueiredo ja Waldemar Celes . Lua on vapaasti jaettu, avoimen lähdekoodin C-kielellä .

Kuten Luis Enrique de Figueiredo totesi, Lua on ainoa kehitysmaassa kehitetty ohjelmointikieli, joka on saanut maailmanlaajuista tunnustusta, mikä ilmaistiin erityisesti kutsussa HOPL- konferenssiin [10] .

Kielen historialliset vanhemmat olivat konfigurointi- ja tiedonkuvauskielet SOL (Simple Object Language) ja DEL (Data-Entry Language) [11] . Ne kehitettiin itsenäisesti Tecgrafissa vuosina 1992-1993 joustavuuden lisäämiseksi kahteen erilliseen kieleen. projekteja (molemmat olivat interaktiivisia grafiikkasovelluksia Petrobrasin suunnittelutarpeisiin ). SOL:sta ja DEL:stä puuttui ohjausrakenteita, ja Petrobras tunsi kasvavan tarpeen lisätä niihin täysi ohjelmointi.

Kuten kielen kirjoittaja kirjoittaa teoksessa The Evolution of Lua : [12]

Vuonna 1993 ainoa todellinen haastaja oli Tcl , joka oli erityisesti suunniteltu upotettavaksi sovelluksiin. Tcl:llä oli kuitenkin tuntematon syntaksi, siitä puuttui hyvä tiedonkuvaustuki ja se toimi vain Unix -alustoilla . Emme ole harkinneet Lispia tai Schemeä niiden epäystävällisen syntaksin vuoksi. Python oli vielä lapsenkengissään. Tecgrafissa tuolloin vallinneessa tee-se-itse-ilmapiirissä oli luonnollista, että päätimme kehittää oman kirjoituskielemme. Koska suurin osa käyttäjistä ei ollut ammattiohjelmoijia, kielen piti välttää kieroutunutta syntaksia ja semantiikkaa. Uuden kielen käyttöönoton piti olla helposti kannettava , sillä Tecgrafin asiakkailla oli hyvin erilaisia ​​alustoja. Lopuksi, koska odotimme myös muiden Tecgraf-tuotteiden tarvitsevan upotetun skriptikielen, uuden kielen tulisi seurata SOL:n esimerkkiä ja tarjota kirjastona C API : lla .

Lua 1.0 suunniteltiin siten, että nykyisestä kevyestä ja joustavasta tyylistä hieman poikkeavat objektien rakentajat sisälsivät SOL-kielen syntaksin (siis Lua-nimi: portugaliksi sol  - "aurinko", lua  - "kuu") . Lua-ohjausrakenteet on enimmäkseen lainattu Modula-2 :sta (jos, while, toista/kunnes), vaikka niihin vaikuttaa myös Clu ( rinnakkaismääritys , usean funktion palautusarvo yksinkertaisempana vaihtoehtona parametrien välittämiselle viitteellä tai eksplisiittisillä osoittimilla ), C++ ("On hyvä idea ilmoittaa paikalliset muuttujat vain silloin, kun niitä tarvitaan"), Snobol ja awk ( assosiatiiviset taulukot ). Luan luojat myöntävät myös, että yksittäinen kaikkialla oleva tiedon strukturointimekanismi Lisp and Schemessa ( linkitetty luettelo ) vaikutti merkittävästi heidän päätöksessään valita taulukot Luan ensisijaiseksi tietorakenteeksi [13] .

Lua - versiot 5.0 : aan asti julkaistiin BSD - lisenssin kaltaisella lisenssillä . Versiosta 5.0 eteenpäin Lua jaetaan MIT-lisenssillä . Molemmat lisenssit ovat sallivia ja käytännössä identtisiä.

Yleiset ominaisuudet

Lua on tarkoitettu käytettäväksi erillisenä komentosarjakielenä tai sisäänrakennettuna sovellukseen. Se suunniteltiin alun perin riittävän yksinkertaiseksi ja kompaktiksi, jotta se sopii useille alustoille ja tarjoaa hyväksyttävän suorituskyvyn. Suunnittelussa on otettu huomioon myös oppimisen helppous ja mahdollisuus käyttää ei-ammattilaisia ​​ohjelmoijia.

Lua on proseduurillisesti dynaamisesti kirjoitettu modulaarinen kieli, jossa on automaattinen muistinhallinta . Sisältää peruselementtejä, jotka tukevat toiminnallisia ja objektiohjelmointityylejä . Siten Luaa voidaan kutsua moniparadigmakieleksi . Sisäänrakennettujen rinnakkaisohjelmointityökalujen avulla voit kirjoittaa monisäikeisiä ohjelmia käyttämällä vain kielityökaluja, ilman käyttöjärjestelmän API:ta tai ulkoisia kirjastoja. Koska Luan päätarkoitus on inlining, sillä on tehokas kielten välinen yhteentoimivuus, joka keskittyy ensisijaisesti C -kirjastojen soittamiseen ja työskentelyyn C-ympäristössä.

Kieli tukee pientä määrää sisäänrakennettuja tietotyyppejä: booleaneja, numeroita, merkkijonoja, funktioita, virtoja. Ei ole olemassa tyypillisiä yhdistettyjä tietorakenteita, kuten taulukoita , joukkoja , luetteloita ja tietueita , vaan niiden kaikkien sijasta käytetään yhtä Lua-perusrakennetta, taulukkoa (katso alla). Erillinen tyyppi userdataon suunniteltu erityisesti matalan tason ohjelmointiin ja tiedonvaihtoon ulkoisen koodin kanssa muilla kielillä. Luan funktiot ovat ensiluokkaisia ​​objekteja, ja ne voidaan määrittää ja välittää parametreina. Sulkemisia tuetaan, on mahdollista luoda korkeamman asteen toimintoja. Objektijärjestelmä on prototyyppinen, perinnöllisyydelle ei ole selkeää tukea , mutta se on helppo toteuttaa metataulukoiden avulla .

Yleisesti ottaen Lua pyrkii tarjoamaan joustavia metafunktioita, joita voidaan laajentaa tarpeen mukaan, sen sijaan, että se tarjoaisi tietylle ohjelmointiparadigalle ominaisia ​​toimintoja. Tämän seurauksena taustalla oleva kieli on yksinkertainen ja helposti mukautettavissa useimpiin sovelluksiin. Tarjoamalla minimijoukon peruspalveluja Lua yrittää löytää tasapainon tehon ja koon välillä.

Syntaksi

Luan syntaksi on enimmäkseen rakennettu myöhään Pascalin kaltaisille kielille, kuten Modula-2 tai Oberon . Tekstinsyöttömuoto on vapaa, komennot ohjelmatekstissä erotetaan välilyönneillä. Puolipisteen käyttäminen toimintojen erottamiseen on sallittua, mutta ei pakollista.

Haastattelussa Robert Jeruzalimskin kanssa hän huomautti, että Lua-syntaksi oli kompromissi, joka hänen oli tehtävä, jotta ei-ammattimaisten ohjelmoijien olisi helpompi oppia kieltä. Hän kuvaili syntaksia "melko sanalliseksi" ja huomautti, että hän henkilökohtaisesti olisi halunnut tiiviimmän merkinnän [10] .

Sanasto

Kielen pääaakkoset ovat englanti, muiden kielten merkkejä voidaan käyttää merkkijono-literaaaleissa. Tunnisteet voivat koostua kirjaimista, numeroista ja alaviivoista, mutta ne eivät voi alkaa numerolla tai vastata yhtä avainsanoista. Kieliopas ei suosittele alaviivalla alkavien tunnisteiden käyttöä, koska tällaisia ​​tunnisteita käytetään järjestelmätarkoituksiin.

Kieli on isot ja pienet kirjaimet erotteleva, kaikki avainsanat kirjoitetaan pienillä kirjaimilla, tunnisteet, jotka eroavat vain kirjaimista, katsotaan erilaisiksi. Seuraavia 22 avainsanaa ei voi käyttää nimissä [14] :

ja break do elseif end false goto funktiolle if paikallisessa nollassa ei tai toista return sitten true kunnes while _ _ _

Kommentit

Kommentit käyttävät seuraavaa syntaksia, joka on samanlainen kuin Ada , SQL ja VHDL :

-- Yksinkertainen yksirivinen kommentti Luassa alkaa kaksinkertaisella miinuksella ja jatkuu rivin loppuun. dim = { "yksi" , "kaksi" , "kolme" } -- Rivikommentin ei tarvitse alkaa rivin alusta -- se voi seurata muita kielen rakenteita -- selittääkseen niitä. --[[Monirivinen kommentti alkaa kahdella peräkkäisellä avaavalla hakasulkeella ja sen jälkeen kahdella miinuksella ja jatkuu kahdella peräkkäisellä sulkevalla hakasulkeella. Kuten täällä: ]] -- Mielenkiintoinen tehoste saadaan yhdistämällä rivi- ja monirivisiä kommentteja: --[[ Alla olevan koodin kommentoinnin poistamiseksi riittää, että tälle riville lisätään välilyönti miinusten ja hakasulkeiden väliin. for i=1,#dim do print(dim[i]) end -- Jos yllä olevien miinusmerkkien ja hakasulkeiden väliin lisätään välilyönti, niin --]] -- tässä monirivisen kommentin loppu muuttuu normaali linja

Tietotyypit

Lua on kieli, jossa on implisiittinen dynaaminen tietotyyppimääritelmä . Kielimuuttuja voi sisältää minkä tahansa tyyppisiä arvoja. Kaikki Luan arvot voidaan tallentaa muuttujiin, käyttää argumentteina toimintokutsuissa ja palauttaa niiden suorittamisen tuloksena.

Luassa on kahdeksan päätyyppiä:

  • nolla (määrittämätön)
  • boolean (boolean)
  • numero (numeerinen)
  • merkkijono _
  • toiminto (funktio)
  • käyttäjätiedot (käyttäjätiedot)
  • lanka (lanka)
  • pöytä (pöytä)

nolla  on arvotyyppi nil [tyhjä arvo], jonka pääominaisuus on olla erilainen kuin kaikki muut arvot ja osoittaa käyttöarvon puuttumista.

Boolen tyyppi sisältää arvot false (false) ja true (true).

Numerotyyppi sisältää yleensä reaaliluvut (double). Luan ensimmäisissä versioissa kokonaislukuja ei erotettu erilliseksi tyypiksi; Tämä päätös perustuu siihen tosiasiaan, että todellisen esitystavan avulla voit esittää tarkasti melko laajan valikoiman kokonaislukuja. Versiosta 5.3 alkaen on lisätty mahdollisuus määritellä eksplisiittisesti kokonaisluku- tai reaalilukumuoto. Lukujen sisäistä esitystapaa voidaan muuttaa tulkkia rakennettaessa.

Merkkijonotyyppi tarkoittaa merkkijonoja . Lua-merkkijonot voivat sisältää minkä tahansa 8-bittisen merkin, mukaan lukien nolla ('\0'). Jouset ovat muuttumattomia. Merkkijonoliteraalit voidaan kirjoittaa kerta- tai kaksoislainausmerkeillä, palvelumerkit sijoitetaan niihin tavallisella C-merkinnällä kenoviivalla. Moniriviset literaalit on rajattu kahdella peräkkäisellä avaavalla ja kahdella peräkkäisellä sulkevalla hakasulkeella.

Kieleen ei ole sisäänrakennettu Unicode-tukea, vaikka UTF-8-merkkien käyttö merkkijonoliteraaaleissa on sallittua, ja itse UTF-8-esitysjärjestelmä mahdollistaa merkkijonojen syöttämisen, tulostamisen ja osittaisen käsittelyn tässä koodauksessa käyttämällä tavallisia järjestelmätyökaluja. . Uusimmat Lua-versiot sisältävät utf8-kirjaston, joka tarjoaa edistyneemmän tuen UTF-8:lle, ja on olemassa kolmansien osapuolien kirjastoja, jotka tarjoavat työkaluja Unicode-merkkijonojen käsittelyyn eri koodauksissa.

Luan funktiot ovat täysimittaisia ​​objekteja, jotka voidaan määrittää, välittää parametrina funktiolle ja palauttaa yhtenä arvoista. Säiketyypissä on korutiinit , userdata -tyyppi on suunniteltu edustamaan ulkoista dataa, joka on vastaanotettu tai toimitettu toisella kielellä (lähinnä C/C++) koodista/koodiin.

Toiminnot

Tehtävä Tehtäväoperaattori on symboli =. Kuten komentosarjakielet, kuten Perl , Python , Ruby ja Icon , sallivat samanaikaisen määrityksen . Yksinkertaisimmassa tapauksessa voit kirjoittaa lausekkeita, kuten: x , y = y , x Toisin kuin esimerkiksi Go , rinnakkaismääritys Luassa on hyvin vapaata, se ei vaadi muuttujien määrää täsmälleen arvojen lukumäärän kanssa. Jos arvoja on enemmän kuin muuttujia, viimeiset arvot hylätään; jos arvoja on vähemmän, luettelon viimeiset muuttujat saavat arvon nolla. Vertailut ja loogiset operaattorit Vertailuoperaattorit: <, >, <=, >=, ==, ~= (kaksi viimeistä tarkoittavat vertailua tasa-arvolle ja epätasa-arvolle). Tasa-arvon ja epätasa-arvon vertailua voidaan soveltaa mihin tahansa tietotyyppiin, toiset - vain merkkijonoihin ja numeroihin. Loogiset operaattorit: and, or, not - looginen "ja", "tai" ja "ei", vastaavasti, voidaan soveltaa minkä tahansa tyyppisiin arvoihin ja palauttaa tosi tai epätosi. Näiden operaatioiden parametreissa arvoja nolla ja false pidetään epätosina, kaikki muut arvot ovat tosi. Toisin kuin C ja monet muut kielet, jopa numeerinen nolla (0) tai tyhjä merkkijono ("") edustaa "todellista" arvoa loogisten operaattoreiden suhteen. Binääristen loogisten operaattorien arviointia suoritetaan perinteisesti, kunnes tulos on määritetty, jolloin viimeinen arvioitu osalauseke palautetaan tuloksena. Siksi niitä voidaan käyttää kolmiosaisena operaattorina ?:C:ssä: -- samanlainen kuin r = ( a < b)? f(a): f(b); C:ssä r = ( a < b ) ja f ( a ) tai f ( b ) -- r saa funktion f() arvon pienemmästä arvosta a ja b, -- edellyttäen, että f(a) is not on nolla tai epätosi. Aritmeettiset operaattorit + - lisäys; - - vähennyslasku; * - kertolasku; / - jako; - - yksipuolinen miinus ; % - divisioonan loppuosa; ^ - eksponentiointi.

Kaikki aritmeettiset operaattorit tukevat todellisia operandeja, jotka antavat ennakoitavia tuloksia. Esimerkiksi x^0.5palauttaa neliöjuuren x, x^(-1/3) kuutiojuuren käänteisluvun x. Operaattorin %määrittelee: a % b = a - math.floor(a / b) * b, jossa funktio math.floor()laskee argumenttinsa kokonaislukuosaan. Kokonaislukuargumenteille sen tulos on melko normaali. Todellisen osingon saamiseksi muista, että operaatio ei suorita murto-osan ylimääräistä pyöristystä tai hylkäämistä, joten tulos säilyttää osingon murto-osan. Esimerkiksi se math.pi % 2ei palaa 1, vaan 1.1415926535898. Tämä toteutus tarjoaa joitain lisäominaisuuksia. Esimerkiksi, jos haluat katkaista xkolmen desimaalin tarkkuudella, riittää, että otat lausekkeenx - x % 0.001

Taulukot

Taulukko Luassa on dynaaminen heterogeeninen assosiatiivinen taulukko , eli joukko " ключ-значение"-pareja. Avaimet voivat olla minkä tahansa Lua-tyypin arvoja paitsi nil. Avaimet voivat olla myös Lua-literaaleja (tunnisteita). Taulukon elementtiin kirjoittaminen nilvastaa tämän elementin poistamista.

Taulukot ovat Luan ainoa yhdistelmätietotyyppi. Ne ovat perusta kaikille käyttäjän määrittämille tietotyypeille, kuten rakenteille , taulukoille , joukoille ja muille:

-- Yleinen taulukko: tyhjä = {} -- Tyhjä taulukko tyhjä [ 1 ] = "ensimmäinen" -- Lisätään elementti, jonka kokonaislukuindeksi on tyhjä [ 3 ] = "toinen" -- Lisätään elementti, jonka kokonaislukuindeksi on tyhjä [ "kolmas" ] = "kolmas" -- Lisää elementti merkkijonoindeksiin tyhjä [ 1 ] = nolla -- Poista elementti taulukosta -- Klassiset taulukot - merkkijonot indeksoidaan oletuksena kokonaisluvuilla alkaen 1 päivää1 = { "maanantai" , "tiistai" , "keskiviikko" , "torstai" , "perjantai" , "lauantai" , "sunnuntai" } -- Taulukko mielivaltaisella indeksillä päivät2 = {[ 0 ] = "sunnuntai" , [ 1 ] = "maanantai" , [ 2 ] = "tiistai" , [ 3 ] = "keskiviikko" , [ 4 ] = "torstai" , [ 5 ] = "perjantai" , [ 6 ] = "lauantai" } -- Tietue (rakenne) - eri tyyppiset arvot indeksoidaan literaaleilla henkilö = { tabnum = 123342 , -- Henkilönumero fio = "Ivanov Stepan Vasilyevich" , -- Koko nimi virka = "työkaluvalmistaja" , -- Tehtävän palkka = 25800,45 , -- Palkkapäivä = "23.10.2013" , -- Palkkauspäivä bdate = "08/08/1973" } -- Syntymäaika pfio = henkilö . fio --Viite rakenneelementtiin. -- Set - indeksejä käytetään arvojen tallentamiseen.workDays = {[ " Maanantai" ] = tosi , [ "tiistai" ] = tosi , [ "keskiviikko" ] = tosi , [ " torstai " ] = tosi " ] = tosi } työpäivät [ "lauantai" ] = tosi -- Lisää lauantai työpäivien määrään työpäivät [ " keskiviikko" ] = nolla -- Emme enää työskentele keskiviikkoisin -- Tarkista onko d työpäivä , jos työpäivät [ d ] sitten tulosta ( d .. " - työpäivä" ) muuten tulosta ( d .. " - vapaapäivä" ) loppu

Multiset (joukot, jotka voivat sisältää useamman kuin yhden saman elementin esiintymän) toteutetaan samalla tavalla kuin viimeinen esimerkki, vain arvot eivät ole loogisia, vaan kokonaislukuja - joukon vastaavien elementtien lukumäärän laskureita. Linkitetyt luettelot voidaan esittää kaksielementtisten taulukoiden taulukoina, joissa on arvo ja viittaus seuraavaan elementtiin. Moniulotteiset taulukot voidaan toteuttaa taulukoiden taulukoina. Myös monimutkaisemmat rakenteet, kuten jonot, graafit, verkot, toteutetaan taulukoiden perusteella, konkreettinen toteutustapa määräytyy tehtävän mukaan.

Sulkemiset

Lua tukee sulkemiskonseptia , esimerkiksi:

funktio makeaddfunc ( x ) - Palauttaa uuden anonyymin funktion, joka lisää x:n argumenttinsa palautusfunktioon ( y ) - Kun viitataan muuttujaan x, joka on nykyisen laajuuden ulkopuolella - ja jonka elinikä on lyhyempi kuin tämä anonyymi funktio - - - Lua luo sulkemisen. return x + y end end plustwo = makeaddfunc ( 2 ) -- eli plustwo = function(y) return 2 + y end print ( pluskaksi ( 5 )) -- Tulostaa 7

Joka kerta kun sitä kutsutaan makeaddfunc, muuttujalle luodaan uusi sulkeminen x, jotta jokainen palautettu anonyymi funktio viittaa omaan parametriinsa x. Kuten minkä tahansa muun Lua-objektin, sulkemisen käyttöikää hallitsee jätteenkerääjä.

Ohjelmointikeinot ja -menetelmät

Metatables

Metataulukkomekanismi tarjoaa monia ominaisuuksia, joita muut kielet tarjoavat ottamalla käyttöön erilliset syntaktiset mekanismit. Metataulukot ovat rakenteeltaan tavallisia Lua-taulukoita, joihin sovelletaan kaikkia kielen sääntöjä ja rajoituksia. Niiden erikoisuus piilee niiden sovelluksessa. Metataulukko tallentaa lisämetatietoja tyypeistä ja objekteista, eli tietoja niihin liittyvistä parametreista ja toiminnoista. Lua-tulkki käyttää metataulukoihin tallennettuja tietoja, joiden avulla voit muuttaa tai laajentaa ohjelmaobjektien toimivuutta.

Luan metataulukko voidaan liittää minkä tahansa tyyppiseen arvoon. Skalaaritietotyypeillä (kaikki paitsi käyttäjätiedot ja taulukot) on yhteiset metataulukot kullekin tyypille. Tyypin taulukoilla ja arvoilla on userdatakussakin tapauksessa yksittäiset metataulukkoviitteet. Kaikentyyppisten metataulukoiden muokkaaminen taulukoita lukuun ottamatta voidaan tehdä vain ulkoisen C-koodin avulla. Vain taulukon metataulukot ovat käytettävissä suoraan Luasta.

Tyhjästä luodulla Lua-taulukolla ei ole metataulukkoa (sen metataulukkoviittaus on nolla). Mutta metataulukko sille voidaan luoda milloin tahansa tai saada toisesta taulukosta. Sisäänrakennettu funktio getmetatable(t)palauttaa taulukon t metataulukon ja funktio setmetatable(t, m)asettaa taulukon t metataulukoksi m.

Metataulukoille dokumentoidaan joukko kenttiä, joita kielen tulkki voi käyttää. Näiden kenttien erityisroolin osoittamiseksi niille on otettu käyttöön erityinen nimeämissääntö: niiden tunnisteet alkavat kahdella alaviivalla. Jotkut näistä kentistä sisältävät tietoja kohteen, johon metataulukko viittaa, erityisistä ominaisuuksista. Esimerkiksi vaihtoehto __mode, kun se on annettu, voi tehdä taulukosta heikon , eli taulukon, jonka objektiviittaukset ovat kaikki heikkoja viittauksia . Mutta useimpien mahdollisten metataulukkokenttien arvot ovat niin sanottuja metamenetelmiä , eli viittauksia funktioihin, joita tulkki kutsuu tietyissä olosuhteissa. Tulkin metamenetelmien yleinen käyttölogiikka on seuraava: kun tulkki kohtaa ohjelmassa toiminnon, jota ei ole määritelty operandiobjektille, hän siirtyy operandiin liittyvään metataulukkoon, löytää siitä vastaavan metamenetelmän ja kutsuu sen.

--[[ Luo summaustoiminto taulukoille ]] -- Operandit t1 = { 1 , 2 , 3 } t2 = { 10 , 20 , 30 } -- Luo metataulukko mt = {} -- Kirjoita metataulukko "__add" mt metataulukkoon . __add = funktio ( a , b ) paikallinen res = {} k :lle pareittain ( a ) do res [ k ] = a [ k ] + b [ k ] end return res end -- Sido metataulukko taulukkoon t1 setmetatable ( t1 , mt ) -- Taulukon lisäys on nyt kelvollinen operaatio t3 = t1 + t2 -- yhdistä metataulukko t3 : een metamenetelmällä __tostring setmetatable ( t3 , { __tostring = funktio ( t ) local res = " \ n " for _ , v pareittain ( t ) do res = res .. tostring ( v ) .. "-" end return res .. " \n " end }) -- Tämä tulostaa: "11-22-33-" for _ , v in ipairs ( t3 ) do io.write ( v , "," ) lopputulostus ( tostring ( t3 )) -- tulostaa "11,22,33",

Lua tukee metametodeja kaikille aritmeettisille ja vertailuoperaatioille, jotta niitä voidaan käyttää aritmetiikkaan kaikissa ohjelmoijan luomissa objekteissa. Vakiomenetelmien lisäksi voit käyttää niin sanottuja "kirjasto"-metamenetelmiä, joita ei tue kielen ydin, vaan tietyt kirjastot. Yllä olevassa esimerkissä tämä on merkkijonokirjaston __tostringtukema metamenetelmä; tämä menetelmä muuntaa taulukon merkkijonoksi.

Ala kiinnostaa eniten __index. Sitä kutsutaan, kun tulkki yrittää lukea taulukon elementtiä, mutta ei löydä sitä. Kenttä __indexvoi viitata joko taulukkoon tai menetelmään. Ensimmäisessä tapauksessa tulkki, joka ei löydä haluttua arvoa päätaulukosta, etsii sitä taulukosta __index. Toisessa vaiheessa taulukkoon pääsyn sijaan tätä menetelmää kutsutaan. Määrittämällä taulukoita tai metamenetelmiä tietylle kentälle Lua voi toteuttaa periytymisen, piilottaa objektitiedot, seurata taulukkotietojen toimintoja ja paljon muuta.

Olio-ohjelmointi

OOP:n perusta Luassa ovat taulukot. Periaatteessa taulukko on OOP-merkityksessä objekti, koska siinä voi olla tunnisteilla nimettyjä kenttiä ja niihin voi tallentaa mielivaltaisia ​​arvoja (objektin ominaisuuksia) ja toimintoja objektin käyttäytymisen toteuttamiseksi (objektimenetelmät). Osa Luan tarjoamasta syntaktisesta sokerista tekee objektien kuvauksesta ja käsittelystä tutumpaa perinteisistä OOP-kielistä kokeneille ohjelmoijille. Luassa ei ole käsitettä “ luokka ”, joten kuvataan erillinen objekti ja kaikki kentät ja menetelmät viittaavat erityisesti siihen. Ominaisuudet kuvataan samalla tavalla kuin taulukkoelementit tunnisteavaimilla, menetelmät kuvataan funktiokenttinä. Klassisen Oberonin tapaan menetelmien kuvaus sisältää nimenomaisen merkinnän niin sanotun "vastaanottimen" ensimmäisessä parametrissa - parametrin, joka, kun menetelmää kutsutaan, viittaa objektiin, jota varten sitä kutsutaan. Mutta tavallisen viittauksen taulukkokenttään pisteen kautta, mikä edellyttää vastaanottajan nimenomaista määrittämistä metodikutsussa, Lua tukee ylimääräistä syntaksia: kun menetelmän otsikko kirjoitetaan muodossa " Объект:метод" metodikutsussa tai kuvauksessa. , silloin vastaanottajaa ei ole määritetty. Samaan aikaan menetelmän rungossa se on edelleen saatavana nimellä self:

-- Objektitili = { -- Objektin " tilin " tunnus , nimi , saldo = 0 , -- kohteen ominaisuudet: numero, nimi, saldohyvitys = funktio ( itse , v ) -- menetelmä "kulut" - kuvaus objektin sisällä eksplisiittinen, joka määrittää vastaanottajan, jos se on itse . tasapaino < v sitten virhe "Riittävä tasapaino" end self . tasapaino = itse . saldo - v loppu } toiminto Tili : debet ( v ) -- "saapuva" menetelmä - ulkoinen lyhyt kuvaus (itse ei määritetä) itse . tasapaino = itse . saldo + v loppu Tili . debet ( tili , 10000 ) -- menetelmäkutsu - pitkä versio Tili : luotto ( 5000 ) -- menetelmäkutsu - lyhyt versio

Periytys, mukaan lukien moniperintö, toteutetaan metataulukoilla ja metamenetelmillä. Lisäksi metamenetelmien avulla voidaan toteuttaa tietojen piilottaminen ja kontrolloitu pääsy taulukkoobjektin kenttiin. Jos vertaat tätä lähestymistapaa muihin kieliin, joissa kaikki yllä oleva on toteutettu erityisillä kielityökaluilla, voit nähdä, että Lua-toteutus on monimutkaisempi ja vaatii huolellisempaa koodausta, mutta tarjoaa enemmän joustavuutta ja yksinkertaistaa tulkkia.

Koodiesimerkkejä

Klassinen ohjelma " Hei, maailma!" » Luassa näyttää tältä:

tulosta ( "Hei maailma!" )

Factorial  on esimerkki rekursiivisesta funktiosta:

funktio factorial ( n ) jos n == 0 sitten palauttaa 1 muuten return n * factorial ( n - 1 ) loppupää _

Silmukka laskurilla :

jos i = 1 , 5 do -- ohjeet/operaatiot loppuvat

Toimintojen käsittely ensiluokkaisina objekteina on esitetty seuraavassa esimerkissä, joka muuttaa tulostusfunktion käyttäytymistä:

do local oldprint = print -- Tallenna nykyinen tulostusfunktio vanhana tulostusfunktiona print ( s ) -- Määritä tulostustoiminto uudelleen, jos s == "foo" sitten oldprint ( "bar" ) muuten oldprint ( t ) end end end

Kaikki tulevat puhelut printohjataan nyt uuteen toimintoon, ja Luan leksikaalisen kontekstin tuen ansiosta vanha tulostustoiminto on käytettävissä vain uuden, muokatun tulostustoiminnon kautta. Lua tukee myös sulkemisia , kuten yllä olevassa vastaavassa osiossa on kuvattu.

Luan keskeinen ominaisuus on sen laajennettavissa oleva semantiikka, ja metataulukkomekanismi antaa paljon tilaa Lua-taulukoiden ainutlaatuisen käyttäytymisen mukauttamiseen. Seuraava esimerkki esittää "ääretön" taulukon. Jokaiselle antaa -th Fibonacci numero käyttämällä muistiinpanoa . fibs[n]

fibs = { 1 , 1 } -- fibs[1] ja fibs[2] alkuarvot. setmetatable ( fibs , { __index = funktio ( nimi , n ) -- Kutsu toimintoa, jos fibs[n] ei ole olemassa. name [ n ] = nimi [ n - 1 ] + nimi [ n - 2 ] -- Laske ja muista fibejä [n] .return name [ n ] end })

Lua antaa sinun käyttää myös loogisia operaattoreita andsyöttääksesi kolmiosaisia ​​rakenteita , kuten esimerkiksi C# :ssa, tai viitata johonkin olemassa olevista objekteista.or

do local num = tonumber ( io.read ()) -- Kirjoita muuttujaan konsolista syötetyt tiedot ja muunna ne kokonaislukutyyppiseksi tulosteeksi ( num == 1 ja "Annoit oikean numeron" tai "Kirjoitit väärä numero" ) -- Jos num-muuttuja on yhtä suuri kuin 1, ja sen jälkeen oleva teksti näytetään konsolissa, kaikissa muissa tapauksissa jälkeen tai lopussa

Olemassa olevan taulukon käyttäminen ja arvon saaminen ensimmäisestä indeksistä:

do local tbl = nolla paikallinen tbl2 = { 1 } print ( ( tbl tai tbl2 )[ 1 ] ) -- Numero 1 tulostetaan , koska taulukon tbl2 arvo on indeksin 1 lopussa

Funktion kutsuminen yhdestä olemassa olevista taulukoista:

tee paikallinen tbl = nolla paikallinen tbl2 = {} tbl2 . DoSomething = toiminto () print ( "Tee jotain" ) end ( tbl tai tbl2 ). DoSomething () loppu

Toteutus

Kuten monet tulkitut ohjelmointikielet , Lua -toteutuksessa on erillinen kääntäjä lähdekielestä suoritettavaan tavukoodiin ja virtuaalikone, joka suorittaa luodun tavukoodin. Lisäksi tavukoodi ei ole pinokoneen komentoja, vaan tietyn virtuaalisen prosessorin komentoja, joissa on useita rekistereitä, mikä lisää suoritustehokkuutta. Tavallinen Lua - virtuaalikone käyttää muistin varausta roskienkeräyksen kanssa (samanlainen kuin Java tai .NET).

Lua käyttää yhtä merkkijonoa , mikä vähentää merkkijonojen tallentamisesta aiheutuvaa muistia.

Aikakriittisiä tehtäviä varten on JIT - Lua -kääntäjä  - LuaJIT [15] . Lisäksi on kehitetty kääntäjä llvm-lua [16] , joka luo koodia LLVM -virtuaalikoneelle , joka tarjoaa mahdollisuuden myöhempään käännökseen erittäin tehokkaaksi konekoodiksi eri arkkitehtuurien prosessoreille.

Käyttö

Sitä käytetään tällä hetkellä erilaisissa projekteissa, joissa vaaditaan melko nopean ja helposti opittavan skriptiohjelmointikielen rakentamista – esimerkiksi pelikehityksessä , jossa Luaa käytetään usein kerroksena pelimoottorin ja käsikirjoitettavan datan välillä. esineiden käyttäytyminen ja vuorovaikutus. Kompaktuutensa ansiosta se soveltuu myös kannettaviin laitteisiin, erityisesti yksi Texas Instrumentsin graafisista laskimista käyttää kieltä BASIC -kielen sijaan, joka on perinteisesti tälle laiteluokalle .

Pelit

LucasArts toi ensimmäisenä Lua - kielen osaksi tietokonepelien kehitystä, alkaen Grim Fandango -pelistä [17] . Kielen kirjoittajat raportissaan HOPL- konferenssissamuistaa, että tammikuussa 1997 he saivat viestin Bret Mogilefskyltä, Grim Fandangon pääkehittäjältä, jossa hän kirjoitti, että hän oli lukenut kielestä vuoden 1996 artikkelissa Dr. Dobb's Journal , hän aikoo korvata heidän kotitekoisen komentosarjakielen SCUMM Lualla [18] . Tämän seurauksena hän loi GrimE - pelimoottorin , jota käytetään myös LucasArts - Escape from Monkey Islandin myöhemmässä tehtävässä .

Vuonna 2003 GameDev.net- tutkimuksessa Lua sijoittui suosituimmaksi komentosarjakieleksi pelien kehittämisessä [9] .

Esimerkki Lualla ohjelmoidusta pelistä on World of Warcraft [19] [20] . Pulmapeli Enigma [21] tasot on kuvattu lua -kielellä .

Saatavilla on useita ilmaisia ​​pelimoottoreita, jotka voidaan ohjelmoida Luassa, kuten Defold [22][ tosiasian merkitys? ] , LÖVE - pelihallimoottori [23] [24] , pelisuunnittelija Novashell [25] ja seikkailusuuntautunut (enimmäkseen tekstipohjainen ) SIJAAN [ 26] .

Käytetään myös X-Planen lentosimulaattorissa, STALKERin röntgenmoottorissa [ 27] .

Suosittua Minecraft -peliä varten on luotu ComputerCraftin ja sen kehittyneemmän analogisen OpenComputersin muunnelmia, jotka lisäävät Lua-kielellä ohjelmoituja tietokoneita [28] .

Kuuluisa peli Garry's Mod on ohjelmoitu ja tukee myös Luassa kirjoitettuja muutoksia.

Croteam -tiimi ( Serious Samin ja The Talos Principlen kehittäjät ) on käyttänyt Luaa käsikirjoituksessa Serious Engine 3.5:stä lähtien [ 29] .

Peliin GTA: San Andreas luodaan Lua-kielellä kirjoitettuja muutoksia, joita Moonloader-laajennus tukee. [30] Multi Theft Auto tukee myös Lua-käsikirjoitusta.

Roblox - pelialusta käyttää Luaa pelien koodauskielenä ja peliympäristön hallintaan [31] .

Ficsit-Networks modin on luonut Satisfactory peliyhteisö , mikä mahdollistaa minkä tahansa toiminnon ohjelmoinnin Lua-kielellä [32] .

Factorio käyttää Luaa modien luomiseen. [33] [34]

Dual Universe -peliä käytetään pelin sisäiseen mekaniikkaan ja pelilohkoohjelmointiin

LuaTeX

Tietokoneen ladontakone LuaTeX , pdfTeX:n laajennettu versio , käyttää Luaa sisäänrakennetun komentosarjakielenään [35] .

RPM

RPM - paketinhallinta sisältää sisäänrakennetun Lua-tulkin [36] .

IDE

Lualle on olemassa ainakin kaksi "natiivia" kehitysympäristöä , nämä ovat:

  • ZeroBrane Studio [37]  on monikäyttöinen kehitysympäristö, joka on kirjoitettu itse Luaan.
  • Decoda on C++ -  kielellä kirjoitettu Windows-kehitysympäristö, jossa on runsaasti virheenkorjausominaisuuksia Lua-skripteille, myös käynnissä oleville sovelluksille. Vuodelle 2018 ympäristön viimeisin julkaisu on vuodelta 2014, ja sen tila on beta-versio.

Lisäksi Luaa tukevat jotkut universaalit IDE:t, erityisesti:

  • Geany
  • Lua Development Tools [38] Eclipse - ympäristöön
  • EmmyLua-laajennus IntelliJ IDEA -ympäristöön , joka on myös varustettu lennossa tapahtuvalla syntaksin tarkistuksella ja edistyneellä tyyppimerkintöjen järjestelmällä [39]

NetBeans -ympäristössä oli Lua- tukimoduuli , mutta se lopetettiin vuonna 2013 ja on saatavilla vain NetBeans 7.4:lle ja sitä vanhemmille versioille. Laajennusta ei tueta NetBeans 8:ssa.

Katso myös

  • Lua Lua käyttävistä sovelluksista

Muistiinpanot

  1. ↑ 1 2 https://www.lua.org/authors.html
  2. ↑ Lua: noin
  3. ↑ Lua 5.1 -viiteopas – 2019.
  4. ↑ Katsaus Luan suunnitteluun  - [ New York] : Association for Computing Machinery , 2018. - ISSN 0001-0782 ; 1557-7317
  5. ↑ https://www.lua.org/license.html
  6. ↑ Lua Open Source -projekti Open Hubissa: Lisenssisivu - 2006.
  7. ↑ https://www.lua.org/about.html
  8. ↑ Tietoja Luasta . Lua.org. Haettu 19. kesäkuuta 2013. Arkistoitu alkuperäisestä 26. joulukuuta 2018.
  9. ↑ 1 2 Mitä kieltä käytät pelimoottorisi komentosarjaan?. GameDev.net - Äänestyksen tulokset
  10. ↑ 1 2 Biancuzzi, Warden, 2011 , s. 216.
  11. ↑ Laajennuskielen kehitys: Luan historia (2001). Haettu 24. elokuuta 2016. Arkistoitu alkuperäisestä 14. lokakuuta 2017.
  12. ↑ HOPL, 2007 , s. 2–1–2–26.
  13. ↑ Lua: laajennettava sulautettu kieli. Muutamat metamekanismit korvaavat joukon ominaisuuksia  (joulukuu 1996), s. 26–33. Arkistoitu alkuperäisestä 20. lokakuuta 2014. Haettu 20.9.2014.
  14. ↑ Lua 5.1 -viiteopas . Haettu 5. marraskuuta 2019. Arkistoitu alkuperäisestä 15. marraskuuta 2013.
  15. ↑ LuaJIT-projekti . Haettu 18. toukokuuta 2009. Arkistoitu alkuperäisestä 16. huhtikuuta 2009.
  16. ↑ llvm-lua. JIT/Staattinen kääntäjä Lualle käyttäen LLVM:ää taustalla. . Haettu 21. tammikuuta 2009. Arkistoitu alkuperäisestä 22. tammikuuta 2009.
  17. ↑ Bret Mogilefsky. Lua Grim Fandangossa . Haettu 9. joulukuuta 2011. Arkistoitu alkuperäisestä 4. helmikuuta 2012.
  18. ↑ HOPL, 2007 , s. yksitoista.
  19. ↑ Paul Emmerich. Alkaen Lua World of Warcraft Addonsilla. - Apress , heinäkuu 2009. - ISBN 1430223715 .
  20. ↑ James Whitehead II, Bryan McLemore ja Matthew Orlando. World of Warcraft -ohjelmointi . - Wiley , toukokuu 2008. - ISBN 0470229810 .
  21. ↑ Tom Gutschmidt. Ch. 8. Lua-peliyhteisö → Pelimoottorit // Peliohjelmointi Pythonilla, Lualla ja Rubylla . - Premier Press, 2003. - 472 s. - ISBN 1-59200-079-7 .
  22. ↑ Defold pelin kehitysopas - Lua in Defold . Defold pelimoottori. Haettu 2. maaliskuuta 2017. Arkistoitu alkuperäisestä 3. maaliskuuta 2017.
  23. ↑ Dj Walker-Morgan. H-nopeusopas Luaan → Kehittäminen Luan kanssa . H (17. huhtikuuta 2012). Haettu 26. helmikuuta 2015. Arkistoitu alkuperäisestä 26. helmikuuta 2015.
  24. ↑ Darmie Akinlaja. LÖVE Lua-peliohjelmointiin. - Paketti, 2013. - 106 s. — ISBN 978-1-78216-160-8 .
  25. ↑ Alan Thorne. Luku 8. Novashell ja 2D-pelit // Cross Platform Game Development . - Jones & Bartlett Learning, 2008. - S.  225-264 . — 421 s. — ISBN 978-1-59822-056-8 .
  26. ↑ Pjotr ​​Kosykh. SIVU: Kuinka kaikki alkoi  // IFprint.org. - 18. maaliskuuta 2013. - Numero. 1 . — ISSN 2307-535X . Arkistoitu alkuperäisestä 26. helmikuuta 2015.
  27. ↑ Ronnie Tucker. Full Circle -lehti #90: UBUNTU LINUX -YHTEISÖN ITSENÄINEN LEHTI . - Full Circle -lehti, 31.10.2014. -50 s.
  28. ↑ Matthew Monk, Simon Monk. ComputerCraft: Lua-ohjelmointi Minecraftissa . - CreateSpace Independent Publishing Platform, 28.1.2013. – 58 s. — ISBN 9781481927659 .
  29. ↑ Zero_Cool. Tekniikan historia - vakava moottori | historia | GPU testi . gamegpu.com. Haettu 10. huhtikuuta 2016. Arkistoitu alkuperäisestä 20. huhtikuuta 2016.
  30. ↑ Suosikit - Lua - ASI - MoonLoader  (venäläinen) , BlastHack - Huijaaminen taiteena . Arkistoitu alkuperäisestä 29. tammikuuta 2018. Haettu 28.1.2018.
  31. ↑ Opi Roblox | Koodaus ja komentosarjat . developer.roblox.com Haettu 23. elokuuta 2019. Arkistoitu alkuperäisestä 23. elokuuta 2019.
  32. ↑ FicsIt-Networks :: Tyydyttävä  modifiointidokumentaatio . docs.fixit.app . Haettu: 24.3.2022.
  33. ↑ Modding - Factorio Wiki . wiki.factorio.com . Haettu 1. kesäkuuta 2022. Arkistoitu alkuperäisestä 1. kesäkuuta 2022.
  34. ↑ API Docs | factorio . lua-api.factorio.com . Haettu 1. kesäkuuta 2022. Arkistoitu alkuperäisestä 18. toukokuuta 2022.
  35. ↑ CTAN : Paketti luatex  . Haettu 6. helmikuuta 2019. Arkistoitu alkuperäisestä 7. helmikuuta 2019.
  36. ↑ Lua RPM  :ssä . Haettu 11. helmikuuta 2019. Arkistoitu alkuperäisestä 24. kesäkuuta 2018.
  37. ↑ ZeroBrane Studio - Lua IDE/editori/debuggeri Windowsille, Mac OSX:lle ja Linuxille . Haettu 31. heinäkuuta 2013. Arkistoitu alkuperäisestä 18. tammikuuta 2016.
  38. ↑ Lua-kehitystyökalut . Haettu 14. helmikuuta 2012. Arkistoitu alkuperäisestä 9. helmikuuta 2012.
  39. ↑ EmmyLua :: JetBrains Plugin  Repository . JetBrains Plugin Repository. Käyttöpäivä: 26. helmikuuta 2018. Arkistoitu alkuperäisestä 27. helmikuuta 2018.

Kirjallisuus

  • Roberto Jerusalem. Ohjelmointi Lua-kielellä. - 3. painos. - DMK, 2014. - ISBN 9785940747673 . (alkuperäinen: Roberto Ierusalimschy. Ohjelmointi luassa. - 3. painos - 2012. - ISBN 9788590379850 . )
  • Ian Dees. Lua // Seitsemän muuta kieltä seitsemässä viikossa. Kielet, jotka muokkaavat tulevaisuutta / Bruce Tate, Fred Daoud, Jack Moffitt, Ian Dees. - Pragmaattinen kirjahylly, 2015. - S. 1-48. – 320 s. — ISBN 978-1941222157 .
  • Mario Kasuba. Lua Game Development Cookbook. - Packt Publishing, 2015. - 402 s. — ISBN 978-1849515504 .
  • David Young. Pelin tekoälyohjelmoinnin oppiminen Luan kanssa. - Packt Publishing, 2014. - 352 s. — ISBN 978-1783281336 .
  • Jayant Varma. Opi Lua iOS-pelien kehittämiseen . - Apress, 2012. - 410 s. — ISBN 9781430246626 .
  • Kurt Jung, Aaron Brown. Lua-ohjelmoinnin aloittaminen . - John Wiley & Sons, 2011. - 675 s. - (Ohjelmoija ohjelmoijalle). — ISBN 9781118079119 .
Kielihistoria
  • R. Ierusalimschy, LH de Figueiredo, W. Celes. Luan kehitys  // Proceedings of ACM HOPL III. 2-1-2-26. – 2007.
  • Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes. Laajennuskielen kehitys: Luan historia . Uusintapainos Proceedings of V Brazilian Symposium on Programming Languages ​​​​(2001) B-14–B-28. Haettu 9. joulukuuta 2011. Arkistoitu alkuperäisestä 4. helmikuuta 2012.
  • Federico Biancuzzi, Shane Warden. Luku 7. Lua // Ohjelmointi Pioneers. Keskustelut tärkeimpien ohjelmointikielten luojien kanssa = ohjelmoinnin päämiehiä: keskusteluja tärkeimpien ohjelmointikielten luojien kanssa. - Symboli, 2011. - S. 211-230. — 608 s. - 1500 kappaletta.  — ISBN 9785932861707 .
  • Robert Yeruzalimskyn haastattelu Computerworldille lua - kielestä

Katso myös

  • Orava  - Lua-pohjainen ohjelmointikieli

Linkit

Lua venäjäksi

Ohjeiden käännökset Artikkelit ja arvostelut
 Lua
KääntäjätKehykset ja DLL:tPortit ja jakelutIDE:tSovellukset
 Ohjelmointikielet