Lehekülje Lua lähteteksti vaatamine

{{See artikkel| on programmeerimiskeelest Lua; teiste tähenduste kohta vaata lehte [[Lua (täpsustus)]]}}
{{keeletoimeta}}

{{Programmeerimiskeel
| nimi                   = Lua
| faililaiend               = .lua
| logo                   = [[Pilt:Lua-Logo.svg|128px]]
|paradigma=[[Programmeerimise paradigma|Mitmeparadigmaline]]: [[skriptimiskeel|skripting]], [[imperatiivne programmeerimine|imperatiivne]] ([[protseduuriline programmeerimine|protseduuriline]], [[prototüübipõhine programmeerimine|prototüübipõhine]], [[objektorienteeritud programmeerimine|objekt-orienteeritud]]), [[funktsionaalne programmeerimine|funktsionaalne]]
| väljalaskeaeg                  = 1993
| disainer                  = [[Roberto Ierusalimschy]]<br /> Waldemar Celes<br /> Luiz Henrique de Figueiredo
| arendaja              =
| tüüpimine                 = [[dünaamiline tüüpimine|dünaamiline]], [[tugev tüüpimine|tugev]], [[parditüüpimine|pardi]]
| implementatsioonid=[http://www.lua.org/download.html Lua], [http://luajit.org/ LuaJIT], [https://code.google.com/p/llvm-lua/ LLVM-Lua]
| programming_language = [[ANSI C]]
| dialektid        = [http://metalua.luaforge.net/ Metalua], [http://idle.thomaslauer.com/ Idle], [http://www.nongnu.org/gsl-shell/ GSL Shell]
| mõjutajad          = [[C++]], [[CLU (programming language)|CLU]], [[Modula-2|Modula]], [[Scheme (programming language)|Scheme]], [[SNOBOL]]
| mõjutatavad             = [[Falcon (programmeerimiskeel)|Falcon]]<!--2003-->, [[GameMonkey Skript|GameMonkey]]<!--2003-->, [[Io (programmeerimiskeel)|Io]]<!--2002-->, [[JavaScript]], [[Julia (programmeerimiskeel)|Julia]]<!--2012-->, [[MiniD]]<!--2006-->, [[Red (programmeerimiskeel)|Red]], [[Ruby (programmeerimiskeel)|Ruby]], [[Squirrel (programmeerimiskeel)|Squirrel]]<!--2003-->, [http://moonscript.org/ MoonScript]<!--2011-->
| os       = [[platvormiülene]]
| litsents              = [[MIT Litsents]]
| veebileht                = {{URL|http://www.lua.org/}}
| wikiraamatud              =
}}

'''Lua''' ( [/ˈluːə/] [loo-ə], portugali keeles lua [ˈlu.(w)ɐ] tähendab [[Kuu]]d) on [[mitmeparadigmaline programmeerimsikeel|mitmeparadigmaline]] [[programmeerimiskeel]], mis on eeskätt loodud välja kutsumiseks teiste programmeerimiskeelte ja -keskkondade seest.<ref name="luaspe" /> Lua keel on alates loomisest [[platvormiülene]] ja on ANSI standardile vastavas C-programmeerimiskeeles<ref name="luaabout" /> ning omab suhteliselt lihtsat [[C (programmeerimiskeel)|C-]][[rakendusliides]]t.<ref name="qSV1H" />

Lua loodi aastal 1993 ning oli mõeldud [[tarkvararakendus]]te üha kasvavate vajaduste täitmiseks. See tagas põhilised võimalused enamikule [[protseduraalne programmeerimine|protseduurilistele programmeerimiskeeltele]], kuid piiratumate ning [[valdkonnapõhine programmeerimsikeel|valdkonnapõhiste programmeerimiskeelte]] omadusi ei ole kaasatud. Lua sisaldab keelt laiendavaid mehhanisme, lubades arendajal keele omadusi implementeerida. Kuigi Lua oli kavandatud olema üldine integreeritav keelelaiendus, siis Lua disainerid suunasid tähelepanu ka selle kiirusele, porditavusele, laiendatavusele ja kasutusmugavusele arenduses.

==Ajalugu==

Lua programmeerimiskeele lõid 1993. aastal [[Roberto Ierusalimschy]], [[Luiz Henrique de Figueiredo]] ja [[Waldemar Celes]] ning Computer Graphics Technology Group (Techgraf) liikmed [[Rio de Janeiro]] Piiskoplikus Katoliku Ülikoolis (Pontifical Catholic University of Rio de Janeiro) [[Brasiilia]]s.

Aastatel 1977–1992 kehtisid [[Brasiilia]]s arvutitarkvarale ja -riistvarale tugevad [[kaubandustõke|kaubandustõkked]]. Nende piirangute tõttu ei olnud Tecgrafi klientidel võimalik (ei poliitilistel ega rahalistel põhjustel) osta kohandatavat tarkvara välismaalt. Nende asjaolude tõttu implementeeris Tecgraf põhilised vahendid iseseisvalt.<ref name="hopl2007" />

Lua ajalooline "isa ja ema" olid andmete kirjeldus/konfiguratsiooni keel ''SOL'' (Simple Object Language) ja ''DEL'' (Data-Entry Language).<ref name="luahist2001" /> Neid on iseseisvalt arendanud Tecgraf aastatel 1992–1993, lisades paindlikkust kahte projekti (mõlemad olid interaktiivsed graafilised programmid ettevõtte [[Petrobras]] rakenduste jaoks). Neis oli puudus igasugustest voo reguleerimise struktuuridest SOL-is ja DEL-is ja Petrobras tundis kasvavat vajadust lisada rakendustesse täiendavaid programmeeritavaid võimalusi.

Lua 1.0 oli disainitud nii, et selle objekti konstruktorid, olles nii vähesel määral erinevad praegusest kergusest ja paindlikkuse laadist, inkorporeeritud SOLi andmekirjelduse süntaksiga (siit tuleneb ka nimi "Lua". ''Sol tähendab'' [[Portugali keel|portugali]] keeles '[[päike]]st', seega ''sobis arendatava keele nimeks [[sõna]] "Lua" -'' '[[Kuu]]'). Lua kontrollstruktuuride [[süntaks]]ist oli suurem osa laenatud [[Modula]]st (if, while, repeat/until), aga samuti oli võetud mõjutusi [[CLU (programmeerimiskeel)|CLU]]-st (korduvad ülesanded ja korduv tagastamine funktsioonide väljakutsumisel kui lihtsam alternatiiv [[Viitparameeter|viitparameetritele]] või kaudsetele [[Viit (informaatika)|viitadele]]), [[C++]] keelest (" [[Lokaalne muutuja|lokaalse muutuja]] deklareerimine ainult seal, kus me vajame seda<ref name="hopl2007" />), [[SNOBOL]]-ist ja [[AWK|AWK-st]] ([[assotsiatiivne massiiv]]). Artiklis, mis avaldati [[Dr. Dobb's Journal]]is, väitsid'' Lua keele loojad, et LISP ja Scheme kui nende ainsad üldlevinud andmete struktureerimise mehhanismid ([[List (programmeerimine)|list]]) olid tugevalt mõjutatud nende otsusest arendada tabelit kui tähtsaimat Lua andmestruktuuri.<ref name="ddj96" />

Lua [[semantika]] on enim mõjutatud Scheme poolt,<ref name="hopl2007" /> eriti seoses [[Anonüümne funktsioon|anonüümsete funktsioonide]] kasutuselevõtuga ja täieliku sõnastiku kindlaksmääramisega.

Lua versioonid enne versiooni 5.0 olid välja lastud [[BSD-litsents]]iga sarnase litsentsi alusel. Alates versioonist 5.0 on Lua olnud [[MIT litsents]]i all. Mõlemad on [[Vaba tarkvara|leebed vaba tarkvara litsentsid]] ja peaaegu identsed.

== Funktsionaalsus ==
Luad on tavaliselt kirjeldatud kui "[[Paradigma|mitmeparadigmalist]]" keelt, toetades väikest hulka üldisi funktsioone, millega saab laiendada sobivust eri tüüpi probleemidele, selle asemel et toetada palju keerulisemat ja ranget spetsifikatsiooni, sobitamaks ühte paradigmat. Näiteks Lua ei sisalda ilmset [[Pärilus (objektorienteeritud programmeerimine)|päriluse]] tuge, aga lubab seda implementeerida koos [[metatabel]]itega. Lisaks lubab Lua programmeerijal implementeerida [[nimeruum]]e, [[Klass (programmeerimine)|klasse]] ja teisi seotud funktsioone, kasutades selle üksiku tabeli implementeerimist. Esimese klassi funktsioonid, mis võimaldavad töötamist paljude [[Funktsionaalne programmeerimine|funktsionaalse programmeerimise]] tehnikatega ja täielik staatiline skoopimine võimaldavad tihedat informatsiooni peitmist, täites väiksema privileegi printsiipi.

Üldiselt püüab Lua tagada lihtsust ning paindlikke [[Metaprogrammeerimine|metafunktsioone]], mis võivad olla vajadusel sisseehitatud, selle asemel et varustada funktsiooni seadistamise spetsiifikaga üht programmeerimisparadigmat. Tulemuseks olev baaskeel on [[Kergekaalu programmeerimiskeel|kerge]] – [[interpretaator]]i maht on kompileeritult ainult umbes 180&nbsp;[[Kilobait|kB]]<ref name="luaabout" /> ning on lihtsasti kohandatav laiale rakenduste valikule.

Lua keel võimaldab dünaamilist tüüpimist ja on mõeldud kasutamiseks kui keelelaiendus või [[skriptimiskeel]] ning on piisavalt kompaktne, et sobib erinevate platvormidega. See toetab ainult väikest osa elementaarseid andmestruktuure nagu tõeväärtuse väärtused, numbrid (kahekohalise täpsusega ujukomaarvud tavaliselt) ja sõned. Enamlevinud andmestruktuure nagu massiive, hulki, liste ja kirjeid saab taasesitada Lua ainsat omaenda andmestruktuuri – tabelit – kasutades, Tabel näol on tegu põhimõtteliselt heterogeenne assotsiatiivse massiiviga.<!-- Artikli esmane parandamine pooleli siin! -->

Lua implementeerib väikest hulka kõrgetasemelisi funktsioone nagu esimese klassi funktsioonid, "prügikorjajad" (garbage collection), sulundid, sabakutse (tail call), tüübiteisendus (automaatne muutmine sõne ja numbri vahel), kaasprogrammid (ühise multitegumitöötlusega) ja dünaamiline mooduli laadimine.

Sisaldades ainult minimaalset hulka andmetüüpe, Lua püüdis saavutada tasakaalu jõudluse ja mahu vahel.

=== Koodi näidis ===
Klassikalist programmi [[Hello world|"Tere maailm"]] saab kirjutada järgmise koodiga:

<syntaxhighlight lang="lua">
print("Tere maailm!")
</syntaxhighlight>
Seda sama programmi saab kirjutada ka sedamoodi:
<syntaxhighlight lang="lua">
io.write('Tere maailm!\n')
</syntaxhighlight>
Seda programmi saab luua ka nii nagu [http://www.lua.org/cgi-bin/demo?hello Lua veebilehel].
<syntaxhighlight lang="lua">
io.write("Hello world, from ", _VERSION, "!\n")
</syntaxhighlight>

[[Kommentaar (programmeerimine)|Kommentaarides]] kasutatakse järgmist süntaksit, mis sarnaneb programmeerimiskeelte [[Ada (programmeerimiskeel)|Ada]], [[Eiffel (programmeerimiskeel)|Eiffeli]], [[Haskell]]i, [[SQL|SQL-i]] ja [[VHDL|VHDL-i]] omadega:
<syntaxhighlight lang="lua">
--Kommentaar keeles Lua algab kahe sidekriipsuga ja on kuni rea lõpuni.

--[[ Mitmerealised sõned ja kommentaarid
     on ümbritsetud kahekordsete kandiliste sulgudega. ]]

--[=[ Seda tüüpi kommentaaridesse on teine --[[kommentaar]] pesastatud. ]=]
</syntaxhighlight>

[[Faktoriaal]]i funktsioon on implementeeritud, nii nagu järgmises näites näidatud.

<syntaxhighlight lang="lua">
function factoriaal(n)
  local x = 1
  for i = 2, n do
    x = x * i
  end
  return x
end
</syntaxhighlight>

=== Tsüklid  ===
Lua keeles on nelja tüüpi [[Tsükkel (programmeerimine)|tsükleid]]: [[Tsükkel (programmeerimine)|<tt>while-tsükkel</tt>]], <tt>repeat</tt> tsükkel (sarnane [[Tsükkel (programmeerimine)|<tt>do-while</tt> tsükliga]]), numbriline [[Tsükkel (programmeerimine)|<tt>for</tt> tsükkel]] ja üldine <tt>for</tt> tsükkel.

<syntaxhighlight lang="lua">
--tingimus = true

while tingimus do
  --käsud
end

repeat
  --käsud
until tingimus

for i = esimene,viimane,samm do     --samm võib olla negatiivne, lubades for-tsüklil loendada alla või üles. Samm näitab, kui palju on järgmine väärtus eelmisest suurem. Näiteks kui samm on 1, i esimene väärtus on 1, siis järgmine on 1+1=2
  --käsud
  --näiteks väljastame i väärtuse: print(i)
end
</syntaxhighlight>

Üldine <tt>for-tsükkel</tt>:
<syntaxhighlight lang="lua">
for key, value in pairs(_G) do
  print(key, value)
end
</syntaxhighlight>
Üldine for-tsükkel itereerib üle tabeli <tt>_G,</tt> kasutades standardset iteraatori funktsiooni <tt>pairs</tt>, kuni see tagastab tühiväärtuse <tt>null</tt>.

=== Funktsioonid ===
Lua funktsioonikäsitluses on [[esimese klassi funktsioon]]ide väärtused, mis on näidatud järgnevas näites, kus print-funktsiooni käitumine on modifitseeritud:
<syntaxhighlight lang="lua">
do
  local oldprint = print
  -- varu praeguse print funktsioon kui oldprint
  function print(s)
    --[[ Defineeri uuesti print function, tavalist print funktsiooni saab endiselt kasutada
         läbi oldprint. Uuel on ainult üks argument]]
    oldprint(s == "foo" and "bar" or s)
  end
end
</syntaxhighlight>
Iga tulevane print-käsu väljakutse hakkab nüüd olema suunatud läbi uue funktsiooni ja tulenevalt Lua staatilisest skoopimisest on vana print funktsioon kättesaadav ainult uue modifitseeritud print jaoks.

Lua samuti toetab [[Sulund (informaatika)|sulundeid]], mida on demonstreeritud järgmises koodis:
<syntaxhighlight lang="lua">
function addto(x)
  --tagastab uue funktsiooni, mis lisab x-i argumendiks
  return function(y)
    --[=[ kui me viitame muutujale x, mis on väljaspool seda skoopi ja mille
         eluperiood on lühem kui sellel anonüümsel funktsioonil,
          Lua loob sulundi.]=]
    return x + y
  end
end
fourplus = addto(4)
print(fourplus(3))  -- väljastab 7

--Seda saab saavutada ka funktsiooni järgmisel viisil välja kutsudes:
print(addto(4)(3))
--[[ See on nii, sest me oleme kutsumas tagastatud funktsiooni `addto(4)'  koos argumendiga `3' otse.
     See aitab ka vähendada andmehinda ja tõsta kasutust, kui oleme kutsunud iteratiivselt.
]]
</syntaxhighlight>
Muutuja x uus sulund on loodud igal korral, kui <tt>addto</tt> kutsutakse välja, nii et iga uus anonüümne funktsioon naaseb alati juurdepääsuga oma x-parameetrile. Sulundit haldab Lua "prügivedaja" just nagu iga teist objekti. 
=== Tabelid ===
Tabelid on kõige tähtsamad andmestruktuurid (ja disainilt ainus sisseehitatud [[liitandmetüüp]]) Lua keeles ning on alus kõigile kasutaja loodud tüüpidele. Need sarnanevad kontseptuaalselt [[Massiiv (programmeerimine)|assotsiatiivse massiiviga]] PHP-s, [[Sõnastik (programmeerimine)|sõnastikuga]] Pythonis ja räsidele Rubys või Perlis.

Tabel on kogum võtmete ja andmete paaridest, kus andmetele viitavad võtmed. Teiste sõnadega on see [[Paisktabel|räsitud]] [[Homogeensus ja heterogeensus|heterogeenne]] [[Massiiv (programmeerimine)|assotsiatiivne massiiv]]. Võti (indeks) võib omada iga väärtust, aga mitte NaN. Numbrilist võtit 1 peetakse erinevaks [[Sõne (andmetüüp)|sõnelisest]] võtmest "1". i

Tabeleid luuakse kasutades <code>{}</code> konstruktorit:
<syntaxhighlight lang="lua">
a_table = {} -- Loome uue tabeli nimega a_table
</syntaxhighlight>
Tabelid saavad viidata ka üksteisele:
<syntaxhighlight lang="lua">
a_table = {x = 10}  -- Loome uue tabeli koos ühe kirje kujutusega, kus "x" on seotud 10-ga.
print(a_table["x"]) -- Väljastame sõnelise võtmega seotud väärtuse, mis on praegusel juhul 10.
b_table = a_table
b_table["x"] = 20   -- Väärtuse muutmine tabelis. Uus väärtus on 20.
print(b_table["x"]) -- Väljastame 20.
print(a_table["x"]) -- Samuti väljastab 20, sest a_table ja b_table mõlemad viitavad samale tabelile.
</syntaxhighlight>

==== Kirje ====
Tabelit on tihti kasutatud nagu struktuuri (või [[Kirje (programmeerimine)|kirjet]]),kus on kasutatud [[Sõne (andmetüüp)|sõnesid]] kui võtmeid, sest selline kasutus on väga tavaline. Lua funktsioonid on spetsiaalse süntaksiga, tegelemiseks selliste väljadega. Seda näitab järgmine koodinäide:
<syntaxhighlight lang="lua">
point = { x = 10, y = 20 }   -- Loome uue tabeli.
print(point["x"])            -- Väljastame 10.
print(point.x)               -- See rida on enamvähem sama, mis eelmine, kuid lihtsam lugeda.
                             -- .
</syntaxhighlight>
Tsiteerides Lua 5.1 manuaali:<ref name="J29hb" />

"Süntaks var.Name on [[Süntaktika|süntaktiline suhkur]] süntaksist var['Name'];"

==== Nimeruum ====
Seotud funktsioonide salvestamiseks kasutatavaid tabeleid saab näidatu kui nimeruumi.<syntaxhighlight lang="lua">
Point = {}

Point.new = function(x, y)
  return {x = x, y = y}  --  return {["x"] = x, ["y"] = y}
end

Point.set_x = function(point, x)
  point.x = x  --  point["x"] = x;
end
</syntaxhighlight>

==== Massiiv ====
Numbrilise võtme kasutamise korral sarnaneb tabel [[Massiiv (programmeerimine)|massiivi andmetüübiga]]. Lua massiivid on 1-baasil. Erinevalt paljudest programmeerimiskeeltest, kus esimene indeks on 0, on siin esimene indeks 1 (kuigi on lubatud kasutada ka indeksit 0).

Lihtne sõnemassiiv:

<syntaxhighlight lang="lua">
array = { "a", "b", "c", "d" }   -- Indeksid määratakse automaatselt
print(array[2])                  -- Väljastab  "b". Automaatne indekseerimine Luas hakkab 1-st.
print(#array)                    -- Väljastab 4.  # See on pikkuse määramise operaator tabelitel ja sõnedel.
array[0] = "z"                   -- 0 on legaalne indeks.
print(#array)                    -- Jätkuvalt väljastab 4, Lua massiivid on 1-põhised.
</syntaxhighlight>
Tabeli <tt>t pikkus on defineeritud</tt> olema iga täisarvuline indeks <tt>n</tt> nii, et <tt>t[n]</tt> ei ole tühi ja <tt>t[n+1]</tt> on tühi; veel enam, kui <tt>t[1]</tt> on tühi, siis <tt>n on</tt> 0. Regulaarse massiivi üks mitte-null väärtustest antakse muutujale <tt>n</tt>, Selle pikkus on sel juhul täpselt <tt>n ehk</tt> viimase indeksi väärtus. Kui massiivil on "auke" (tühjad väärtused on mittetühjade väärtuste vahel), siis <tt>#t</tt> saab olla iga indeks, mis on vahetult eelnev tühjale väärtusele (see tähendab, et ta võib iga sellist tühja väärtust pidada massiivi lõpuks).<ref name="pWO0k" />

Kahedimensiooniline tabel:

<syntaxhighlight lang="lua">
ExampleTable =
{
     {1,2,3,4},
     {5,6,7,8}
}
print(ExampleTable[1][3]) -- Väljastab "3"
print(ExampleTable[2][4]) -- Väljastab "8"
</syntaxhighlight>
Objektide massiiv:
<syntaxhighlight lang="lua">
function Point(x, y)        -- "Point" objekti konstruktor
  return { x = x, y = y }   -- Loome ja tagastame uue objekti (tabel)
end
array = { Point(10, 20), Point(30, 40), Point(50, 60) }   -- Loome punktide massiivi
                        -- massiiv = { { x = 10, y = 20 }, { x = 30, y = 40 }, { x = 50, y = 60 } };
print(array[2].y)                                         -- Väljastab 40
</syntaxhighlight>
Kasutades kujutust normaalse massiivi järgitegemiseks on aeglasem kui kasutada seda tegeliku massiivina. Siiski on Lua tabelid optimeeritud kasutama neid nagu massiive<ref name="lobject_h_array" />.
=== Metatabelid ===
Laiendatud semantikas on Lua võtmefunktsioon ja [[metatabel]]i kontseptsioon lubab Lua tabeleid kohandada võimsaimasse olekusse. Järgnev näide demonstreerib "lõpmatut" tabelit. Iga <math>n</math>, <tt>fibs[n]</tt> annab <math>n</math>-inda [[Fibonacci jada]] liikme kasutades [[Dünaamiline programmeerimine|dünaamilist programmeerimist]] ja [[Memoisatsioon|tabeli pidamist]], mis on optimeerimise tehnika.
<syntaxhighlight lang="lua">
fibs = { 1, 1 }                                -- esialgne väärtus fibs[1]'le ja fibs[2]'le.
setmetatable(fibs, {
  __index = function(values, n)                --[[ __index on funktsioon, mis on eeldefineeritud Lua poolt,
                                                    See kutsutakse välja, kui võtit "n" ei eksisteeri. ]]
    values[n] = values[n - 1] + values[n - 2]  -- Calculate and memoize fibs[n].
    return values[n]
  end
})
</syntaxhighlight>

=== Objektorienteeritud programmeerimine ===
Lua keeles ei ole sisseehitatud klasse, kuid sellegipoolest on võimalik objektorienteeritult programmeerida. Selleks tuleb kasutada kaht Lua keele funktsiooni: esimese klassi funktsioone ja tabeleid. Objekti saab luua funktsioonide ja soetud andmete tabelisse paigutamisega. Metatabeli mehhanismi abil saab implementeerida pärilust.

Luas ei ole sellist mõistet nagu "[[Klass (programmeerimine)|klass]]" koos nende tehnikatega: pigem on kasutusel prototüübid nagu programmeerimiskeeltes [[Self (programmeerimiskeel)|Self]] ja [[JavaScript]]. Uusi objekte luuakse nii [[tehase meetod]]iga (see konstrueerib uued objektid nullist) kui ka kloonides eksisteerivat objekti.

Lua toetab mõnda süntaktilist suhkrut, et aidata kaasa objekti orientatsioonile. Deklareerides liikmefunktsiooni prototüübi tabelisse sisse, saab kasutada koodi <tt>function table:func(args), millega on samaväärne kood <tt>function table.func(self, args). Klassimeetodeid saab samuti kutsuda kooloni abil. Kood <tt>object:func(args) on samaväärne koodiga</tt> <tt>object.func(object, args)</tt>.</tt></tt>

Loome tavalise [[vektor]]i objekti:
<syntaxhighlight lang="lua">
local Vector = {}
Vector.__index = Vector

function Vector:new(x, y, z)    -- konstruktor
  return setmetatable({x = x, y = y, z = z}, Vector)
end

function Vector:magnitude()     -- teine meetod
  -- viitab varjatud objektile kasutades iseennast
  return math.sqrt(self.x^2 + self.y^2 + self.z^2)
end

local vec = Vector:new(0, 1, 0) -- Loome vektori
print(vec:magnitude())          -- Kutsume välja (output: 1)
print(vec.x)                    -- Ligipääs mälus olevale väärtusele (output: 0)
</syntaxhighlight>

== Sisemus ==
Lua [[Arvutiprogramm|programmid]] ei ole otseselt [[Interpreteerimine|interpreteeritud]] Lua [[tekstifail]]idest, aga on [[Kompileerima|kompileeritud]] [[baitkood]]i, mis töötab Lua [[virtuaalmasin]]as. Kompileerimise protsess on tüüpiliselt nähtamatu kasutajale ja on sooritatud käitamisaja kestel, aga seda saab teha ühenduseta, et kasvatada laadimiskiirust või vähendada rakenduse keskkonna mälu "jalajälge" kompilaatorit välja jättes. Lua baitkood saab samuti olla produtseeritud ja täidetud Luaga kasutades minemaviskamise funktsiooni sõne teegist ja load/loadstring/loadfile funktsioone. Lua versioon 5.3.3 on implementeeritud umbes 24 000 rea C-keele koodiga.<ref name="luaspe" /><ref name="luaabout" /> <!-- Artikli esmane parandamine pooleli siin! -->

Nagu enamik [[keskprotsessor]]eid (CPU) ja erinevalt enamikust virtuaalmasinatest, mis on pinupõhised, Lua virtuaalmasin on registripõhine ja järelikult palju enam sarnane päevakajalise riistvara disainiga. Registri arhitektuur väldib nii ülemäärast väärtuste kopeerimist kui ka vähendab kogu instruktsioonide arvu funktsiooni kohta. Lua 5 virtuaalmasin on üks esimesi puhtalt registripõhiseid virtuaalmasinaid omades laia kasutust.<ref name="lua5impl" /> [[Perl]]i [[Parrot]] ja [[Android]]i [[Dalvik]] on kaks teist teada-tuntud registripõhist virtuaalmasinat.

See näide on baitkoodi list faktoriaali funktsioonist, mis sai defineeritud ülal (nagu näha <tt>luac</tt> 5.1 kompilaatori poolt):<ref name="luavm51instr" />

 function <factorial.lua:1,7> (9 instructions, 36 bytes at 0x8063c60)
 1 param, 6 slots, 0 upvalues, 6 locals, 2 constants, 0 functions
 	1	[2]	LOADK 	1 -1	; 1
 	2	[3]	LOADK 	2 -2	; 2
 	3	[3]	MOVE  	3 0
 	4	[3]	LOADK 	4 -1	; 1
 	5	[3]	FORPREP 	2 1	; to 7
 	6	[4]	MUL  	1 1 5
 	7	[3]	FORLOOP 	2 -2	; to 6
 	8	[6]	RETURN 	1 2
 	9	[7]	RETURN 	0 1

== C API ==
Lua on kavandatud olema sisseehitatud teistese rakendustesse ja C API toetab seda eesmärki. API on jagatud kaheks osaks: Lua südamikuks ja Lua abiteegiks.<ref name="luarefman" />

Lua API disain elimineerib vajaduse manuaalseks viidete haldamiseks C koodis, erinevalt Pythoni API-st. Keeltel nagu see on API minimalistlik. Arenenud funktsionaalsus on toetatud abiteegi poolt, mis koosneb suurel määral eeltöödeldud makrodest, mis abistavad koos liittabeli operatsioonidega.

=== Kuhi ===
Lua C API põhineb [[Kuhi (informaatika)|kuhjal]]. Lua tagab funktsioonide tõukamist ja esiletoomist enamikus lihtsates C andmetüüpides (näiteks täisarvud, reaalarvud ja nii edasi) ning kuhjas. Lisaks ka funktsioonid töötlevad tabeleid läbi kuhja. Lua kuhi erineb mõnevõrra traditsioonilisest kuhjast. Kuhi saab olla indekseeritud otse. Negatiivsed indeksid kalduvad kõrvale kuhja ülemisest otsast. Kui −1 on üleval (viimati uuendatud väärtus), kuna positiivsed indeksid annavad märku nihkest alumises otsas (vanad väärtused).

C ja Lua vaheliste andmete kogumise funktsioonid on samuti tehtud kasutades kuhja. Kutsudes Lua funktsiooni, argumendid on surutud kuhja peale ja siis lua_call on kasutatud kutsumaks tegelikku funktsiooni. Kui C-keeles kirjutatud funktsiooni otseselt kutsuda Lua keeles, siis argumendid on loetud kuhjast.

=== Näide ===
Siin on näide sellest, kuidas kutsuda välja Lua funktsiooni C-keeles.

<syntaxhighlight lang="c">
#include <stdio.h>
#include <lua.h> //Lua main library (lua_*)
#include <lauxlib.h> //Lua auxiliary library (luaL_*)

int main(void)
{
    //loome Lua seisundi
    lua_State *L = luaL_newstate();

    //lae ning täida string
    if (luaL_dostring(L, "function foo (x,y) return x+y end")) {
        lua_close(L);
        return -1;
    }

    //lükka globaalne väärtus "foo" (funktsioon on eelnevalt defineeritud)
    //kuhja, jälgitud täisarvude 5 ja 3 poolt.
    lua_getglobal(L, "foo");
    lua_pushinteger(L, 5);
    lua_pushinteger(L, 3);
    lua_call(L, 2, 1); //kutsu funktsioon koos kahe argumendiga ja tagasta üks väärtus.
    printf("Result:%d\n", lua_tointeger(L, -1)); //väljastame väärtuse
    lua_close(L); //sulgeme lua seisundi.
    return 0;
}
</syntaxhighlight>

Näite käitamine annab: 
<pre>$ cc -o example example.c -llua
$ ./example
Result: 8
</pre>

=== Spetsiaalsed tabelid ===
C API samuti tagab mõned spetsiaalsed tabelid lokaliseeritult mitmesuguste "pseudo-indeksitega" Lua kuhjas. LUA_GLOBALSINDEX enne Lua 5.2 on üldises tabelis. _G on peamine nimeruum. Seal on samuti registriga määratud LUA_REGISTRYINDEX, kus C programmid saavad salvestada Lua väärtusi hilisema vajaduse jaoks.

=== Laiendus ja seos ===
Lua API-t kasutades on võimalik kirjutada laiendmooduleid. Laiendmoodulid on jagatud objektid, mis on harjunud laiendama interpreteerija funktsionaalsust, tagades algupärase hõlpsuse Lua skriptidele. Selline moodul ilmub, kui nimeruumi tabelis hoitakse vastavaid funktsioone ja muutujaid. Lua skriptid võivad laadida laiendusmooduleid kasutades <tt>require</tt>,<ref name="luarefman" /> just nagu moodulid oleks kirjutatud Lua keeles endas.

Kasvav moodulite kollektsiooni teatakse kui "rocks", mis on saadaval paketihaldussüsteemi LuaRocks<ref name="ALhQB" /> kaudu, [[CPAN]] vaimus, [[RubyGems]], [[Python Eggs]].

Eelkirjutatud Lua seosed eksisteerivad enamikus populaarsetes programmeerimiskeeltes, sealhulgas skriptimiskeeltes nagu [[C++]]. Seal on mitu mallipõhist juurdepääsu ja mõni automaatne seosegeneraator.

== Rakendused ==

=== Videomängud ===

Videomängude arenduses on Lua mängude programmeerijate poolt laialdaselt kasutatud kui skriptimiskeel ehk tänu selle tajutud lihtsuses manustamisel, kiirel täitmisel ja lühikesel õppimiskõveral.<ref name="xO4LN" />

2003. aastal korraldatud GameDev.neti küsitlus näitas, et Lua on kõige populaarsem skriptimiskeel mängude programmeerimisel.<ref name="6JX3E" /> Lua kuulutati 12. jaanuaril 2012 Front Line Award 2011 võitjaks ajakirjas Game Developer kategoorias "Programmeerimisvahendid".<ref name="XsCfz" /><!--
PALUN ära lisa Robloxit või WoW'i või mõnda teist spetsiifilist mängu. Lua on laialdaselt kasutatud ka meile tuntud mängudes. See on ebaaus, kui üksikult välja tuua ainult mõned ning ei ole neutraalset viisi valimaks, mis peaks olema välja toodud. Palun kasuta: 
[[Kategooria:Lua-keeles loodud arvutimängud]]
või
[[Kategooria:Lua-keelsed mängumootorid]]

selle asemel..
-->

=== Muid rakendusi ===

Muud rakendused, mis on loodud Lua keelega:
<!--
MÄRGE MUUTJATELE!
1) Iga väline või punane link, mis pole läbimõeldud või märkimisväärne, kuulub eemaldamisele. Sa peaks kasutama ennast artikli loomiseks kõigepealt, et näha kas see on märkimisväärne.
 2) Ära loo siia mingisugustki nimekirja MÄNGUDEST või Mängu loomise tarkvarast nagu ROBLOX. Lua mänge on liiga palju, et panna neid siia artiklisse.
  
See osa ei ole NIMISTU Lua-ga seotud tarkvarast – palun ära loo mingit tähestikulist vm klassifikatsiooni.  Kui sa tunned, et see kasvab liiga suureks, siis puhasta seda listi ning eemalda kõik sisestused, mis on vastuolus ülalmainituga. Eemalda need, mida sa pead ebaoluliseks.

Tänud Sulle mõistva suhtumise eest.
-->
* [[3DMLW]] plugin, kasutatakse Lua [[3D computer graphics|3D]]-animatsioonide skriptimiseks ja käsitlemaks erinevaid sündmusi.
* [[Adobe Photoshop Lightroom]], kasutab Lua'd oma kasutaja kasutajaliideses.
* [[Aerospike database|Aerospike Database]], kasutab Lua'd kui oma sisemist skriptimiskeelt oma "UDF" (User Defined Function) suutlikkuse jaoks – sarnased protseduurid.
* [[Apache HTTP Server]], saab kasutada Lua keelt igal pool päringuprotsessis (alates versioon 2.3, läbi tuumse mod_lua mooduli).
* [[Artweaver]], graafika redaktor kasutab Lua'd skriptimisfiltrina.
* [[Autodesk Stingray]], mängumootor, mis kasutab Lua'd videomängude arendamiseks.
* [[Awesome (window manager)|Awesome]], [[aknahaldur]], mis on kirjutatud osaliselt Lua keeles, samuti kasutatakse seda konfiguratsioonifailivorminguna.
* [http://www.eterna.com.au/bozohttpd/ bozohttpd], vaikimisi veebiserver koos [[NetBSD]]-ga,<ref name="ictqp" /> on integreeritud Lua toega dünaamilise sisu loomiseks.<ref name="Loz2S" />
* [[CHDK|The Canon Hack Development Kit]] (CHDK), avaliku lähtekoodiga püsivara Canoni kaameras, kasutatakse Lua kui ühte kahest skriptimiskeelest.
* [[Celestia]], astronoomia hariduslik programm, kasutab Lua keelt kui oma skriptimiskeelt.
* [[Cheat Engine]], mälu redaktor/silur, lubab Lua skripte manustada oma "cheat table" failidesse. Lisaks sisaldab GUI disainijat. 
* [[Cisco Systems|Cisco]], kasutab Lua'l implementeerida dünaamilise juurdepääsu poliise Adaptive Security Appliance'i piires.
* [[Conky (software)|Conky]], Linux süsteemiseire rakendus, mis kasutab Lua arenenud graafika jaoks. 
* [[Cocos2d]], kasutab Lua'd mängude ehitamises koos nende Cocos Code IDE-ga.
* [[Codea]], Lua redaktor [[iOS]]-i operatsioonisüsteemile.
* [[Creative Technology]] [[Creative ZEN#ZEN X-Fi2|Zen X-Fi2]] kohandatud rakendused nagu kaasaskantav meediamängija on loodud Lua keeles. 
* [[Damn Small Linux]], kasutab Lua keelt toetamaks ekraani-sõbraliku kasutajaliidese käsurea vahendeid ilma ohverdamata palju kettaruumi. 
* [[darktable]] avatud lähtekoodiga fotograafia töövoo rakendus, mis on skriptitav Lua'ga.<ref name="tT6UY" />
* [[Dolphin Computer Access]], kasutab Lua skriptimist, tegemaks ligipääsmatuid rakendusi ligipääsetavaks nägemiskahjustusega arvutikasutajatele ekraanilugereid – SuperNova.
* Eyeon'i [[Eyeon Fusion|Fusion]] komponeerija kasutab sisseehitatud Lua'd ja LuaJIT sisemist ja välimiste skriptide jaoks ning samuti laienduste prototüüpimiseks. 
* [[Nintendo Entertainment System|NES]] [[emulator]] [[FCE Ultra]] haru, mida kutsutakse FCEUX-iks, lubab laiendusteks ja mängumodifikatsioonideks kasutada Lua skripte.
* [[Flame (pahavara)|Flame]], suur ja kõrge keerukusega pahavara osa on kasutatud küberkuritegevuses.<ref name="05AFm" />
* [[Foldit]] – teadusele orienteeritud proteiinide kokkupanemise mäng, mis kasutab Lua'd oma skriptides. Mõned selle rakenduse skriptidest on olnud artikli [[Proceedings of the National Academy of Sciences of the United States of America|PNAS]] eesmärk.<ref name="8u9um" />
* [[FreePOPs]], meili vahendaja laiendus, mis kasutab Lua'd oma veebi front-end osa jõudluse parandamiseks. 
* [[Freeswitch]], avatud lähtekoodiga telefoniplatvorm, mis on disainitud hõlbustama heliloomingu loomist ja sõidu ajal rääkimist võimaldavaid tooteid, milles Lua'd kasutatakse kui skriptimiskeelt kõneprotokollide ja kõnevoogude ja teiste asjade jaoks. 
* [[Geany]], koodiredaktor, omab Lua pluginaid, GeanyLua.
* [[Ginga (SBTVD Middleware)|Ginga]], Brasiilia digitaaltelevisiooni süsteemi ([[ISDB-T International|SBTVD või ISDB-T]]) vahevara, kasutab Lua'd kui skriptimiskeelt oma deklaratiivses keskkonnas. Ginga-NCL. Ginga-NCL-is Lua on integreeritud kui meediaobjektid (kutsutakse NCLua) NCL-i (Nested Context Language) dokumentides.
* [[GrafX2]], piksel-joonistamise redaktor, saab käitada Lua skripte lihtsa pildi töötlemiseks või üldiseks illustreerimiseks.
* [[HAProxy]], [[pöördproksi]] tarkvara, võib olla laiendus koos Luaga alates versioonist 1.6.<ref name="53jSJ" />
* [[iClone]], reaalajas animeerimise 3D-stuudio loomaks animafilme, kasutab Lua'd oma uues füüsikasimulatsiooni juhtsüsteemis. 
* Joonistamisredaktor [[Ipe (program)|Ipe]] (peamiselt kasutatud jooniste töötlemiseks [[LaTeX|LaTeX-i]] märgistamisega). Kasutab Lua'd oma funktsionaalsuses ja skriptitud laiendustes. 
* [[Lego Mindstorms NXT]] ja [[Lego Mindstorms NXT 2.0|NXT 2.0]] saab skriptida Lua'ga kasutades kolmanda osapoole tarkvara.<ref name="Ub6yQ" />
* [[lighttpd]] veebiserver, kasutab Lua'd haakimaks skripte sama hästi kui tänapäevane asendus [[Cache Meta Language|Cache Meta Language'ks]].
* [[Logitech]]i profiili haldamise tarkvara versioon 2.01 [[Logitech G15|G15]] mänguklaviatuur kasutab Lua keelt kui oma skriptimiskeelt.
* [https://luakit.github.io/luakit/ luakit] püüab olla kiire ja lihtne [[WebKit]]i-põhine [[brauser]]i raamistik, Lua poolt laiendatav.
* [[LuaTeX]], määratud [[pdfTeX]]-i järglaseks, lubab laiendusi kirjutada Lua keeles.<ref name="luatex" />
* LuCI, vaikimisi brauseri kasutajaliides [[OpenWrt]]. See on kirjutatud peamiselt keeles Lua.<ref name="luci" />
* [[MediaWiki]]<ref name="O09ZQ" /> kasutab Lua kui uut šabloonkeelt, mis on kasutusel [[Wikipedia]]s ja teistes vikides.
* [http://www.public-software-group.org/moonbridge Moonbridge Network Server for Lua Applications] kombinatsioonis [http://www.public-software-group.org/webmcp WebMCPiga], veebiarendamise raamistik, lubab keerulisi veebirakendusi kirjutada Lua keeles (kasutatud [[LiquidFeedback]]i<ref name="cLpVX" /> poolt).
* [[MySQL Workbench]], kasutab Lua keelt oma laienduste jaoks.
* [[NetBSD]], omab Lua [[draiver]]it, mis saab luua ja kontrollida Lua seisundit [[kernel]]i sees. See lubab Lual olla kasutatud pakettide filtreerimiseks ja loomaks seadme draivereid.<ref name="JpzRY" /><ref name="LKHWY" /><ref name="iDkoG" />
* [[Nginx]], omab jõuliselt sisse kinnitatud Lua mooduleid, mis tagavad API ligipääsu Nginx abivahenditele nagu soketi käitlemine.<ref name="sHxix" />
* [[nmap]], internetiturvalisuse kontrollija kasutab Lua keelt kui põhja oma skriptimiskeelele ''nse''.<ref name="U4vS0" />
* [[NodeMCU]], kasutab Lua keelt riistvaras. NodeMCU on [[open source]] riistvara platvorm, mis saab käitada Luad otse [[ESP8266]] [[Wi-Fi]] [[System on a chip|SoC'd]].<ref name="init devkit" />
* [[Sierra Wireless]] AirLink ALEOS GSM / CDMA / LTE juurdepääs lubab kasutaja rakendustel olla kirjutatud Lua keeles. 
* [[OpenResty]] on dünaamiline veebiplatvorm, mis põhineb NGINX-il ja LuaJIT-l. [https://openresty.org/en/].
* Perimeta seansipiirangukontroller [[Metaswitch Networks]]ilt kasutab Lua keelt kui skriptimiskeelt, manipuleerimaks SDP andmetega lennult.<ref name="tlda1" />
* [[PowerDNS]] pakub laiendatud Lua keeles skriptimist teenindamiseks ja DNS-i vastuste muutmiseks, parandamaks katkisi servereid ja DoS-i kaitset. 
* [[Project Dogwaffle]] Professional pakub Lua skriptimist tegemaks filtreid läbi DogLua filtri. Lua filtreid saab jagada Project Dogwaffle, [[GIMP]], Pixarra Twistedbrush ja ArtWeaveri vahel. 
* [[Prosody (software)|Prosody]] on platvormiülene [[Extensible Messaging and Presence Protocol|Jabber/XMPP]] [[server]], mis on kirjutatud keeles Lua.
* [[QSC Audio Products]] toetab Lua keeles skriptimist väliste seadmete kontrollimisel ja teistel kõrgema funktsionaalsusega [http://www.qsc.com/resources/software-and-firmware/q-sys-designer/ Q-SYS Designeris].
* [[Quartz Composer]], visuaalse programmeerimise tööriist [[Apple Inc.|Apple]]'ilt, saab skriptida Lua keeles läbi tasuta plugina, mis on toodetud [[Boinx Software]] poolt.
* [[REAPER]] digitaalse audio tööjaam toetab laienduste funktsionaalsuse Lua keeles skriptimist.
* [[Reason (software)|Reason]] digitaalse audio tööjaam, Lua keelt kasutatakse Remote codec'i kirjeldamiseks. 
* [[Redis]], on avatud lähtekoodiga võtmeväärtusega andmebaas, milles Lua'd saab kasutada (alates versioonist 2.6) keeruliste funktsioonide kirjutamiseks, mis käitab serveris iseennast, seega laiendab oma funktsionaalsust.<ref name="VO4Da" />
* [[RetroShare]] krüptitud failijagamine, serverivaba e-post, hetketeated, jututuba ja BBS tarkvara, põhineb sõbralt-sõbrale võrgul, omab Lua pluginat automatiseerimiseks ja kontrollimiseks.
<!--
PLEASE do NOT add Roblox or any other specific game. Lua is *way* too widely used for us to mention every game, it's unfair to single out just a few, and there's not a good neutral way to pick which would be included.
-->
* [[Rockbox]], avatud lähtekoodiga digitaalse audio püsivara, toetab pluginaid, mis on kirjutatud Lua keeles.
<!-- Read the comments people! -->
* [[RPM Package Manager|RPM]], tarkvarapakettide haldamise süsteem, kõigepealt välja töötatud [[Red Hat Linux]]i jaoks.<ref name="5dYC1" />
* Uus versioon [[SciTE]] redaktorist saab laiendada kasutades Lua'd.
* [[SAS (software)|SAS]] integreerib Lua PROC LUA seisundiga<ref name="KYHnt" />
* [[Snort (software)|Snort]] sissetungi tuvastamise süsteem sisaldab Lua interpretaatorit alates 3.0 beetaväljalaskest.<ref name="kc6V0" />
* [[Squeezebox (network music player)|Squeezebox]] muusika mängijad Logitechilt toetavad pluginaid, mis on kirjutatud Lua'ga hiljutistele mudelitele (Kontroller, Raadio ja Puutuja).
* [[Tarantool]] kasutab Lua keelt kui salvestamise protseduuri keelt oma NoSQL-i andmebaasi haldamise süsteemiga ning tegutseb kui Lua rakenduste server. 
* [[TeamSpeak]] omab Lua keeles skriptimise pluginat modifikatsioonide jaoks.
* [[TI-Nspire]] kalkulaatorid sisaldavad Lua keeles kirjutatud rakendusi alates sellest ajast, kui TI lisas Lua skriptimise toe koos kalkulaatorispetsiifilise API-ga OS 3+'is.
* [[Torch (machine learning)|Torch]] on avatud lähtekoodiga süvaõppe teek Lua keeles.
* [[Transformice]] – iseseisev mitmikmäng tasuta mängitaval veebiplatvormil brauseri mäng, mis kasutab Lua keelt programmeerimaks minimänge.
* [[Varnish (software)|Varnish]] saab käitada Lua skripte nõutud protsessis, laiendades VCL läbi Lua VMOD (Varnish moodul).<ref name="hknHM" />
* [[Vim (text editor)|Vim]] omab Lua keeles skriptimise tuge alates versioonist 7.3.<ref name="hTcsL" />
* [[VLC media player]] kasutab Lua keelt tagamaks skriptimise toe.
* [[WeeChat]] IRC klient aktsepteerib skripte, mis on kirjutatud Lua keeles. 
* [[WinGate]] proksi server lubab sündmuste töötlemise ja Lua skriptide täitmise poliitika ligipääsuga sisemistele WinGate objektidele.
* [[Wireshark]]i võrgupaketi analüüsija lubatud protokolli lahutaja on kirjutatud Lua-ga.<ref name="Rut4f" />
* [[ZeroBrane Studio]] Lua [[Integrated Development Environment|IDE]], mis on kirjutatud Lua keeles ja kasutab Lua'd oma laiendustes.
<!--PALUN ära lisa Robloxit või WoW'i või mõnda teist spetsiifilist mängu. Lua on laialdaselt kasutatud ka meile tuntud mängudes. See on ebaaus, kui üksikult välja tuua ainult mõned ning ei ole neutraalset viisi valimaks, mis peaks olema välja toodud.-->

== Fakte Lua keele kohta ==
* Lua on ainus arengumaalt pärit programmeerimiskeel, mis on saavutanud globaalse tähtsuse.

== Vaata ka ==
* [[Programmeerimiskeel]]

== Viited ==
{{viited|1=30em|allikad=
<ref name="luaspe">{{Cite journal |last=Ierusalimschy |first=Roberto |url=http://www.lua.org/spe.html |title=Lua—An Extensible Extension Language |journal=Software: Practice and Experience |volume=26 |issue=6 |pages=635–652 |date=Juuni 1996 |access-date=24. oktoober 2015 |last2=de Figueiredo |first2=Luiz Henrique |last3=Filho |first3=Waldemar Celes |doi=10.1002/(SICI)1097-024X(199606)26:6<635::AID-SPE26>3.0.CO;2-P}}</ref>
<ref name="luaabout">{{cite web| url = http://www.lua.org/about.html#why| title = About Lua| publisher = Lua.org| accessdate = 11.08.2011}}</ref>
<ref name="hopl2007">{{cite book| last1 = Ierusalimschy | first1 = R.| author1-link = Roberto Ierusalimschy| last2 = Figueiredo| first2 = L. H. | last3 = Celes| first3 = W.| contribution = The evolution of Lua| contribution-url = http://www.lua.org/doc/hopl.pdf| doi = 10.1145/1238844.1238846| title = Proc. of ACM HOPL III| url = http://www.acm.org/sigs/sigplan/hopl| year = 2007| pages = 2–1–2–26| isbn = 978-1-59593-766-7}}</ref>
<ref name="luahist2001">{{cite web|url=http://www.lua.org/history.html|title=The evolution of an extension language: a history of Lua|year=2001|accessdate=18.12.2008}} <!-- {{cite journal| last1 = Ierusalimschy | first1 = R. | author1-link = Roberto Ierusalimschy| last2 = Figueiredo | first2 = L. H.| last3 = Celes | first3 = W. | contribution = The evolution of an extension language: a history of Lua| contribution-url = http://www.lua.org/history.html| title = Proc. of V Brazilian Symposium on Prog. Lang.| year = 2001| pages = B–14–B–28}} --></ref>
<ref name="ddj96">{{Cite news |last=Figueiredo |first=L. H. |url=http://www.lua.org/ddj.html |title=Lua: an Extensible Embedded Language. A few metamechanisms replace a host of features |work=Dr. Dobb's Journal |date=Detsember 1996 |last2=Ierusalimschy |first2=R. |issue=12 |volume=21 |pages=26–33 |last3=Celes |first3=W.}}</ref>
<ref name="lobject_h_array">{{cite web|url=http://www.lua.org/source/5.1/lobject.h.html#array|title=Lua 5.1 Source Code|accessdate=24.03.2011|year=2006}}</ref>
<ref name="lua5impl">{{cite journal| last1 = Ierusalimschy | first1 = R. | last2 = Figueiredo | first2 = L. H. | last3 = Celes | first3 = W. | title = The implementation of Lua 5.0| journal = J. Of Universal Comp. Sci.| volume = 11| issue = 7| pages = 1159–1176| year = 2005| url = http://www.jucs.org/jucs_11_7/the_implementation_of_lua/jucs_11_7_1159_1176_defigueiredo.html}}</ref>
<ref name="luavm51instr">{{cite web| author = Kein-Hong Man| title = A No-Frills Introduction to Lua 5.1 VM Instructions| year = 2006| url = http://luaforge.net/docman/view.php/83/98/ANoFrillsIntroToLua51VMInstructions.pdf}}</ref>
<ref name="luarefman">{{cite web| url = http://www.lua.org/manual/5.2/| title = Lua 5.2 Reference Manual| publisher = Lua.org| accessdate = 23.10.2012}}</ref>
<ref name="luatex">{{Cite web |url=http://www.luatex.org/ |title=LuaTeX |website=luatex.org |access-date=21. aprill 2015}}</ref>
<ref name="luci">{{Cite web |url=http://wiki.openwrt.org/doc/techref/luci |title=LuCI |access-date=2. juuli 2015}}</ref>
<ref name="init devkit">{{Cite web |last=Huang R. |url=https://github.com/nodemcu/nodemcu-devkit |title=NodeMCU devkit |website=Github |access-date=3. aprill 2015}}</ref>
<ref name="qSV1H">{{Cite web |last=Yuri Takhteyev |url=http://www.foreignaffairs.com/articles/139332/yuri-takhteyev/from-brazil-to-wikipedia?page=2 |title=From Brazil to Wikipedia |website=[[Foreign Affairs]] |date=21. aprill 2013 |access-date=25. aprill 2013}}</ref>
<ref name="J29hb">{{cite web|url=http://www.lua.org/manual/5.1/manual.html#2.3|title=Lua 5.1 Reference Manual|accessdate=27.02.2014|year=2014}}</ref>
<ref name="pWO0k">{{cite web|url=http://www.lua.org/manual/5.1/manual.html#2.5.5|title=Lua 5.1 Reference Manual|accessdate=16.10.2012|year=2012}}</ref>
<ref name="ALhQB">{{cite web| url = http://www.luarocks.org/| title = LuaRocks| publisher = LuaRocks wiki| accessdate=24.05.2009}}</ref>
<ref name="xO4LN">url=https://web.archive.org/web/20130820131611/http://stackoverflow.com/questions/38338/why-is-lua-considered-a-game-language |date=20 August 2013 |title=Why is Lua considered a game language?</ref>
<ref name="6JX3E">url=https://web.archive.org/web/20031207171619/http://gamedev.net/gdpolls/viewpoll.asp?ID=163 |date=7 December 2003 |title=Poll Results</ref>
<ref name="XsCfz">url=https://web.archive.org/web/20130615013638/http://www.gdmag.com/blog/2012/01/front-line-award-winners.php |date=15 June 2013 |title=Front Line Award Winners Announced</ref>
<ref name="ictqp">{{cite web|title=how to setup a web server|url=https://wiki.netbsd.org/tutorials/how_to_setup_a_webserver/|website=wiki.netbsd.org|accessdate=28.10.2016}}</ref>
<ref name="Loz2S">{{cite web|title=bozohttpd – NetBSD Manual Pages|url=http://netbsd.gw.com/cgi-bin/man-cgi?bozohttpd++NetBSD-current|website=netbsd.gw.com|accessdate=28.10.2016|archive-date=28.10.2016|archive-url=https://web.archive.org/web/20161028215512/http://netbsd.gw.com/cgi-bin/man-cgi?bozohttpd++NetBSD-current|url-status=dead}}</ref>
<ref name="tT6UY">{{cite web|url=http://www.darktable.org/2013/09/using-lua-with-darktable/|title=Using Lua with darktable}}</ref>
<ref name="05AFm">{{Cite web |last=Zetter |first=Kim |url=http://www.wired.com/threatlevel/2012/05/flame/ |title=Meet 'Flame,' The Massive Spy Malware Infiltrating Iranian Computers |publisher=[[Wired News]] |date=28. mai 2012}}</ref>
<ref name="8u9um">{{cite web|url=http://www.pnas.org/content/early/2011/11/02/1115898108|title=Algorithm discovery by protein folding game players}}</ref>
<ref name="53jSJ">http://blog.haproxy.com/2015/10/14/whats-new-in-haproxy-1-6/{{Kõdulink|aeg=juuni 2023 |bot=InternetArchiveBot |paranduskatse=jah }}</ref>
<ref name="Ub6yQ">{{cite web|url=http://www.hempeldesigngroup.com/lego/pbLua/|title=pbLua Scriptable Operating Systems with Lua|access-date=2017-01-30|archive-date=2008-12-08|archive-url=https://web.archive.org/web/20081208045027/http://www.hempeldesigngroup.com/lego/pbLua/|url-status=dead}}</ref>
<ref name="O09ZQ">[[Wikipedia:Wikipedia Signpost/2012-01-30/Technology report|Technology report]], ''[[Wikipedia:Wikipedia Signpost|Wikipedia Signpost]]'' (30 January 2012)</ref>
<ref name="cLpVX">{{Cite web |last=<!--Staff writer(s); no by-line.--> |url=http://www.public-software-group.org/liquid_feedback_frontend |title=Public Software Group e. V. – LiquidFeedback Frontend |publisher=Public Software Group |website=public-software-group.org |access-date=3. aprill 2015}}</ref>
<ref name="JpzRY">{{cite web|url=http://netbsd.gw.com/cgi-bin/man-cgi?lua+4+NetBSD-current|title=LUA(4) Man Page|publisher=netbsd.gw.com|accessdate=21.04.2015|archive-date=4.03.2016|archive-url=https://web.archive.org/web/20160304084721/http://netbsd.gw.com/cgi-bin/man-cgi?lua+4+NetBSD-current|url-status=dead}}</ref>
<ref name="LKHWY">{{cite web|url=https://www.netbsd.org/gallery/presentations/lneto/eurobsdcon14.pdf|title=NPF Scripting with Lua EuroBSDCon 2014}}</ref>
<ref name="iDkoG">{{cite web|url=https://www.netbsd.org/gallery/presentations/lneto/dls14.pdf|title=Scriptable Operating Systems with Lua|publisher=Dynamic Languages Symposium 2014}}</ref>
<ref name="sHxix">{{cite web|url=http://wiki.nginx.org/HttpLuaModule|title=HttpLuaModule|publisher=Wiki.nginx.org|accessdate=17.07.2013|archive-date=31.07.2013|archive-url=https://web.archive.org/web/20130731012033/http://wiki.nginx.org/HttpLuaModule|url-status=dead}}</ref>
<ref name="U4vS0">{{cite web|title=Nmap Scripting Engine|url=http://nmap.org/book/nse.html|accessdate=10.04.2010}}</ref>
<ref name="tlda1">{{cite web|title=Know Your SBCs|url=http://www.metaswitch.com/sites/default/files/know-your-sbcs-010813_0.pdf|accessdate=8.03.2014|archive-date=7.03.2014|archive-url=https://web.archive.org/web/20140307001616/http://www.metaswitch.com/sites/default/files/know-your-sbcs-010813_0.pdf|url-status=dead}}</ref>
<ref name="VO4Da">{{cite web|title=Redis Lua scripting|url=http://redis.io/commands/eval}}</ref>
<ref name="5dYC1">{{cite web|title=Lua for RPM|url=http://www.rpm.org/wiki/PackagerDocs/RpmLua|access-date=2017-01-30|archive-date=2009-02-10|archive-url=https://web.archive.org/web/20090210004126/http://rpm.org/wiki/PackagerDocs/RpmLua|url-status=dead}}</ref>
<ref name="KYHnt">{{Netiviide |url=https://support.sas.com/documentation/cdl/en/proc/68954/HTML/default/viewer.htm#p0lqta2cbq9b44n12h28nil7a093.htm |pealkiri=Arhiivikoopia |vaadatud=2017-01-30 |arhiivimisaeg=2016-11-19 |arhiivimisurl=https://web.archive.org/web/20161119002821/http://support.sas.com/documentation/cdl/en/proc/68954/HTML/default/viewer.htm#p0lqta2cbq9b44n12h28nil7a093.htm |url-olek=ei tööta }}</ref>
<ref name="kc6V0">{{cite web|title=Lua in Snort 3.0|url=http://www.linuxsecurity.com/content/view/128135/171/|accessdate=10.04.2010|archive-date=27.05.2010|archive-url=https://web.archive.org/web/20100527024154/http://www.linuxsecurity.com/content/view/128135/171/|url-status=dead}}</ref>
<ref name="hknHM">{{cite web|title=VMOD Lua for Varnish 3.0|url=https://www.varnish-cache.org/vmod/lua|accessdate=29.02.2016}}</ref>
<ref name="hTcsL">{{cite web|title=Vim documentation: if_lua|url=http://vimdoc.sourceforge.net/htmldoc/if_lua.html|accessdate=17.08.2011}}</ref>
<ref name="Rut4f">{{cite web|title=Lua in Wireshark|url=http://wiki.wireshark.org/Lua|accessdate=10.04.2010}}</ref>
}}

== Lisalugemist ==
{{Col-begin}}
{{Col-break}}

=== Raamatud ===
* {{cite book | last1 = Gutschmidt | first1 = T. | title = Game Programming with Python, Lua, and Ruby | year = 2003 | publisher = Course Technology PTR | isbn = 1-59200-077-0 }}
* {{cite book | last1 = Schuytema | first1 = P. | last2 = Manyen | first2 = M. | title = Game Development with Lua | url = https://archive.org/details/gamedevelopmentw0000schu | year = 2005 | publisher = Charles River Media | isbn = 1-58450-404-8 }}
* {{cite book | last1 = Jung  | first1 = K. | last2 = Brown | first2 = A. | title = Beginning Lua Programming | year = 2007 | publisher = [[Wrox Press]] | isbn = 0-470-06917-1 | url = http://www.wrox.com/WileyCDA/WroxTitle/productCd-0470069171.html }}
* {{cite book| editor-last  = Figueiredo | editor-first  = L. H. | editor2-last = Celes | editor2-first = W. | editor3-last = Ierusalimschy | editor3-first = R. | title = Lua Programming Gems | publisher = Lua.org | year = 2008 | isbn = 978-85-903798-4-3 | url = http://www.lua.org/gems/ }}
* {{cite book | last = Takhteyev  | first = Yuri | title = Coding Places: Software Practice in a South American City | year = 2012 | publisher = [[The MIT Press]] | isbn = 0-262-01807-1 | url = http://codingplaces.net/ }} Chapters 6 and 7 are dedicated to Lua, while others look at software in Brazil more broadly.
* {{cite book | last=Varma | first=Jayant | title=Learn Lua for iOS Game Development | publisher=[[Apress]] | year=2012 | isbn=1-4302-4662-6 | url=http://www.amazon.com/exec/obidos/ASIN/1430246626/lua-docs-20 }}
* {{cite book | last1 = Ierusalimschy | first1 = R. | title = Programming in Lua | edition = 3rd | year = 2013 | publisher = Lua.org | isbn = 85-903798-5-X | url = http://www.lua.org/pil/ }} (The 1st ed. is available [http://www.lua.org/pil/contents.html online].)
<!--UPDATEME to 5.2: * {{cite book | last1 = Ierusalimschy | first1= R. | last2 = Figueiredo | first2 = L. H. | last3 = Celes  | first3 = W. | title = Lua 5.1 Reference Manual | year= 2006 | publisher = Lua.org | isbn= 85-903798-3-3 | url = http://www.lua.org/manual/5.1/ }}-->

{{Col-break}}

=== Artiklid ===
* {{cite web | url=http://www.gamedev.net/page/resources/_/technical/game-programming/an-introduction-to-lua-r1932 | title=An Introduction to Lua | publisher=[[GameDev.net]] | date=29. aprill 2003 | accessdate=3. jaanuar 2013 | author=Matheson, Ash}}
* {{cite web|url=http://www.onlamp.com/pub/a/onlamp/2006/02/16/introducing-lua.html|title=Introducing Lua|last=Fieldhouse|first=Keith|date=16. veebruar 2006|work=ONLamp.com|publisher=[[O'Reilly Media]]}}
* {{cite web|url=http://www.ibm.com/developerworks/linux/library/l-lua.html|title=Embeddable scripting with Lua|last=Streicher|first=Martin|date=28. aprill 2006|work=developerWorks|publisher=[[IBM]]}}
* {{cite journal |last=Quigley|first=Joseph|date=1. juuni 2007|title=A Look at Lua|journal=[[Linux Journal]]|url=http://www.linuxjournal.com/article/9605}}
* {{cite news|url=http://www.computerworld.com.au/article/260022/a-z_programming_languages_lua/|title=The A-Z of Programming Languages: Lua|last=Hamilton|first=Naomi|date=11. september 2008|work=[[Computerworld]]|publisher=[[International Data Group|IDG]]}} Interview with Roberto Ierusalimschy.
* {{cite journal |url=http://queue.acm.org/detail.cfm?id=1983083|title=Passing a Language through the Eye of a Needle|last1=Ierusalimschy|first1=Roberto|last2=de Figueiredo|first2=Luiz Henrique |last3=Celes|first3=Waldemar|date=12. mai 2011|journal=[[ACM Queue]]|publisher=[[Association for Computing Machinery|ACM]]}} How the embeddability of Lua impacted its design.
* [http://www.lua.org/papers.html Lua papers and theses]
{{col-end}}

== Välislingid ==
* [http://www.lua.org/ Lua] ametlik veebileht
* [http://lua-users.org/ Lua Users], kommuun
* [http://www.eluaproject.net/en_overview.html eLua], Embedded Lua
* [http://luaforge.net/ Projects in Lua]
* [https://code.google.com/p/squilu/ SquiLu], [[Squirrel (programming language)|Squirrel]] modifitseeritud koos Lua teekidega
* [https://github.com/dibyendumajumdar/ravi Ravi], Lua 5.3 derivatiiv koos limiteeritud valikulise staatilise tüüpimisega ja LLVM-il põhinev JIT kompilaator

[[Kategooria:Programmeerimiskeeled]]