Lua (programazio lengoaia)-en iturria ikusi

{{Programazio lengoaia infotaula
| izena = Lua
| logoa = Lua-Logo.svg
| paradigma =  [[Multiparadigma programazio lengoaia|Mutiparadigma]],</br> [[Programazio lengoaia interpretatua|interpretatua]],</br> [[Programazio inperatiboa|inperatiboa]],</br>([[Prozedura bidezko programazioa|prozedurala]],<br />[[Prototipoetan oinarritutako programazioa|prototipoetan oinarrituta]],<br />[[Objektuei bideratutako programazioa|objektuei bideratuta]]), [[Programazio funtzionala|funtzionala]]
| familia = 
| diseinatzailea = Roberto Ierusalimschy<br/> Waldemar Celes<br/> Luiz Henrique de Figueiredo
| garatzailea = 
| agerpena = 1993
| kaleratze egonkorra = 5.3.3 / 2016ko ekainaren 6an
| kaleratze ezegonkorra = 5.3.3 RC3 / 2016ko maiatzaren 30an
| idazketa = 
| esparrua = 
| programazio lengoaia = 
| garapen etena = 
| plataforma = 
| sistema eragilea = 
| lizentzia = MIT Lizentzia
| luzapena = .lua
| formatua = 
| webgunea = http://www.lua.org/
| inplementazioak = 
| dialektoak = 
| eragina = 
| eragindua = 
}}
'''Lua''' [[programazio-lengoaia|programazio lengoaia]] interpretatutako lengoaia [[programazio inperatibo|inperatibo]], [[Programazio egituratua|egituratua]] eta [[lengoaia arinak|arina]] da<ref name=":1">{{Cite aldizkari|abizena=de Figueiredo|izena=Luiz Henrique|egile-lotura=|izenburua=Lua—An Extensible Extension Language|aldizkaria=Software: Practice and Experience|argitaratze-lekua=|liburukia=26|alea=6|data=|urtea=|orrialdea=635–652|url=http://www.lua.org/spe.html|sartze-data=2016ko Urriaren 26a|DOI=10.1002/(SICI)1097-024X(199606)26:6<635::AID-SPE26>3.0.CO;2-P}}</ref>. [[Portuges]]ez ''Lua-k'' ''[[ilargia]]'' esan nahi du. Lua [[multiplataforma]] da, [[ANSI C]]-n idatzita dagoelako<ref name=":2">{{erreferentzia|url=http://www.lua.org/about.html#why|izenburua=About Lua|sartze-data=26-10-2016|egunkaria=|aldizkaria=|abizena=|izena=|egile-lotura=|hizkuntza=en|formatua=}}</ref>, eta [[C (programazio lengoaia)|C]] [[API]] erlatiboki sinple bat dauka<ref>{{erreferentzia|url=http://www.foreignaffairs.com/articles/139332/yuri-takhteyev/from-brazil-to-wikipedia?page=2|izenburua=From Brazil to Wikipedia|sartze-data=26-10-2016|egunkaria=[[Foreign Affairs]]|aldizkaria=|abizena=Takhteyev|izena=Yuri|egile-lotura=|hizkuntza=en|formatua=}}</ref>.

Hasieran Lua [[Aplikazio informatiko|software aplikazioetan]] handitzen zihoan pertsonalizazio eskaerak betetzeko diseinatua izan zen. Programazio lengoaia [[Programazio prozedurala|prozedural]] gehienen oinarrizko funtzioak bete ahal zituen, baina beste funtzionalitate zailagoak edota [[Domeinu espezifikoko lengoaia|domeinu espezifikoko lengoaien]] ezaugarriak ez zeuden bere barne. Bestalde, lengoaia handitzeko mekanismoak zituen, funtzionalitate hauek gehitzeko ahalbidetzen zutenak. Lua sistema integratuentzat diseinatuta zegoenez, bere garatzaileek abiadura, eramangarritasuna, hedapena eta garapenean erraztasuna hobetzean fokatu ziren.

== Historia ==
Lua [[1993]]an sortu zuten [[Roberto Ierusalimschy]]k, [[Luis Henrique de Figueiredo]]k eta [[Waldemar Celes]]ek, Konputagailu Grafikoen Teknologia Taldeko (Tecgraf) kide ziren [[Rio de Janeiroko Unibertsitate Pontifiko Katolikoa]]n, [[Brasil]]en.

1977tik 1992ra, Brasilek [[merkataritzako hesi]] gogorrak (merkatu erreserba deituak) aplikatu zituen konputagailu software eta hardwarearentzako. Egoera horretan, Tecgrafen bezeroek ezin zuten software pertsonalizatua erosi kanpotik. Arrazoi honengatik Tecgrafek behar zituen oinarrizko erremintak ezerezetik inplementatu behar izan zituen.<ref name=":0">{{erreferentzia|hizkuntza=en|izenburua=Proc. of ACM HOPL III|urtea=2007|abizena=Figueiredo Celes|izena=L. H.|orrialdeak=|orrialdea=|argitaletxea=|ISBN=978-1-59593-766-7|url=http://www.acm.org/sigs/sigplan/hopl|DOI=10.1145/1238844.1238846|author=Roberto Ierusalimschy|artikulu-url=http://www.lua.org/doc/hopl.pdf}}</ref>


Luaren "ama eta aita" historikoak SOL (Simple Object Language) eta DEL (Data-entry Language) izan ziren.<ref>{{Web erref|hizkuntza=en|izenburua=The evolution of an extension language: a history of Lua|urtea=2001|abizena=|izena=|orrialdeak=|orrialdea=|argitaletxea=|ISBN=|url=http://www.lua.org/history.html|sartze-data=26-10-2016}}". <!-- {{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> 1992 eta 1993 artean Tecgrafengatik sortuak izan ziren malgutasuna gehitzeko proiektu batzuei (biak ingeniaritzarako programa grafikoak izan ziren [[Petrobras]] enpresan). SOL eta DEL-ek ez zuten fluxu kontrolerako egiturarik, eta Petrobras programazio potenteago baten beharrean zegoen.

Lengoaiaren sortzaileek hau idatzi zuten ''The Evolution of Lua'' liburuan:

{{aipu|1993an, Tcl zen geneukan hautagai bakarra, sistema integratuentzako esplizituki sortua zelako. Hala eta guztiz ere, Tcl-en sintaxia bitxia zen, ez zuen datuen deskripziorako euskarri ona eskaintzen, eta bakarrik Unix plataforman erabili ahal zen. Ez genituen LISP edo Scheme kontsideratu haien sintaxi zailarengatik. Python oraindik bere hasieran zegoen. Azkenean, zuk-egin-ezazu giro bat zegoen Tecgrafen, oso naturala iruditu zitzaigun gure programazio lengoaia sortu behar genuela pentsatzea ... Erabiltzaile potentzial asko ez ziren garatzaile profesionalak, beraz lengoaiak sintaxi eta semantika kriptikoak saihestu behar zituen. Lengoaia berriaren inplementazioa hedatzeko erraza izan behar zen, Tecgrafen bezeroek plataforma oso desberdinetan lan egiten zutelako. Azkenean, beste Tecgrafen produktu batzuek programazio lengoaia integratu bat beharko zutela pentsatu genuenez, lengoaia berri honek SOLen pausuak jarraitu behar zituen eta C-ren APIko liburutegi bezala funtzionatu behar zuen.}}
Lua 1.0 SOL-en data deskriptoreen sintaxia zuten objektu eraikitzaileak inkorporatu zituen (horregatik deitzen da Lua - ''sol'' Portugesez eguzkia da; ''lua'' ilargia). Luaren kontrol egitura sintaxia gehienbat [[Modula]]tik hartua izan zen (if, while, repeat/until), baina [[CLU (programazio lengoaia)|CLU]] (hainbat esleipen eta hainbat return funtzio deietatik, [[Ebaluazio estrategia|erreferentzia parametroen]] eta [[Puntero (informatika)|puntero]] esplizituen ordez), [[C++]]("ideia ona [[aldagai lokala]]k behar den lekuetan bakarrik deklaratzea"<ref name=":0" />), [[SNOBOL]] eta [[AWK]]tik ([[bektore asoziatiboa]]k). [[Dr. Dobb's Journal]]en argitaratutako artikulu batean, Luaren sortzaileek LISP eta Scheme ere lengoaiaren datu egitura nagusia taulak izatearen erabakian asko eragin zietela diote, haien datu egitura ubikuoarengatik ([[Lista (datu abstraktu mota)|listak]]).<ref>{{Cite news|url=http://www.lua.org/ddj.html|abizena=|izena=|izenburua=Lua: an Extensible Embedded Language. A few metamechanisms replace a host of features|data=1996ko Abendua|egunkaria=Dr. Dobb's Journal|formatoa=|hizkuntza=en|sartze-data=2016-10-27}}</ref>

Luaren [[semantika]] Schemerengatik aldatuak izan dira denbora pasa ahala,<ref name=":0" /> gehienbat [[Funtzio anonimoa|funtzio anonimo]] eta [[Esparru (programazioa)|esparru lexiko]] osoen sarrerarekin.

Lua 5.0 bertsioaren aurrekoak [[BSD lizentziak|BSD lizentziarekin]] atera ziren. 5.0 bertsiotik aurrera, Luak [[MIT Lizentzia|MIT lizentzia]] erabiltzen du. Biak dira software libre permisibo lizentziak, eta ia identikoak dira.


== Ezaugarriak ==
Lua programazio lengoaia trinkoa da, beraz plataforma askotan erabili daiteke. Aldagaiek ez dute [[Datu mota|motarik]], bakarrik datuak izan daitezke [[Datu mota logikoa|logikoak]], [[Datu mota osoa|osoak]], [[Datu mota erreala|koma flotagarria]] edo [[Karaktere katea|kateak]]. [[Bektore (informatika)|Bektoreak]], [[Pila (informatika)|pilak]], [[hash taula]]k, [[Lista (informatika)|listak]] eta [[Erregistro (programazioa)|erregistroak]] taulekin (Luan dagoen [[datu egitura]] bakarra) errepresentatu daitezkeen datu egiturak dira.

Lua [[Multiparadigma programazio lengoaia|multiparadigma]] lengoaia da bere semantika hedatu eta aldatu egin ahal delako, datu egituren funtzioak aldatuz ''metataulak'' erabiliz, [[Perl]] bezala (honela [[Herentzia (informatika)|herentziak]] sartu daitezke adibidez, nahiz eta lengoaian berezkoak ez izan).

Luak [[ordena altuko funtzioak]] erabili ditzake, eta [[zabor biltzailea]] ere. Hauek konbinatuz, Lua [[Objektuei orientatutako programazio|objektuei bideratutako programazioan]] erabili daiteke. Beste ezaugarri batzuk [[mota bihurketa]], [[koerrutina]]k eta [[Karga dinamikoa|modulu dinamikoen karga]] dira, besteak beste.

Datu mota kantitate txikia duenez bere barne, Lua ahalmen eta tamainaren arteko oreka bat mantentzen saiatzen da.

== Sintaxia ==
[[Kaixo mundua]] adibidea:
<syntaxhighlight lang="lua">
print("Hello, World!")
</syntaxhighlight>

Honela ere idatzi daiteke:
<syntaxhighlight lang="lua">
io.write("Hello, World!\n")
</syntaxhighlight>

edo [https://web.archive.org/web/20160304095806/http://www.lua.org/cgi-bin/demo?hello Lua orrian] emandako adibidea:<syntaxhighlight lang="lua">
io.write("Kaixo Mundua, ", _VERSION, "tik!\n")
</syntaxhighlight>[[Iruzkina (informatika)|Iruzkinek]] hurrengo sintaxia erabiltzen dute, [[Ada (programazio lengoaia)|Ada]], [[Eiffel (programazio lengoia)|Eiffel]], [[Haskell (programazio lengoaia)|Haskell]], [[SQL]] eta [[VHDL]] antzera:<syntaxhighlight lang="lua">
-- Lua iruzkinak bi gidoiekin hasten dira eta lerroaren amaierararte funtzionatzen dute.

--[[ Hainbat lerrotako iruzkinak eta kateak
    kortxeteak erabiltzen dituzte. ]]

--[=[ Mota honetako iruzkinek beste --[[iruzkin batzuk]] izan ahal dituzte bere barnean. ]=]
</syntaxhighlight>Funtzio [[faktorial]]a hurrengo adibidean bezala inplementatzen da:<syntaxhighlight lang="lua">
function factorial(n)
  local x = 1
  for i = 2, n do
    x = x * i
  end
  return x
end
</syntaxhighlight>

=== Iterazioak ===
Luak lau [[iterazio]] edo [[Begizta (programazioa)|begizta]] mota ditu: <code>while</code>, <code>repeat</code> (''<code>do while</code>''-en antzekoa) <code>for</code> begizta numerikoa, eta <code>for</code> begizta generikoa.<syntaxhighlight lang="lua">
--baldintza = true

while baldintza do
  --deklarazioak
end

repeat
  --deklarazioak
until baldintza

for i = first,last,delta do --delta negatiboa izan daiteke, i aldagaia aurrera edo atzera kontatzen utziz
  --deklarazioak
  --adibidea: print(i)
end
</syntaxhighlight><code>For</code> begizta generikoa:<syntaxhighlight lang="lua">
for key, value in pairs(_G) do
  print(key, value)
end
</syntaxhighlight><code>_G</code> taula iteratuko luke, <code>pairs</code> funtzio iteratiboa erabiliz, nulua bueltatzen duen arte.

Habiatutako begiztak (begizta bat beste begizta baten barnean) ere egin daitezke.<syntaxhighlight lang="lua">
local objektuak = { "kaixo", "epa" }

for i,v in pairs(_G) do
    for indizea,balioa in pairs(objektuak) do
        print(objektuak[indizea])
        print(balioa)
    end
end
</syntaxhighlight>

=== Funtzioak ===
Luaren funtzioen tratamendua ordena altuko balio bezala hurrengo adibidean erakusten da, print funtzioaren portaera aldatzen duena:<syntaxhighlight lang="lua">
do
  local oldprint = print
  -- Print funtzioa oldprintera aldatu
  function print(s)
    --[[ Print funtzioa berdefinitu, print normala oldprinten bidez deitu daiteke. Berriak argumentu bakarra dauka.]]
    oldprint(s == "foo" and "bar" or s)
  end
end
</syntaxhighlight>Edozein print dei funtzio berritik pasatuko da orain, eta Luaren [[Esparru (programazioa)|esparru lexikoaengatik]], print funtzio zaharra funtzio berritik bakarrik erabili ahal izango da.

Luak [[Itxidura (informatika)|itxidurentzako]] euskarria du, behean erakusten den bezala:<syntaxhighlight lang="lua">
function gehitu(x)
  -- Funtzio bat bueltatu x gehitzen diona argumentuari
  return function(y)
    --[=[ x aldagaiaz hitz egiten ari garenean, esparru honen kanpoan dagoena
       eta bere bizi-zikloa funtzio anonimo hau baino laburragoa izango dena, 
       Luak itxidura bat sortzen du.]=]
    return x + y
  end
end
gehilau = gehitu(4)
print(gehilau(3)) -- 7 bueltatzen du

--Hau ere funtzioa honako era honetan deituz lortu daiteke:
print(gehitu(4)(3))
--[[ Hau bueltatzen den 'gehitu(4)' funtzioa '3' argumentuarekin zuzen deitzen ari garelako gertatzen da.
     Honek datuen kostua erreduzitzen ditu eta errendimiendua hobetzen du iteratiboki deitzerakoan.
]]
</syntaxhighlight>Gehitu funtzioa deitzen den bakoitzean itxidura berri bat sortzen da x aldagaiarentzako, beraz funtzio bakoitzak bere x parametroa erabiliko du, erroreak saihestuz. Itxidura Luaren zabor biltzaileak kudetuko du, edozein objektu bezala.

=== Taulak ===
Taulak Luan dauden datu egitura garrantzitsuenak (diseinuz, dauden [[Datu mota konposatua|datu mota konposatu]] bakarrak) dira, eta erabiltzaileak sortutako datu mota guztien oinarria. PHPko [[Bektore asoziatiboa|bektore asoziatiboen]], Pythonen hiztegien eta Perl edo Rubyren hashen kontzeptu antzerakoak dituzte.

Taulak datu eta gakoez osatutako pare bilduma da, non datua gakoarengatik erreferentziatuta dagoen. Gako bat (indizea) edozein balio (nulua eta [[NaN]] izan ezik) izan daiteke. 1 balioa duen gako numerikoa "1" kate gakoaren desberdina dela kontuan hartuko da.

Taulak <code>{}</code> sintaxia duen eraikitzailea erabiltzen sorten dira:

<syntaxhighlight lang="lua">
taula_bat = {} -- Taula berri eta hutsa sortzen du
</syntaxhighlight>Taulak beti erreferentzialki erabiltzen dira (ikus. [[Objektu deia]])<syntaxhighlight lang="lua">
taula_bat = {x = 10} -- Taula berri bat sortzen du, "x" gakoa 10 baliora apuntatzen
print(taula_bat["x"]) --[[ Kate gakoarekin asoziatuta dagoen balioa bueltatzen du,
                        kasu honetan 10.]]
taula_bi = taula_bat
taula_bi["x"] = 20 -- Taularen balioa "x" gakoan 20 balioa da orain
print(taula_bi["x"]) -- 20 bueltatzen du.
print(taula_bat["x"]) --[[ 20 ere bueltatzen du, taula_bat eta taula_bi taula
                        berdinera apuntatzen dutelako.]]
</syntaxhighlight>

==== Erregistro bezala ====
Taulak askotan [[Objektu konposizioa|egitura]] (edo [[Erregistro (informatika)|erregistro]]) bezala erabiltzen dira [[Katea (informatika)|kateak]] erabiliz gako bezala. Erabilera hori hain komuna denez, Luak sintaxi berezia dauka eremu horietan sartzeko. Adibidez:<syntaxhighlight lang="lua">
puntua = { x = 10, y = 20 } -- Taula berria sortu
print(puntua["x"]) -- 10 bueltatzen du
print(puntua.x) --[[ Goiko lerroaren berdina egiten du, irakurterraza
                                den puntu notazioa azukre sintaktikoa bakarrik da.]]
</syntaxhighlight>Lua 5.3 Erreferentzia Manualean agertzen den bezala<ref>{{erreferentzia|url=http://www.lua.org/manual/5.3/manual.html#3.2|izenburua=Lua 5.3 Reference Manual|sartze-data=2016-10-28|egunkaria=|aldizkaria=|abizena=|izena=|egile-lotura=|hizkuntza=en|formatua=}}</ref>:

{{aipu|ald.Izena sintaxia ald.['Izena']-ren [[azukre sintaktikoa]] da}}

==== Izen tarte bezala ====
Taula batean bere funtzio erlazionatuak gordetzean, izen tarte bezala funtzionatu dezake.<syntaxhighlight lang="lua">
Puntua = {}

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

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

==== Bektore bat bezala ====
Gako numeriko bat erabiliz, taulak [[bektore datu mota]]k izan daitezke. Lua bektoreak 1-oinarrikoak dira: lehenengo indizea 1 da eta ez 0 beste programazio lengoaia asko bezala (baina 0 indizea esplizituki gehitu daiteke)

Kate bektore sinple bat:<syntaxhighlight lang="lua">
bekt = { "a", "b", "c", "d" } -- Indizeak automatikoki ezartzen dira.
print(bekt[2]) -- "b" bueltatzen du, Luaren indizea 1etik hasten delako.
print(#bekt) -- 4 bueltatzen du. # taulen eta kateen luzera jakiteko operandoa da.
bekt[0] = "z" -- Zero indize legala da.
print(#bekt) -- 4 bueltatzen du oraindik, Lua bektoreak 1-oinarrikoak direlako.
</syntaxhighlight>T taularen luzera edozein integer n izan daiteke, beraz t[n] ez da nulua eta t[n+1] nulua da; t[1] nulua bada, n zero izan daiteke. Bektore erregulark batentzat, balio ez nuluekin 1etik n-ra, bere luzera n hori da, azken balioaren indizea. Bektoreak "zuloak" baditu (hau da, balio nuluak nuluak ez diren balioen artean), orduan #t balio nulu bat baino lehenago dagoen edozein indize izan daiteke. Beraz, edozein balio nulu hartu dezake bektorearen amaiera bezala.

Bi dimentsioko taula:<syntaxhighlight lang="lua">
NireTaula =
{
     {1,2,3,4},
     {5,6,7,8}
}
print(NireTaula[1][3]) -- "3" bueltatzen du
print(NireTaula[2][4]) -- "8" bueltatzen du
</syntaxhighlight>Objektu bektore bat:<syntaxhighlight lang="lua">
function Puntu(x, y) -- "Puntu" objektu eraikitzailea
  return { x = x, y = y }   -- Objektu berria sortu eta bueltatzen du (taula)
end
bekt = { Puntu(10, 20), Puntu(30, 40), Puntu(50, 60) } -- Puntu bektore bat sortzen du
                        -- bekt = { { x = 10, y = 20 }, { x = 30, y = 40 }, { x = 50, y = 60 } };
print(bekt[2].y)
</syntaxhighlight>Hash taulak erabiltzea bektore bat emulatzeko normalean bektorea bera erabiltzea baino geldoagoa da. Lua taulak bektore bezala erabiltzeko optimizatuta daude arazo hau saihesteko.<ref>{{erreferentzia|url=http://www.lua.org/source/5.3/lobject.h.html#array|izenburua=Lua 5.3 Source Code|sartze-data=2016-10-28|egunkaria=|aldizkaria=|abizena=|izena=|egile-lotura=|data=2015|hizkuntza=en|formatua=}}</ref>

=== Metataulak ===
Semantika hedagarria Luaren zati garrantzitsu bat da, eta [[metataula]] kontzeptuak Lua taulak era potentean pertsonalizatzea ahalbidetzen du. Hurrengo adibideak taula "infinitua" adierazten du. Edozein <math>n</math>-rako, fibs[n] <math>n</math>. [[Fibonacciren zenbakiak|Fibonacciren zenbakia]] bueltatuko du [[programazio dinamiko]]a eta [[memoizazioa]] erabiliz.<syntaxhighlight lang="lua">
fibs = { 1, 1 } -- Hasierako balioak fibs[1] eta fibs[2]rentzako.
setmetatable(fibs, {
  __index = function(balioak, n)                --[[ __index Luak duen berezko funtzio bat da,
                                                    "n" gakoa existitzen ez bada deitzen zaio. ]]
    balioak[n] = balioak[n - 1] + balioak[n - 2]  -- fibs[n] kalkulatu eta memoizatu.
    return balioak[n]
  end
})
</syntaxhighlight>

=== Objektuetara bideratutako programazioa ===
Nahiz eta Luak [[Klasea (informatika)|klaseen]] kontzeptua berez inplementatuta ez eduki, lengoaiak dituen bi ezaugarrirekin gehitu daitezke: [[ordena altuko funtzioa]]k eta taulak. Funtzioak eta haiekin erlazionatuta dauden datuak taula batean sartuz, objektu bat sortzen da. [[Herentzia (informatika)|Herentzia]] (singularra eta plurala) [[metataula]] mekanismoarekin inplementatu daitezke, objektuari metodo ezezagunak eta eremuak bere aita objektuan/etan esanez.

Ez dago "klase" kontzeptu bat teknika hauekin, termino zehatzagoa [[Prototipoetan oinarritutako programazioa|prototipoa]] izango litzateke, [[Self (programazio lengoaia)|Self]] eta [[JavaScript]] moduko lengoaietan bezala. Objektu berriak [[Factory method (diseinu patroia)|factory method]] (objektu berriak zerotik sortzen dituena) edo existitzen den proiektu bat klonatzen sortzen dira.

Luak [[azukre sintaktikoa]] dauka bere barnean objektuetata bideratutako programazioa errazagoa egiteko. Objektu baten [[Metodoa (informatika)|metodoak]] prototipo taula batean adierazteko, taula:func(args) funtzioa erabili daiteke, taula.func(self, args)-en berdina dena. Klase metodoak deitzerakoan bi puntu erabili daitezkeBar object:funrgs), object.func(object, args)-en berdina dena.

Oinarrizko [[Bektore (matematika)|bektore]] objektu baten adibidea:<syntaxhighlight lang="lua">
local Bektore = {}
Bektore.__index = Bektore

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

function Bektore:magnitude() -- Beste metodo bat
  -- 'self' erabiliz gure objektua erreferentziatu dezakegu
  return math.sqrt(self.x^2 + self.y^2 + self.z^2)
end

local bek = Bektore:new(0, 1, 0) -- Bektore objektu bat sortu
print(bek:magnitude()) -- Metodo bat deitu (irteera: 1)
print(bek.x) -- Objektuaren aldagai bati dei egin (irteera: 0)
</syntaxhighlight>

== Barnekoak ==
Lua programak ez dira zuzenean testu fitxategitik [[Lengoaia interpretatua|interpretatzen]]; bytecodean konpilatzen dira eta [[makina birtual]] batean exekutatzen dira. Konpilazio prozesua ikustezina izaten da erabiltzailearentzat eta [[exekuzio denbora]]n egiten da. Jada konpilatuta dauden fitxategiak erabili daitezke errendimiendua igotzeko eta memoria erabilera gutxitzeko. Lua bytecodea lengoaian produzituta eta exekutatuta izan daiteke ere, string liburutegiko ''dump'' funtzioa eta ''load/loadstring/loadfile'' funtzioak erabiliz. Lua 5.3.3 bertsioak 24000 C lengoaieko lerro ditu bere barnean.<ref name=":1" /><ref name=":2" />

PUZ gehienek bezala, eta makina birtual gehienek ez bezala (piletan oinarrituta daudenak), Lua VM erregistroak erabiltzen ditu, eta beraz egungo hardware diseinutik hurbil dabil. Erregistro arkitekturak beharrezkoak ez diren balioen kopiak sahiesten ditu eta funtzio bakoitzeko instrukzio gutxiago erabiltzen dira. Lua 5en makina birtuala erabilera asko duen erregistroetan oinarritutako VM puruetako bat da<ref>{{Cite aldizkari|abizena=Figuereido|izena=L. H.|egile-lotura=|izenburua=The implementation of Lua 5.0|aldizkaria=Journal Of Universal Computer Science|argitaratze-lekua=|liburukia=11|alea=7|data=|urtea=2005|url=http://www.jucs.org/jucs_11_7/the_implementation_of_lua/jucs_11_7_1159_1176_defigueiredo.html|sartze-data=|issn=|hizkuntza=en}}</ref>. [[Perl]]en [[Parrot makina birtuala|Parrot]] eta [[Android]]en [[Dalvik]] dira beste bi erregistroetan oinarritutako VM ezagunak.

Hemen ikusi dezakegu goiko funtzio faktorialaren bytecode zerrenda (luac 5.1 konpilatzaileak erakusten duen bezala):<ref>{{erreferentzia|url=http://luaforge.net/docman/view.php/83/98/ANoFrillsIntroToLua51VMInstructions.pdf|izenburua=A No-Frills Introduction to Lua 5.1 VM Instructions|sartze-data=|egunkaria=|aldizkaria=|abizena=|izena=|egile-lotura=Kein-Hong Man|data=2006|hizkuntza=en|formatua=PDF}}</ref>

 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 beste aplikazio batzuen barnean egoteko diseinatuta dago, eta [[C (programazio lengoaia)|C]] [[API]] bat eskaintzen du honetarako. APIa bi zatitan dago: Lua nukleoa eta Lua liburutegi osagarria.<ref name=":3">{{erreferentzia|url=http://www.lua.org/manual/5.3/|izenburua=Lua 5.3 Reference Manual|sartze-data=2016-11-03|egunkaria=|aldizkaria=|abizena=|izena=|egile-lotura=|hizkuntza=en|formatua=}}</ref>

Luaren API diseinuak C lengoaieko [[Erreferentzia zenbaketa|erreferentzia kudeaketa]] manuala saihesten du, Pythonen APIa ez bezala. API hau, lengoaiaren bezala, minimalista da. Funtzio konplexuagoak liburutegi osagarriak ahalbidetzen ditu, gehienbat [[Aurreprozesatzailea|aurreprozesatzaile]] [[Makro (informatika)|makroez]] osatuta dagoena eta taula operazio konplexuetan laguntzen duena.

=== Pilak ===
Lua C APIa [[Pila (informatika)|piletan]] oinarrituta dago. Luak C datu mota sinpleenekin (integerrak, floatak, etab.) ''push'' eta ''pop'' egiteko eta pilan taulak manipulatzeko funtzioak dauzka. Luaren pila pila tradizional baten ezberdina da nolabait; pila hauei zuzenean indize bat esleitu dakieke, adibidez. Indize negatiboak pilaren goikaldetik zenbatera dauden adierazten dute, beraz, -1 pilaren goikaldea adierazten du (hau da, sartu den balio berriena) eta balio positiboek azpitik zenbatera dauden adierazten dute (balio zaharrena).

C eta Luaren arteko datuen [[Marshalling (informatika)|marshallinga]] pila erabiltzen egiten da. Lua funtzio bat deitzeko, argumentuak sartzen dira pilan. Orduan, lua_call erabltzen da funtzioa deitzeko. C funtzio bat Luatik zuzenean deitzeko idazterakoan, argumentuak pilatik irakurtzen dira.

=== Adibidea ===
Honako funtzio honetan Lua funtzio bat deitzen da Ctik:<syntaxhighlight lang="c">
#include <stdio.h>
#include <lua.h> //Lua oinarrizko liburutegia (lua_*)
#include <lauxlib.h> //Lua liburutegi osagarria (luaL_*)

int main(void)
{
    //Lua deklarazio bat sortu
    lua_State *L = luaL_newstate();

    //string (kate) bat kargatu eta exekutatu
    if (luaL_dostring(L, "function foo (x,y) return x+y end")) {
        lua_close(L);
        return -1;
    }

    //"foo" globalaren (goian dagoen funtzioaren) balioa 
    //stackean sartu, 5 eta 3 integerrez jarraitua
    lua_getglobal(L, "foo");
    lua_pushinteger(L, 5);
    lua_pushinteger(L, 3);
    lua_call(L, 2, 1); //bi argumentu eta bueltzatze balio bakarra duen funtzio bat deitu
    printf("Result: %d\n", lua_tointeger(L, -1)); //pilaren goikaldean dagoen integer balioa idatzi
    lua_close(L); //Lua deklarazioa itxi
    return 0;
}
</syntaxhighlight>
Adibide hau exekutatzeak hau bueltatzen du:

 $ cc -o example example.c -llua 
 $ ./example 
 Result: 8

=== Taula bereziak ===
C APIak taula bereziak eskaintzen ditu, Lua pilaren "pseudo-indize" batzuetan kokatuak. Lua 5.2 baino lehen<ref>{{erreferentzia|url=http://www.lua.org/manual/5.2/manual.html#8.3|izenburua=Changes in the API – Lua 5.2 Reference Manual|sartze-data=2016-11-04|egunkaria=|aldizkaria=|abizena=|izena=|egile-lotura=|hizkuntza=en|formatua=}}</ref> <code>LUA_GLOBALSINDEX</code> da globalen taula, <code>_G</code> Luaren barnean, eta oinarrizko [[izen tartea]] da. <code>LUA_REGISTRYINDEX</code> erregistro bat ere dago non C programak Lua balioak gorde dezaketen, gero erabiltzeko.

=== Hedapena eta atzipena ===
Posiblea da hedapen moduluak idaztea Lua APIa erabiliz. Hedapen moduluak interpretatzailearen funtzionalitatea hedatzeko balio duten [[Liburutegia (informatika)#Karga dinamikoa|liburutegi dinamikoak]] dira. Lua aldetik, modulua izen tarte taula bat bezala agertuko da bere funtzio eta aldagaiekin. Lua programak hedapen moduluak kargatu ditzakete <code>require</code> erabiliz<ref name=":3" />, Luan idatzitako moduluek bezala.

''LuaRocks'' [[pakete kudeaketa sistema]]k Lua modulu asko dauzka aukeran, [[CPAN]], [[RubyGems]] eta [[Setuptools|Python Eggsen]] antzera. Moduluei ''rock'' deitzen zaie, eta handik datorkio izena. Beste modulu batzuk [https://web.archive.org/web/20161120122906/http://lua-users.org/wiki/LuaAddons http://lua-users.org/] daukan wikian aurkitu daitezke.<ref>{{erreferentzia|url=http://lua-users.org/wiki/LuaAddons|izenburua=Lua Addons|sartze-data=2016-11-04|egunkaria=|aldizkaria=|abizena=|izena=|egile-lotura=|hizkuntza=en|formatua=}}</ref>

Aurreidatzitako Lua [[Lengoaia atzipena|atzipenak]] jada existitzen dira programazio lengoaia erabilienetan<ref>{{erreferentzia|url=http://lua-users.org/wiki/BindingCodeToLua|izenburua=Binding Code to Lua|sartze-data=2016-11-04|egunkaria=|aldizkaria=|abizena=|izena=|egile-lotura=|hizkuntza=en|formatua=}}</ref>. C++en txantiloi batzuk daude eta atzipen sortzaile automatikoak ere.

== Aplikazioak ==

=== Bideo-jokoak ===
[[Bideo-jokoen garapena|Bideo-jokoen garapenean]], Lua [[Script|scripting lengoaia]] oso erabilia da, beharbada bere lizentzia zabaldua, exekuzio arina, integrazio maila eta [[ikasketa kurba]] laburrarengatik. Crytek eta CryEngine [[motore grafikoa]]k Lua eta C++ean diseinatuta daude.<ref>{{erreferentzia|url=http://docs.cryengine.com/display/SDKDOC4/Lua+Scripting|izenburua=Lua Scripting - Technical Documentation|sartze-data=2016-11-04|egunkaria=|aldizkaria=|abizena=Kaye|izena=David Paul|egile-lotura=|hizkuntza=en|formatua=}}</ref>

2012. urtean, TigForums webguneko erabiltzaile batek jokoentzarako scripting lengoaia erabiliena zein zen galdetu zuen inkesta batean, eta Lua atera zen irabazle diferentzia handi batekin.<ref>{{erreferentzia|url=https://forums.tigsource.com/index.php?topic=24770.0|izenburua=Your favorite scripting language|sartze-data=2016-11-04|egunkaria=|aldizkaria=|abizena=|izena=|egile-lotura=|hizkuntza=en|formatua=}}</ref> 2012ko Urtarrilaren 12an [[Game Developer (aldizkaria)|Game Developer]] aldizkariaren Front Line Award 2011 irabazle agertu zen Lua Programazio Erreminten kategorian.<ref>{{erreferentzia|url=https://web.archive.org/web/20130615013638/http://gdmag.com/blog/2012/01/front-line-award-winners.php|izenburua=Front Line Award Winners Announced|sartze-data=2016-11-04|egunkaria=|aldizkaria=Game Developer|abizena=|izena=|egile-lotura=|hizkuntza=en|formatua=}}</ref>

== Erreferentziak ==
{{erreferentzia zerrenda|zabalera=30em}}

== Kanpo estekak ==
* {{en}} [http://www.lua.org Webgune ofiziala]
{{autoritate kontrola}}

[[Kategoria:Programazio lengoaiak]]
[[Kategoria:Plataforma anitzeko softwarea]]
[[Kategoria:Sistema txertatuak]]