Lua

Lua
Språkklass funktionellt programmeringsspråk , objektorienterat programmeringsspråk , skriptspråk , multiparadigm programmeringsspråk , imperativt programmeringsspråk , prototyporienterat programmeringsspråk , prototyporienterat programmeringsspråk [d] , tolkat programmeringsspråk , kompilerat programmeringsspråk , fri programvara och filformat
Framträdde i 1993 [2]
Författare Roberto Jeruzalimski ,
Valdemar Selish,
Luis Enrique de Figueiredo
Utvecklaren Robert Jeruzalimsky [1]
Filtillägg _ .lua[3] [4] ,.luna,.lunaireeller.anair
Släpp 5.4.4 (26 januari 2022)
Typ system dynamisk , stark , anka
Blivit påverkad C++ , Clu , Simple Object Language [d] , DEL , Snobol , Modula , Modula-2 och Scheme
påverkas JavaScript
Licens MIT-licens [5] [6]
Hemsida lua.org ​(  engelska) ​(  port)
OS plattformsoberoende [7]
 Mediafiler på Wikimedia Commons

Lua ( lua ,  port.  -  "måne" [8] ) är ett programmeringsspråk för skript som utvecklats i Tecgraf ( Computer Graphics Technology Group ) division vid det katolska universitetet i Rio de Janeiro ( Brasilien ). Språktolken är en gratis C -språktolk med öppen källkod .

När det gäller ideologi och implementering är Lua-språket närmast JavaScript , i synnerhet implementerar det också OOP - prototypmodellen , men skiljer sig i Pascal-liknande syntax och mer kraftfulla och flexibla konstruktioner. En karakteristisk egenskap hos Lua är implementeringen av ett stort antal mjukvaruenheter med ett minimum av syntaktiska medel. Så alla sammansatta användardefinierade datatyper ( matriser , strukturer , uppsättningar , köer , listor ) implementeras genom tabellmekanismen och objektorienterade programmeringsmekanismer , inklusive multipelt arv  , med hjälp av metatabeller , som också är ansvariga för överbelastningsoperationer och en antal andra funktioner.

Lua är avsedd för användare som inte är professionella programmerare, som ett resultat av vilket mycket uppmärksamhet ägnas åt enkel design och lätt att lära. Språket används ofta för att skapa replikerbar programvara (till exempel är det grafiska gränssnittet för Adobe Lightroom -paketet skrivet i det ). Fick även framträdande plats som ett programmeringsspråk för nivåer och tillägg i många spel (inklusive Garry's Mod ) [9] .

Historik

Språket utvecklades av Tecgraf-avdelningen (datorgrafikteknikgrupp) vid det katolska universitetet i Rio de Janeiro i Brasilien, språkets historia går tillbaka till 1993. Språkets författare är Roberto Jeruzalimski , Luiz Henrique de Figueiredo och Waldemar Celes . Lua distribueras fritt, öppen källkod på C-språket .

Som Luis Enrique de Figueiredo noterade, är Lua det enda programmeringsspråk som utvecklats i ett utvecklingsland som har fått världsomspännande erkännande, vilket i synnerhet uttrycktes i en inbjudan till HOPL- konferensen [10] .

Språkets historiska föräldrar var konfigurations- och databeskrivningsspråken SOL (Simple Object Language) och DEL (Data-Entry Language) [11] , de utvecklades oberoende av Tecgraf 1992-1993 för att lägga till viss flexibilitet till två separata projekt (båda var interaktiva grafikapplikationer för designbehov hos Petrobras ). SOL och DEL saknade några kontrollkonstruktioner, och Petrobras kände ett växande behov av att lägga till fullständig programmering till dem.

Som språkets författare skriver i The Evolution of Lua : [12]

År 1993 var den enda riktiga utmanaren Tcl , som var speciellt utformad för att bäddas in i applikationer. Tcl hade dock en okänd syntax, saknade bra stöd för databeskrivningar och körde bara på Unix- plattformar . Vi har inte övervägt Lisp eller Scheme på grund av deras ovänliga syntax. Python var fortfarande i sin linda. I den gör-det-själv-atmosfär som rådde på Tecgraf vid den tiden var det helt naturligt att vi bestämde oss för att utveckla vårt eget skriptspråk. På grund av det faktum att de flesta av användarna inte var professionella programmerare, var språket tvunget att undvika invecklad syntax och semantik. Implementeringen av det nya språket måste vara lätt att bära eftersom Tecgrafs kunder hade mycket olika plattformar. Slutligen, eftersom vi förväntade oss att andra Tecgraf-produkter också skulle behöva ett inbäddat skriptspråk, bör det nya språket följa exemplet med SOL och tillhandahållas som ett bibliotek med en C API .

Lua 1.0 designades på ett sådant sätt att objektkonstruktörer, då något annorlunda än den nuvarande lätta och flexibla stilen, inkluderade syntaxen för SOL-språket (därav namnet Lua: på portugisiska sol  - "sol", lua  - "måne") . Lua-kontrollkonstruktioner är mestadels lånade från Modula-2 (if, while, repeat/tills), även om de också påverkas av Clu ( parallell tilldelning , returvärde för flera funktioner som ett enklare alternativ till att skicka parametrar genom referens eller explicita pekare ), C++ ("Det är en bra idé att bara deklarera lokala variabler när du behöver dem"), Snobol och awk ( associativa arrayer ). Skaparna av Lua erkänner också att den enda allestädes närvarande datastruktureringsmekanismen i Lisp and Scheme ( länkad lista ) var en stor inverkan i deras beslut att välja tabeller som den primära datastrukturen för Lua [13] .

Versioner av Lua upp till 5.0 släpptes under en licens som liknar BSD-licensen . Från version 5.0 och framåt distribueras Lua under MIT-licensen . Båda licenserna är tillåtande och praktiskt taget identiska.

Allmänna egenskaper

Lua är tänkt att användas som ett fristående skriptspråk eller inbyggt i en applikation. Den designades ursprungligen för att vara enkel och kompakt nog att passa på en mängd olika plattformar och ge acceptabel prestanda. Designen tog också hänsyn till kraven på enkel inlärning och möjligheten att använda av icke-professionella programmerare.

Lua är ett processuellt dynamiskt typat modulspråk med automatisk minneshantering . Innehåller grundläggande element för att stödja funktions- och objektprogrammeringsstilar . Således kan Lua kallas ett språk med flera paradigm . De inbyggda parallellprogrammeringsverktygen låter dig skriva flertrådade program med enbart språkverktyg, utan att hänvisa till operativsystemets API eller externa bibliotek. Eftersom Luas huvudsakliga syfte är inlining, har den effektiv interoperabilitet över flera språk, främst fokuserad på att anropa C -bibliotek och arbeta i en C-miljö.

Språket stöder ett litet antal inbyggda datatyper: booleans, siffror, strängar, funktioner, strömmar. Det finns inga typiska kombinerade datastrukturer som arrayer , uppsättningar , listor och poster , istället för alla används en grundläggande Lua-struktur, tabellen (se nedan). En separat typ userdataär utformad speciellt för lågnivåprogrammering och datautbyte med extern kod på andra språk. Funktioner i Lua är förstklassiga objekt och kan tilldelas och skickas som parametrar. Stängningar stöds, det är möjligt att skapa funktioner av högre ordning. Objektsystemet är prototypiskt, det finns inget uttryckligt stöd för arv , men det implementeras enkelt med hjälp av metatables .

I allmänhet syftar Lua till att tillhandahålla flexibla metafunktioner som kan utökas efter behov, snarare än att tillhandahålla en uppsättning funktioner som är specifika för ett visst programmeringsparadigm. Som ett resultat är det underliggande språket enkelt och lätt att anpassa till de flesta applikationer. Genom att tillhandahålla en minimal uppsättning grundläggande faciliteter försöker Lua hitta en balans mellan kraft och storlek.

Syntax

Luas syntax är mestadels byggd på sena Pascal-liknande språk som Modula-2 eller Oberon . Textinmatningsformatet är gratis, kommandon i programtexten är åtskilda av blanksteg. Det är tillåtet, men inte nödvändigt, att använda semikolon för att separera operationer.

I en intervju med Robert Jeruzalimski påpekade han att Lua-syntaxen var en kompromiss han var tvungen att göra för att göra det lättare för icke-professionella programmerare att lära sig språket. Han beskrev syntaxen som "ganska ordrik", och noterade att han personligen skulle ha föredragit en mer koncis notation [10] .

Ordförråd

Språkets huvudalfabet är engelska, tecken från andra språk kan användas i bokstavliga strängar. Identifierare kan bestå av bokstäver, siffror och understreck, men kan inte börja med en siffra eller matcha ett av nyckelorden. Språkguiden rekommenderar inte att du använder identifierare som börjar med ett understreck, eftersom sådana identifierare används för systemändamål.

Språket är skiftlägeskänsligt, alla nyckelord skrivs med gemener, identifierare som skiljer sig endast vid bokstäver anses olika. Följande 22 nyckelord kan inte användas för namn [14] :

och bryt gör annat om sluta falskt gå till funktion om i lokal noll inte eller upprepa returnera sedan sant tills medan

Kommentarer

Kommentarer använder följande syntax, liknande Ada , SQL och VHDL :

-- En enkel enkelradskommentar i Lua börjar med ett dubbelt minus och fortsätter till slutet av raden. dim = { "en" , "två" , "tre" } -- En radkommentar behöver inte börja i början av en rad -- den kan följa andra språkkonstruktioner -- för att förklara dem. --[[En kommentar med flera rader börjar med två på varandra följande öppna hakparenteser följt av två minus och fortsätter genom två på varandra följande avslutande hakparenteser. Som här: ]] -- En intressant effekt kan erhållas genom att kombinera inline- och flerradskommentarer: --[[ För att avkommentera koden nedan räcker det att lägga till ett mellanslag på denna rad mellan minus och parentes. för i=1,#dim do print(dim[i]) end -- Om ett mellanslag läggs till mellan minustecken och parentes ovan, då --]] -- här kommer slutet av flerradskommentaren att bli till en normal linje

Datatyper

Lua är ett språk med implicit dynamisk datatypsdefinition . En språkvariabel kan innehålla värden av vilken typ som helst. Alla värden i Lua kan lagras i variabler, användas som argument för funktionsanrop och returneras som ett resultat av deras exekvering.

Det finns åtta huvudtyper i Lua:

  • noll (odefinierad)
  • boolean (boolean)
  • nummer (numeriskt)
  • sträng _
  • funktion (funktion)
  • användardata (användardata)
  • tråd (tråd)
  • bord (bord)

noll  är värdetypen noll [tomt värde], vars huvudsakliga egenskap är att skilja sig från alla andra värden och beteckna frånvaron av ett användbart värde.

Den booleska typen inkluderar värdena false (false) och true (true).

Taltypen innehåller vanligtvis reella tal (dubbla) . I de första versionerna av Lua var inte heltal separerade i en separat typ; detta beslut motiveras av det faktum att den verkliga representationen tillåter dig att korrekt representera ett ganska brett spektrum av heltal. Från och med version 5.3 har möjligheten att uttryckligen definiera ett heltals- eller reellt talsformat lagts till. Den interna representationen av siffror kan ändras när du bygger tolken.

Strängtypen anger teckenuppsättningar. Lua-strängar kan innehålla vilket 8-bitars tecken som helst, inklusive noll ('\0'). Strängar är oföränderliga. Strängliteraler kan skrivas med enkla eller dubbla citattecken, servicetecken placeras i dem i standard C-notation med ett inledande snedstreck. Flerradiga bokstaver avgränsas av två på varandra följande öppnande och två på varandra följande avslutande hakparenteser.

Det finns inget Unicode-stöd inbyggt i språket, även om användningen av UTF-8-tecken i strängliteraler är tillåten, och själva UTF-8-representationssystemet låter dig mata in, mata ut och delvis bearbeta strängar i denna kodning med standardsystemverktyg . Nya versioner av Lua inkluderar utf8-biblioteket, som ger mer avancerat stöd för UTF-8, och det finns tredjepartsbibliotek som tillhandahåller verktyg för att arbeta med Unicode-strängar i olika kodningar.

Funktioner i Lua är fullfjädrade objekt som kan tilldelas, skickas som en parameter till en funktion och returneras som ett av värdena. Trådtypen har koroutiner, användardatatypen är designad för att representera extern data som tas emot eller tillhandahålls från/till kod på ett annat språk (främst C/C++).

Operationer

Uppdrag Tilldelningsoperatorn är symbolen =. Liksom skriptspråk som Perl , Python , Ruby och Icon , tillåter samtidig tilldelning . I det enklaste fallet låter detta dig skriva uttryck som: x , y = y , x Till skillnad från till exempel Go är parallelltilldelning i Lua väldigt liberal, den kräver inte att antalet variabler exakt matchar antalet värden. Om det finns fler värden än variabler så kasseras de sista värdena; om det finns färre värden får de sista variablerna i listan värdet noll. Jämförelser och logiska operatorer Jämförelseoperatorer: <, >, <=, >=, ==, ~= (de två sista betyder jämförelse för jämlikhet respektive för ojämlikhet). Jämförelser för jämlikhet och ojämlikhet är tillämpliga på alla datatyper, andra - bara för strängar och siffror. Logiska operatorer: and, or, not - logiska "och", "eller" respektive "inte" kan appliceras på värden av vilken typ som helst och returnera sant eller falskt. I parametrarna för dessa operationer anses värdena noll och false vara falska, alla andra värden är sanna. Till skillnad från C och ett antal andra språk, representerar även en numerisk nolla (0) eller en tom sträng ("") ett "sant" värde i termer av logiska operatorer. Utvärdering av binära logiska operatorer utförs traditionellt tills resultatet har fastställts, varvid det senast utvärderade subuttrycket returneras som resultat. Därför kan de användas som en ternär operator ?:i C: -- liknande r = (a < b)? f(a): f(b); i C, r = ( a < b ) och f ( a ) eller f ( b ) -- kommer r att få värdet på funktionen f() från det minsta av de två värdena a och b, -- förutsatt att f(a) är inte är noll eller falsk. Aritmetiska operatorer + - tillägg; - - subtraktion; * - multiplikation; / - division; - - unär minus ; % - resten av divisionen; ^ - exponentiering.

Alla aritmetiska operatorer stöder verkliga operander, vilket ger förutsägbara resultat. Returnerar till exempel x^0.5kvadratroten av x, x^(-1/3) den reciproka av kubroten av x. Operatorn %definieras av: a % b = a - math.floor(a / b) * b, där funktionen math.floor()utvärderas till heltalsdelen av dess argument. För heltalsargument är resultatet ganska normalt. För en riktig utdelning, tänk på att operationen inte utför någon ytterligare avrundning eller kassering av bråkdelen, så resultatet kommer att behålla bråkdelen av utdelningen. Till exempel kommer det math.pi % 2inte att returnera 1, men 1.1415926535898. Denna implementering ger några ytterligare funktioner. För att till exempel trunkera xtill tre decimaler räcker det att ta uttrycketx - x % 0.001

Tabeller

En tabell i Lua är en dynamisk heterogen associativ array , det vill säga en uppsättning par av " ключ-значение". Nycklar kan vara värden av vilken Lua-typ som helst förutom nil. Nycklar kan också vara Lua-literals (identifierare). Att skriva niltill ett tabellelement motsvarar att ta bort detta element.

Tabeller är den enda sammansatta datatypen i Lua. De är grunden för alla användardefinierade datatyper som strukturer , matriser , uppsättningar och andra:

-- Allmän tabell: tom = {} -- Tom tabell tom [ 1 ] = "första" -- Lägger till element med heltalsindex tomt [ 3 ] = "andra" -- Lägger till element med heltalsindex tomt [ "tredje" ] = "tredje" -- Lägg till element vid strängindex tomt [ 1 ] = noll -- Ta bort element från tabellen -- Klassiska array-strängar indexeras som standard med heltal som börjar från 1 dagar1 = { "måndag" , "tisdag" , "onsdag" , "torsdag" , "fredag" , "lördag" , "söndag" } -- Array med godtyckliga indexeringsdagar2 = { [ 0 ] = "Söndag" , [ 1 ] = "Måndag" , [ 2 ] = "Tisdag" , [ 3 ] = "onsdag" , [ 4 ] = "torsdag" , [ 5 ] = "fredag" , [ 6 ] = "lördag" } -- Rekord (struktur) - värden av olika typer indexeras efter bokstavlig person = { tabnum = 123342 , -- Personalnummer fio = "Ivanov Stepan Vasilyevich" , -- Fullständigt namn post = "verktygsmakare" , -- Befattningslön = 25800,45 , -- Lönedatum = "10/23/2013" , -- Anställd datum bdate = "08/08/1973" } -- Födelsedatum pfio = person . fio --Referens till strukturelement. -- Set-index används för att lagra värden workDays = {[ "Måndag" ] = sant , [ "tisdag" ] = sant , [ "onsdag" ] = sant , [ "torsdag" ] = sant , [ "fredag" " ] = sant } arbetsdagar [ "lördag" ] = sant -- Lägg till lördag till antalet arbetsdagar arbetsdagar [ "onsdag" ] = noll -- Vi arbetar inte längre på onsdagar -- Kontrollera om d är en arbetsdag om arbetsdagar [ d ] skriv sedan ut ( d .. " - arbetsdag " ) annars skriv ut ( d .. " - ledig dag " ) slut

Multiset (uppsättningar som kan innehålla mer än en instans av samma element) implementeras på samma sätt som det förra exemplet, bara värdena är inte logiska, utan heltal - räknare för antalet motsvarande element i uppsättningen. Länkade listor kan representeras som matriser av tvåelementsmatriser som innehåller ett värde och en referens till nästa element. Flerdimensionella arrayer kan implementeras som arrayer av arrayer. Mer komplexa strukturer som köer, grafer, nätverk implementeras också på basis av tabeller, den specifika implementeringsmetoden bestäms av uppgiften.

Stängningar

Lua stöder konceptet med stängningar , till exempel:

funktion makeaddfunc ( x ) -- Returnerar en ny anonym funktion som lägger till x till sin argumentreturfunktion ( y ) -- När vi hänvisar till en variabel x som ligger utanför det aktuella omfånget -- och vars livslängd är kortare än denna anonyma funktion - - - Lua skapar en stängning. return x + y end end plustwo = makeaddfunc ( 2 ) -- dvs plustwo = function(y) return 2 + y end print ( plustwo ( 5 )) -- Prints 7

Varje gång som anropas makeaddfuncskapas en ny stängning för variabeln x, så att varje returnerad anonym funktion kommer att referera till sin egen parameter x. Liksom alla andra Lua-objekt hanteras en förslutnings livslängd av sopsamlaren.

Medel och metoder för programmering

Metatables

Den metatable mekanismen ger många av de funktioner som andra språk tillhandahåller genom att introducera separata syntaktiska mekanismer. Metatabeller är genom strukturen vanliga Lua-tabeller, med förbehåll för alla språkets regler och begränsningar. Deras egenhet ligger i deras tillämpning. Metatabellen lagrar ytterligare metadata för typer och objekt, det vill säga information om de parametrar och funktioner som är associerade med dem. Informationen som lagras i metatabeller används av Lua-tolken, deras användning låter dig ändra eller utöka funktionaliteten för programobjekt.

En metatable i Lua kan associeras med ett värde av vilken typ som helst. Skalära datatyper (alla utom användardata och tabeller) har gemensamma metatabeller för varje typ. Tabellerna och värdena av en typ userdatahar individuella metatable referenser i varje instans. Ändring av metatabeller av alla typer utom tabeller kan endast göras genom extern C-kod. Endast bordsmetatabeller är tillgängliga direkt från Lua.

En Lua-tabell skapad från grunden har ingen metatable (dess metatable referens är noll). Men en metatable för det kan skapas när som helst eller erhållas från en annan tabell. Den inbyggda funktionen getmetatable(t)returnerar metatablen för tabell t, och funktionen setmetatable(t, m)ställer in tabell t till metatable m.

För metatabeller dokumenteras en uppsättning fält som kan användas av språktolken. För att indikera den speciella rollen för dessa fält har en speciell namnregel antagits för dem: deras identifierare börjar med två understreck. Vissa av dessa fält innehåller information om specifika egenskaper hos objektet som metatablen refererar till. Till exempel kan alternativet __mode, när det ges, göra en tabell svag , det vill säga en tabell vars objektreferenser alla är svaga referenser . Men värdena för de flesta av de möjliga metabara fälten är de så kallade metametoderna , det vill säga referenser till funktioner som tolken anropar under vissa förutsättningar. Den allmänna logiken för att använda metametoder av tolken är som följer: när tolken stöter på en operation i programmet som inte är definierad för operandobjektet, kommer den åt den metatabell som är associerad med operanden, hittar motsvarande metametod i den och anropar den.

--[[ Skapa additionsoperation för tabeller ]] -- Operander t1 = { 1 , 2 , 3 } t2 = { 10 , 20 , 30 } -- Skapa metatable mt = {} -- Skriv metametod "__add" mt till metatable . __add = funktion ( a , b ) lokal res = {} för k i par ( a ) do res [ k ] = a [ k ] + b [ k ] slut retur res slut -- Bind metatable till tabell t1 setmetatable ( t1 , mt ) -- Tabelltillägg är nu en giltig operation t3 = t1 + t2 -- sammanfoga metatable med t3 med metamethod __tostring setmetatable ( t3 , { __tostring = function ( t ) local res = " \n " för _ , v i par ( t ) do res = res .. tostring ( v ) .. "-" end return res .. " \n " end }) -- Detta kommer att skriva ut: "11-22-33-" för _ , v i ipairs ( t3 ) do io.write ( v , "," ) end print ( tostring ( t3 )) -- skriver ut "11,22,33,"

Lua stöder metametoder för alla aritmetiska och jämförelseoperationer, så att de kan användas för att implementera aritmetik för alla objekt som skapats av programmeraren. Utöver de vanliga kan du använda de så kallade "bibliotek"-metametoderna, som inte stöds av kärnan i språket, utan av specifika bibliotek. I exemplet ovan är detta en metametod som __tostringstöds av strängbiblioteket; denna metod konverterar tabellen till en sträng.

Området är av största intresse __index. Det kallas när tolken försöker läsa ett tabellelement men inte hittar det. Ett fält __indexkan referera till antingen en tabell eller en metod. I det första fallet kommer tolken, som inte hittar det önskade värdet i huvudtabellen, att leta efter det i tabellen __index. I den andra, istället för att komma åt tabellen, kommer denna metod att anropas. Genom att specificera tabeller eller metametoder för ett givet fält kan Lua implementera arv, dölja objektdata, spåra operationer på tabelldata och mycket mer.

Objektorienterad programmering

Grunden för OOP i Lua är tabeller. I princip är en tabell ett objekt i OOP-bemärkelse, eftersom den kan ha fält namngivna med identifierare och lagra godtyckliga värden (objektegenskaper) och funktioner för att implementera objektets beteende (objektmetoder) i dessa fält. En del av det syntaktiska sockret som tillhandahålls av Lua gör beskrivning och hantering av objekt mer bekant för programmerare med erfarenhet av traditionella OOP-språk. Det finns inget koncept för " klass " i Lua, därför beskrivs ett separat objekt och alla fält och metoder refererar specifikt till det. Egenskaper beskrivs på samma sätt som tabellelement med identifierarnycklar, metoder beskrivs som funktionsfält. Liksom den klassiska Oberon innehåller beskrivningen av metoder en explicit indikation i den första parametern av den så kallade "mottagaren" - en parameter som, när en metod anropas, refererar till det objekt för vilket den anropas. Men förutom standardreferensen till ett tabellfält, genom en punkt, som kräver att mottagaren uttryckligen anges i metodanropet, stöder Lua ytterligare en syntax: när metodhuvudet skrivs i formen " Объект:метод" i metodanropet eller beskrivningen , då anges inte mottagaren. Samtidigt, i kroppen av metoden, är den fortfarande tillgänglig under namnet self:

-- Objektkonto = { -- Objekt "konto" id , namn , saldo = 0 , -- objektegenskaper: nummer, namn, saldo kredit = funktion ( själv , v ) -- metod "kostnad" - beskrivning inuti objektet med explicit anger mottagaren om själv . balans < v sedan felet "Otillräckligt saldo" slut själv . balans = själv . balans - v slut } funktion Konto : debet ( v ) -- "inkommande" metod - extern stenografi beskrivning (egen inte specificerad) själv . balans = själv . balans + v slut Konto . debet ( Konto , 10000 ) -- metod call - long version Konto : kredit ( 5000 ) -- metod call - short version

Arv, inklusive multipelt arv, implementeras med hjälp av metatabeller och metametoder. Med hjälp av metametoder kan du också implementera datadöljning och kontrollerad åtkomst till fälten i tabellobjektet. Om du jämför detta tillvägagångssätt med andra språk, där allt ovanstående implementeras med hjälp av speciella språkverktyg, kan du se att Lua-implementeringen är mer komplicerad och kräver mer noggrann kodning, men ger mer flexibilitet och förenklar tolken.

Kodexempel

Klassiskt program " Hej, värld!" » i Lua ser ut så här:

print ( "Hej världen!" )

Faktoriell  är ett exempel på en rekursiv funktion:

funktion faktoriell ( n ) om n == 0 returnera 1 annars returnera n * faktoriell ( n - 1 ) slut slut _

Slinga med räknare :

för i = 1 , 5 do -- instruktioner/operationer slutar

Att arbeta med funktioner som förstklassiga objekt visas i följande exempel, som ändrar utskriftsfunktionens beteende:

gör lokalt oldprint = print -- Spara aktuell utskriftsfunktion som oldprint funktion print ( s ) -- Omdefiniera utskriftsfunktion om s == " foo " sedan oldprint ( " bar " ) annars oldprint ( s ) end end end end

Alla framtida anrop printkommer nu att omdirigeras till den nya funktionen, och tack vare Luas stöd för lexikalisk kontext kommer den gamla utskriftsfunktionen endast att vara tillgänglig via den nya, modifierade utskriftsfunktionen. Lua stöder även stängningar , som beskrivs ovan i det relaterade avsnittet.

En nyckelfunktion hos Lua är dess utvidgningsbara semantik, och den metatable mekanismen ger mycket utrymme för att anpassa unikt beteende för Lua-tabeller. Följande exempel visar en "oändlig" tabell. För varje kommer att ge det -th Fibonacci-numret med hjälp av memoization . fibs[n]

fibs = { 1 , 1 } -- Initiala värden för fibs[1] och fibs[2]. setmetatable ( fibs , { __index = function ( name , n ) -- Anropsfunktion om fibs[n] inte finns. namn [ n ] = namn [ n - 1 ] + namn [ n - 2 ] -- Beräkna och memorera fibs [n] .returnamn [ n ] slut } )

Lua låter dig också använda logiska operatorer andför att orange ternära konstruktioner , som till exempel i C# , eller för att referera till ett av de befintliga objekten.

gör lokalt nummer = tonumber ( io.read ()) -- Skriv till en variabel informationen som matats in från konsolen och konvertera den till en heltalstyp utskrift ( num == 1 och "Du skrev in rätt nummer" eller "Du skrev in fel nummer" ) -- Om num-variabeln är lika med 1, kommer texten efter och att visas i konsolen, i alla andra fall efter eller slut

Få åtkomst till en befintlig tabell och få värdet vid det första indexet:

gör lokal tbl = noll lokal tbl2 = { 1 } print ( ( tbl eller tbl2 )[ 1 ] ) -- Nummer 1 kommer att skrivas ut eftersom tabell tbl2 har detta värde vid index 1 slutet

Anropa en funktion från en av de befintliga tabellerna:

gör lokal tbl = noll lokal tbl2 = {} tbl2 . DoSomething = funktion () print ( "Gör något" ) slut ( tbl eller tbl2 ). DoSomething () slut

Implementering

Liksom många tolkade programmeringsspråk har Lua- implementeringen en separat kompilator från källspråk till exekverbar bytekod, och en virtuell maskin för att exekvera den genererade bytekoden. Dessutom är bytekoden inte kommandon från stackmaskinen, utan kommandon från en viss virtuell processor med flera register, vilket ökar effektiviteten i exekveringen. Den virtuella standardmaskinen Lua använder minnesallokering med skräpinsamling (liknande Java eller .NET).

Lua använder en enda strängpool , vilket minskar minnet för att lagra strängar.

För tidskritiska uppgifter finns en JIT - Lua - kompilator  - LuaJIT [15] . Kompilatorn llvm-lua [16] har också utvecklats , som genererar kod för den virtuella LLVM -maskinen , vilket ger möjlighet till efterföljande kompilering till en mycket effektiv maskinkod för processorer med olika arkitekturer.

Användning

Det används för närvarande i olika projekt där det krävs att man bygger in ett ganska snabbt och lättläst skriptprogrammeringsspråk - till exempel inom spelutveckling , där Lua ofta används som ett lager mellan spelmotorn och data för att skripta föremåls beteende och interaktion. På grund av dess kompakthet är den också användbar i bärbara enheter, i synnerhet använder en av Texas Instruments grafiska räknare ett språk istället för BASIC , traditionellt för denna klass av enheter .

Spel

LucasArts var den första som introducerade Lua -språket i utvecklingen av datorspel, med början i spelet Grim Fandango [17] . Språkets författarna i sin rapport på HOPL- konferensenminns att de i januari 1997 fick ett meddelande från Bret Mogilefsky, huvudutvecklaren av Grim Fandango, där han skrev att efter att ha läst om språket i en artikel från 1996 i Dr. Dobb's Journal planerar han att ersätta deras hemmagjorda skriptspråk SCUMM med Lua [18] . Som ett resultat skapade han spelmotorn GrimE , som också används av ett senare uppdrag från LucasArts - Escape from Monkey Island .

2003 rankade en GameDev.net- undersökning Lua som det mest populära skriptspråket för spelutveckling [9] .

Ett exempel på ett spel som programmerats med Lua är World of Warcraft [19] [20] . Nivåerna i pusselspelet Enigma [21] beskrivs på Lua- språket .

Ett antal gratis spelmotorer finns tillgängliga, programmerbara i Lua, såsom Defold [22][ betydelsen av faktum? ] , arkadmotorn LÖVE [23] [24] , speldesignern Novashell [ 25] och den uppdragsorienterade (mestadels textbaserade ) I STÄLLET [ 26] .

Används även i flygsimulatorn X-Plane, i röntgenmotorn för STALKER [27] .

För det populära spelet Minecraft har modifieringar av ComputerCraft och dess mer avancerade analoga OpenComputers skapats, som lägger till datorer programmerade på Lua-språket [28] .

Det berömda spelet Garry's Mod är programmerat och stöder även modifieringar skrivna i Lua.

Croteam - teamet (utvecklare av Serious Sam och The Talos Principle ) har använt Lua i skript sedan Serious Engine 3.5 [29] .

För spelet GTA: San Andreas skapas modifieringar skrivna på Lua-språket och stöds av Moonloader-plugin. [30] Multi Theft Auto stöder även Lua-skript.

Roblox -spelplattformen använder Lua som sitt spelkodningsspråk och spelmiljöhantering [31] .

Ficsit-Networks-moden har skapats av Satisfactory game community , vilket gör det möjligt att programmera alla åtgärder på Lua-språket [32] .

Factorio använder Lua för att skapa mods. [33] [34]

Spelet Dual Universe används för mekanik i spelet och programmering av spelblock

LuaTeX

Datorsättaren LuaTeX , en utökad version av pdfTeX , använder Lua som sitt inbyggda skriptspråk [35] .

RPM

RPM -pakethanteraren innehåller en inbyggd Lua-tolk [36] .

IDE

Det finns minst två "inhemska" utvecklingsmiljöer för Lua, dessa är:

  • ZeroBrane Studio [37]  är en multiplattformsutvecklingsmiljö skriven i själva Lua.
  • Decoda  är en Windows-utvecklingsmiljö skriven i C++ med rika felsökningsmöjligheter för Lua-skript, inklusive i applikationer som körs. För 2018, den senaste utgåvan av miljön går tillbaka till 2014 och har status som en betaversion.

Dessutom stöds Lua av några universella IDE:er, särskilt:

Det fanns en Lua-stödmodul för NetBeans- miljön , men den avbröts 2013 och är endast tillgänglig för NetBeans 7.4 och tidigare. Plugin-programmet stöds inte i NetBeans 8.

Se även

  • Lista över applikationer som använder Lua

Anteckningar

  1. ↑ 1 2 https://www.lua.org/authors.html
  2. ↑ Lua: om
  3. ↑ Lua 5.1 Referensmanual - 2019.
  4. ↑ A Look at the Design of Lua  - [ New York] : Association for Computing Machinery , 2018. - ISSN 0001-0782 ; 1557-7317
  5. ↑ https://www.lua.org/license.html
  6. ↑ Lua Open Source Project på Open Hub: Licenser sida - 2006.
  7. ↑ https://www.lua.org/about.html
  8. ↑ Om Lua . Lua.org. Hämtad 19 juni 2013. Arkiverad från originalet 26 december 2018.
  9. ↑ 1 2 Vilket språk använder du för skript i din spelmotor?. GameDev.net - Omröstningsresultat
  10. ↑ 1 2 Biancuzzi, Warden, 2011 , sid. 216.
  11. ↑ Utvecklingen av ett förlängningsspråk: en historia om Lua (2001). Hämtad 24 augusti 2016. Arkiverad från originalet 14 oktober 2017.
  12. ↑ HOPL, 2007 , sid. 2–1–2–26.
  13. ↑ Lua: ett utbyggbart inbäddat språk. Några metamekanismer ersätter en mängd funktioner  (december 1996), s. 26–33. Arkiverad från originalet den 20 oktober 2014. Hämtad 20 september 2014.
  14. ↑ Lua 5.1 Referensmanual . Hämtad 5 november 2019. Arkiverad från originalet 15 november 2013.
  15. ↑ LuaJIT-projektet . Hämtad 18 maj 2009. Arkiverad från originalet 16 april 2009.
  16. ↑ llvm-lua. JIT/Statisk kompilator för Lua med LLVM på backend. . Hämtad 21 januari 2009. Arkiverad från originalet 22 januari 2009.
  17. ↑ Bret Mogilefsky. Lua i Grim Fandango . Hämtad 9 december 2011. Arkiverad från originalet 4 februari 2012.
  18. ↑ HOPL, 2007 , sid. elva.
  19. ↑ Paul Emmerich. Börjar Lua med World of Warcraft-tillägg. - Apress , juli 2009. - ISBN 1430223715 .
  20. ↑ James Whitehead II, Bryan McLemore och Matthew Orlando. World of Warcraft programmering . - Wiley , maj 2008. - ISBN 0470229810 .
  21. ↑ Tom Gutschmidt. Ch. 8. Lua Game Community → Spelmotorer // Spelprogrammering med Python, Lua och Ruby . - Premier Press, 2003. - 472 sid. - ISBN 1-59200-079-7 .
  22. ↑ Defold-spelutvecklingsmanual - Lua in Defold . Defold spelmotor. Hämtad 2 mars 2017. Arkiverad från originalet 3 mars 2017.
  23. ↑ Dj Walker-Morgan. H Speed ​​​​Guide till Lua → Utveckla med Lua . The H (17 april 2012). Hämtad 26 februari 2015. Arkiverad från originalet 26 februari 2015.
  24. ↑ Darmie Akinlaja. LÖVE för Lua Game Programmering. — Packt, 2013. — 106 sid. — ISBN 978-1-78216-160-8 .
  25. ↑ Alan Thorne. Kapitel 8. Novashell och 2D-spel // Cross Platform Game Development . - Jones & Bartlett Learning, 2008. -  S. 225-264 . — 421 sid. — ISBN 978-1-59822-056-8 .
  26. ↑ Pyotr Kosykh. I STÄLLET: Hur allt började  // IFPrint.org. - 18 mars 2013. - Utgåva. 1 . — ISSN 2307-535X . Arkiverad från originalet den 26 februari 2015.
  27. ↑ Ronnie Tucker. Full Circle Magazine #90: DEN OBEROENDE MAGASINEN FÖR UBUNTU LINUX COMMUNITY . — Full Circle Magazine, 2014-10-31. - 50 s.
  28. ↑ Matthew Monk, Simon Monk. ComputerCraft: Lua-programmering i Minecraft . - CreateSpace Independent Publishing Platform, 2013-01-28. — 58 s. — ISBN 9781481927659 .
  29. ↑ Zero_Cool. Teknikhistoria - Seriös motor | historia | GPU test . gamegpu.com. Hämtad 10 april 2016. Arkiverad från originalet 20 april 2016.
  30. ↑ Favoriter - Lua - ASI - MoonLoader  (ryska) , BlastHack - Fusk som konst . Arkiverad från originalet den 29 januari 2018. Hämtad 28 januari 2018.
  31. ↑ Lär dig Roblox | Kodning och skript . developer.roblox.com Hämtad 23 augusti 2019. Arkiverad från originalet 23 augusti 2019.
  32. ↑ FicsIt-Networks :: Tillfredsställande  modningsdokumentation . docs.fixit.app . Hämtad: 24 mars 2022.
  33. ↑ Modding - Factorio Wiki . wiki.factorio.com . Hämtad 1 juni 2022. Arkiverad från originalet 1 juni 2022.
  34. ↑ API-dokument | factorio . lua-api.factorio.com . Hämtad 1 juni 2022. Arkiverad från originalet 18 maj 2022.
  35. ↑ CTAN : Paket luatex  . Hämtad 6 februari 2019. Arkiverad från originalet 7 februari 2019.
  36. ↑ Lua i RPM  . Hämtad 11 februari 2019. Arkiverad från originalet 24 juni 2018.
  37. ↑ ZeroBrane Studio - Lua IDE/editor/debugger för Windows, Mac OSX och Linux . Hämtad 31 juli 2013. Arkiverad från originalet 18 januari 2016.
  38. ↑ Lua utvecklingsverktyg . Hämtad 14 februari 2012. Arkiverad från originalet 9 februari 2012.
  39. ↑ EmmyLua :: JetBrains Plugin  Repository . JetBrains Plugin Repository. Datum för åtkomst: 26 februari 2018. Arkiverad från originalet 27 februari 2018.

Litteratur

  • Roberto Jerusalem. Programmering på Lua-språket. - 3:e upplagan - DMK, 2014. - ISBN 9785940747673 . (original: Roberto Ierusalimschy. Programmering i Lua. - 3:e upplagan.. - 2012. - ISBN 9788590379850 . )
  • Ian Dees. Lua // Sju fler språk på sju veckor. Språk som formar framtiden / Bruce Tate, Fred Daoud, Jack Moffitt, Ian Dees. - Den pragmatiska bokhyllan, 2015. - S. 1-48. — 320 s. — ISBN 978-1941222157 .
  • Mario Kasuba. Kokbok för Lua spelutveckling. - Packt Publishing, 2015. - 402 sid. — ISBN 978-1849515504 .
  • David Young. Lär dig spel AI-programmering med Lua. - Packt Publishing, 2014. - 352 sid. — ISBN 978-1783281336 .
  • Jayant Varma. Lär dig Lua för iOS-spelutveckling . - Apress, 2012. - 410 sid. — ISBN 9781430246626 .
  • Kurt Jung, Aaron Brown. Börjar Lua-programmering . - John Wiley & Sons, 2011. - 675 sid. - (Programmerare till programmerare). — ISBN 9781118079119 .
Språkhistoria
  • R. Ierusalimschy, LH de Figueiredo, W. Celes. Utvecklingen av Lua  // Proceedings of ACM HOPL III. 2-1–2-26. – 2007.
  • Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes. Utvecklingen av ett förlängningsspråk: en historia om Lua . Reprint från Proceedings of V Brazilian Symposium on Programming Languages ​​(2001) B-14–B-28. Hämtad 9 december 2011. Arkiverad från originalet 4 februari 2012.
  • Federico Biancuzzi, Shane Warden. Kapitel 7. Lua // Programmeringspionjärer. Samtal med skaparna av stora programmeringsspråk = Masterminds of Programming: Conversations with the Creators of Major Programming Languages. - Symbol, 2011. - S. 211-230. — 608 sid. - 1500 exemplar.  — ISBN 9785932861707 .
  • Intervju med Robert Yeruzalimsky för Computerworld om Lua-språket

Se även

  • Squirrel  - Lua-baserat programmeringsspråk

Länkar

Lua på ryska

Översättningar av manualer Artiklar och recensioner
 Lua
KompilatorerRamar och DLL :erHamnar och distributionerIdusAnsökningar
 Programmeringsspråk