„Lua (programozási nyelv)” változatai közötti eltérés
[ellenőrzött változat] | [ellenőrzött változat] |
Nl (vitalap | szerkesztései) Visszavontam 81.182.12.221 (vita) szerkesztését (oldid: 17550528) |
frissítés a jelenlegi verzióra, formázás |
||
7. sor: | 7. sor: | ||
| megvalósítások ='''Lua''', [http://luajit.org/ LuaJIT], [http://code.google.com/p/llvm-lua/ LLVM-Lua], [http://code.google.com/p/lua-alchemy/ Lua Alchemy] |
| megvalósítások ='''Lua''', [http://luajit.org/ LuaJIT], [http://code.google.com/p/llvm-lua/ LLVM-Lua], [http://code.google.com/p/lua-alchemy/ Lua Alchemy] |
||
| kiindulási nyelv = [[C++]], [[CLU (programozási nyelv)|CLU]], [[Modula-2|Modula]], [[Scheme (programozási nyelv)|Scheme]], [[SNOBOL]] |
| kiindulási nyelv = [[C++]], [[CLU (programozási nyelv)|CLU]], [[Modula-2|Modula]], [[Scheme (programozási nyelv)|Scheme]], [[SNOBOL]] |
||
| befolyásolt nyelvek=[[Io (programozási nyelv)|Io]]<!--2002-->, [[GameMonkey Script|GameMonkey]]<!--2003-->, [[Squirrel (programozási nyelv)|Squirrel]]<!--2003-->, [[Falcon (programozási nyelv)|Falcon]]<!--2003-->, [[MiniD]]<!--2006--> |
| befolyásolt nyelvek=[[Io (programozási nyelv)|Io]]<!-- 2002 -->, [[GameMonkey Script|GameMonkey]]<!-- 2003 -->, [[Squirrel (programozási nyelv)|Squirrel]]<!-- 2003 -->, [[Falcon (programozási nyelv)|Falcon]]<!-- 2003 -->, [[MiniD]]<!-- 2006 --> |
||
| operációs rendszer = [[platformfüggetlen|többplatformos]] |
| operációs rendszer = [[platformfüggetlen|többplatformos]] |
||
}} |
}} |
||
17. sor: | 17. sor: | ||
== Szintaxisa == |
== Szintaxisa == |
||
===Nyelvi elemek=== |
|||
=== Nyelvi elemek === |
|||
Az azonosítók betűkből, számokból, aláhúzásjelekből építkezhetnek, ahol az első jel nem lehet szám. A betűkészlet a helyi beállításoktól függ. Egy jel betű volta ellenőrizhető az <code>isalpha</code>, szám volta az <code>isalnum</code> függvénnyel. |
Az azonosítók betűkből, számokból, aláhúzásjelekből építkezhetnek, ahol az első jel nem lehet szám. A betűkészlet a helyi beállításoktól függ. Egy jel betű volta ellenőrizhető az <code>isalpha</code>, szám volta az <code>isalnum</code> függvénnyel. |
||
24. sor: | 26. sor: | ||
A Lua forráskódban a kis- és nagybetűk nem minősülnek azonosnak. |
A Lua forráskódban a kis- és nagybetűk nem minősülnek azonosnak. |
||
===Típusok=== |
=== Típusok === |
||
A Lua beépített típusai: |
A Lua beépített típusai: |
||
*nil |
|||
*boolean |
|||
*number |
|||
*string |
|||
*table |
|||
*function |
|||
*userdata |
|||
*thread |
|||
* nil |
|||
A nil típusnak egyetlen eleme van, a <code>nil</code>. A globális változók alapértelmezett értéke; a változók törölhetők is úgy, hogy értéküket <code>nil</code>re állítjuk. Fontos hibaforrás, hogy a [[Ruby (programozási nyelv)|Rubyhoz]] hasonlóan csak a <code>nil</code> és a <code>false</code> hamis, az üres string vagy a nulla nem. A logikai műveletek: and, or, not. |
|||
* boolean |
|||
* number |
|||
* string |
|||
* table |
|||
* function |
|||
* userdata |
|||
* thread |
|||
Egy nil típusú változónak egyetlen lehetséges értéke van, a <code>nil</code>. Ez a globális változók alapértelmezett értéke; a változók törölhetők is úgy, hogy értéküket <code>nil</code>-re állítjuk. |
|||
A számok alapértelmezetten dupla pontosságú lebegőpontos számok. Nincs külön egész típus. A számokon végezhető műveletek operátorai: +, -, *, /, és a hatványozás jele, a ^. Az összehasonlításra a ==, ~=, <, >, <=, >= operátorok szolgálnak. |
|||
Egy logikai változónak két lehetséges értéke van: <code>true</code> és <code>false</code>. Fontos hibaforrás, hogy a [[Ruby (programozási nyelv)|Rubyhoz]] hasonlóan csak a <code>nil</code> és a <code>false</code> hamis, az üres string vagy a nulla nem. A logikai műveletek: <code>and</code>, <code>or</code>, <code>not</code>. |
|||
A számok alapértelmezetten dupla pontosságú lebegőpontos számok. Nincs külön egész típus. A számokon végezhető műveletek operátorai: <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, és a hatványozás jele, a <code>^</code>. Az összehasonlításra a <code>==</code>, <code>~=</code> (nem egyenlő), <code><</code>, <code>></code>, <code><=</code>, <code>>=</code> operátorok szolgálnak. |
|||
A függvények tárolhatók változókban, és átadhatók paraméterként. A C-ben írt programkönyvtárak felhasználásának elősegítésére a C függvények is kezelhetők így. Függvényhíváskor akkor is ki kell tenni a zárójelet, ha nem adunk meg paramétereket. A [[Java (programozási nyelv)|Java]]ban megszokott <code>this</code> itt <code>self</code>. Metódusok hívásakor az objektumot is fel kellene sorolni a paraméterek között: |
A függvények tárolhatók változókban, és átadhatók paraméterként. A C-ben írt programkönyvtárak felhasználásának elősegítésére a C függvények is kezelhetők így. Függvényhíváskor akkor is ki kell tenni a zárójelet, ha nem adunk meg paramétereket. A [[Java (programozási nyelv)|Java]]ban megszokott <code>this</code> itt <code>self</code>. Metódusok hívásakor az objektumot is fel kellene sorolni a paraméterek között: |
||
53. sor: | 59. sor: | ||
A thread a többszálú programozás programszálainak típusa. |
A thread a többszálú programozás programszálainak típusa. |
||
A rövid |
A rövid stringek megadhatók egyszeres vagy kétszeres idézőjelek között. Hosszabb stringek megadhatók <code>[[hosszú szöveg]]</code>> formában is. A hosszú stringekben levő utasítások, escape sorozatok nem hajtódnak végre. Minden fajta string tárolhat tetszőleges Unicode karaktereket, amik a C fordító <code>char</code> típusára képeződnek le. A fájlokat azonban mindig binárisan érdemes kezelni, mivel a nyelv az <code>stdio</code> C könyvtárat használja, ami azonban nem garantálja a különféle kódolások megfelelő kezelését. |
||
Az escape sorozatok ugyanazok, mint |
Az [[Feloldójel (informatika)|escape sorozatok]] ugyanazok, mint C-ben. |
||
A userdata C |
A userdata C-ben megvalósított adattípusokat tárol. Módosítani, rajta műveleteket végrehajtani csak C függvényekkel lehet, a Lua csak értékadást és egyenlőségvizsgálatot biztosít hozzá. |
||
====Táblák==== |
|||
A table a Lua egyetlen összetett típusa, ami a tömbök és az asszociatív tömbök közös általánosítása. Két részből állnak, a tömb és az asszociatív tömb részből. A ciklusok végigiterálhatnak csak a tömb részen, vagy az egész táblán is. A táblák indexelése a legtöbb nyelvtől eltérően 1-től kezdődik. Explicit lehet értéket adni a nulladik elemnek, de a tömbrészen végigiteráló ciklusok ezt az elemet kihagyják. |
|||
==== Táblák ==== |
|||
Tömb típusú táblák létrehozhatók így: |
|||
A table a Lua egyetlen összetett típusa, [[asszociatív tömb]]. A kulcsok lehetnek számok (ajánlottan csak egészek), stringek, másik táblák vagy függvények. A táblák automatikus indexelése a modernebb nyelvekhez hasonlóan 1-től kezdődik, mivel a 0 index hiánya nem igényel kihasználatlan helyfoglalást. |
|||
Bejárásuk kétféle módon lehetséges: csak az egész típusú kulcsokat (és a hozzájuk tartozó értékeket) nézzük végig 1-től az első nem létező kulcsig (<code>ipairs</code>) vagy az összes kulcs-érték párt (<code>pairs</code>). |
|||
Táblák létrehozhatók így: |
|||
<source lang="lua"> |
<source lang="lua"> |
||
x={3.14, |
x = {3.14, "ez egy string"} |
||
</source> |
</source> |
||
Ilyenkor az egyes értékeket sorban az 1, 2, 3, ... kulcsokhoz rendeli. |
|||
Asszociatív tömb esetén az egyes kulcsokhoz egyenként kell értéket rendelni. |
|||
String kulcsokat így lehet használni: |
|||
<source lang="lua"> |
|||
x = |
|||
{ |
|||
nev = "Kovács János", |
|||
kor = 46, |
|||
fizetes = {ertek = 10000, penznem = "Ft"} |
|||
} |
|||
</source> |
|||
A táblák referencia szerint adódnak át: |
A táblák referencia szerint adódnak át: |
||
< |
<source lang="lua"> |
||
a_table = {x = 10} -- Új tábla, egy kulcs-érték pár: "x" kulcs a 10-es számhoz. |
a_table = {x = 10} -- Új tábla, egy kulcs-érték pár: "x" kulcs a 10-es számhoz. |
||
print(a_table["x"]) -- A string kulcshoz tartozó érték kiíratása; itt 10. |
print(a_table["x"]) -- A string kulcshoz tartozó érték kiíratása; itt 10. |
||
78. sor: | 99. sor: | ||
print(b_table["x"]) -- Az új érték kiíratása: 20. |
print(b_table["x"]) -- Az új érték kiíratása: 20. |
||
print(a_table["x"]) -- ez is 20-at ír, mert az a_table és a b_table ugyanarra a táblára hivatkozik. |
print(a_table["x"]) -- ez is 20-at ír, mert az a_table és a b_table ugyanarra a táblára hivatkozik. |
||
</source> |
|||
</syntaxhighlight> |
|||
Kulcsok, értékek beszúrása, eltávolítása: |
Kulcsok, értékek beszúrása, eltávolítása: |
||
< |
<source lang="lua"> |
||
myTable = {"a", "b"} |
|||
table.insert(myTable,"c") |
table.insert(myTable, "c") |
||
print(unpack(myTable)) -- eredménye: a b c |
|||
table.remove(myTable,2) |
table.remove(myTable, 2) |
||
print(unpack(myTable)) -- eredménye: a c |
|||
</source> |
|||
</syntaxhighlight> |
|||
=== Megjegyzések === |
=== Megjegyzések === |
||
Egysoros megjegyzés: |
Egysoros megjegyzés: |
||
<source lang="lua"> |
<source lang="lua"> |
||
94. sor: | 118. sor: | ||
</source> |
</source> |
||
Több soros megjegyzés: |
|||
<source lang="lua"> |
<source lang="lua"> |
||
--[[Ide egy |
--[[Ide egy |
||
több soros |
|||
többsoros |
|||
megjegyzés |
megjegyzés |
||
került]] |
került]] |
||
103. sor: | 127. sor: | ||
=== Változók === |
=== Változók === |
||
A változók nevükkel hivatkozhatók. |
A változók nevükkel hivatkozhatók. |
||
A táblában levő értékek hivatkozhatók a tömböknél megszokott módon |
A táblában levő értékek hivatkozhatók a tömböknél megszokott módon, pl. <code>a[4]</code>. Ha a kulcs string, akkor használható az <code>a["nev"]</code> és <code>a.nev</code> alak is. |
||
A változók láthatóság szempontjából háromfélék lehetnek: globális, lokális, és táblamezők. A változók deklarációjuktól kezdve egészen a legkisebb befoglaló blokk végéig láthatók. Egy változó lokálissá tehető, ha <code>local</code> |
A változók láthatóság szempontjából háromfélék lehetnek: globális, lokális, és táblamezők. A változók deklarációjuktól kezdve egészen a legkisebb befoglaló blokk végéig láthatók. Egy változó lokálissá tehető, ha <code>local</code> kulcsszóval deklaráljuk. A függvények paraméterei is lokálisnak tekinthetők. Minden más változó globális. A deklarált, de értéket még nem kapott változók értéke <code>nil</code>. A függvények látják hívási helyük lokális változóit. |
||
=== Elágazás === |
=== Elágazás === |
||
A Lua csak a két irányú elágazást ismeri, a több ágú elágazás valójában csak szintaktikus cukorka: |
A Lua csak a két irányú elágazást ismeri, a több ágú elágazás valójában csak szintaktikus cukorka: |
||
134. sor: | 160. sor: | ||
=== Ciklusok === |
=== Ciklusok === |
||
'''Elöltesztelő [[ciklus (programozás)|ciklus]]:''' |
|||
Elöltesztelő [[ciklus (programozás)|ciklus]]: |
|||
<source lang="lua"> |
<source lang="lua"> |
||
while (feltétel) do |
while (feltétel) do |
||
142. sor: | 169. sor: | ||
Addig hajtja végre a ciklusmagot, amíg a feltétel igaz. |
Addig hajtja végre a ciklusmagot, amíg a feltétel igaz. |
||
Hátultesztelő ciklus' |
|||
<source lang="lua"> |
<source lang="lua"> |
||
repeat |
repeat |
||
150. sor: | 177. sor: | ||
A ciklusmagot egyszer mindenképpen végrehajtja, majd utána addig hajtja végre a ciklust, amíg a feltétel hamis (igazzá nem válik). Az until ciklus valójában csak szintaktikus cukorka, nem hoz létre új láthatósági tartományt. |
A ciklusmagot egyszer mindenképpen végrehajtja, majd utána addig hajtja végre a ciklust, amíg a feltétel hamis (igazzá nem válik). Az until ciklus valójában csak szintaktikus cukorka, nem hoz létre új láthatósági tartományt. |
||
Számlálós ciklus: |
|||
<source lang="lua"> |
<source lang="lua"> |
||
for index = start,finish,delta do |
for index = start,finish,delta do |
||
165. sor: | 192. sor: | ||
</source> |
</source> |
||
Iteráló ciklus: |
|||
<source lang="lua"> |
<source lang="lua"> |
||
174. sor: | 201. sor: | ||
A <code>lista</code> összes elemén végigiterál, egészen addig, amíg <code>nil</code> értéket nem kap. |
A <code>lista</code> összes elemén végigiterál, egészen addig, amíg <code>nil</code> értéket nem kap. |
||
==Függvények== |
== Függvények == |
||
A Luában a függvények átadhatók paraméterként, sőt, visszatérési értékek is lehetnek, ahogy a következő példa mutatja: |
A Luában a függvények átadhatók paraméterként, sőt, visszatérési értékek is lehetnek, ahogy a következő példa mutatja: |
||
< |
<source lang="lua"> |
||
do |
do |
||
local oldprint = print -- a jelenlegi print függvény eltárolása oldprint néven |
local oldprint = print -- a jelenlegi print függvény eltárolása oldprint néven |
||
188. sor: | 216. sor: | ||
end |
end |
||
end |
end |
||
</source> |
|||
</syntaxhighlight> |
|||
A régi print függvény csak az új print függvényen keresztül érhető el. |
A régi print függvény csak az új print függvényen keresztül érhető el. |
||
194. sor: | 222. sor: | ||
A Lua a lezártakat is támogatja: |
A Lua a lezártakat is támogatja: |
||
< |
<source lang="lua"> |
||
function addto(x) |
function addto(x) |
||
-- Return a new function that adds x to the argument |
-- Return a new function that adds x to the argument |
||
206. sor: | 234. sor: | ||
fourplus = addto(4) |
fourplus = addto(4) |
||
print(fourplus(3)) -- Prints 7 |
print(fourplus(3)) -- Prints 7 |
||
</source> |
|||
</syntaxhighlight> |
|||
Valahányszor meghívódik az <code>addto</code>, annyiszor új lezárt jön létre az <code>x</code> változóhoz. Így a névtelen függvény mindig hozzáfér a paraméteréhez. A lezártat, mint minden más objektumot, a szemétszedő gyűjti be. |
Valahányszor meghívódik az <code>addto</code>, annyiszor új lezárt jön létre az <code>x</code> változóhoz. Így a névtelen függvény mindig hozzáfér a paraméteréhez. A lezártat, mint minden más objektumot, a szemétszedő gyűjti be. |
||
=== Metatáblák === |
=== Metatáblák === |
||
A metatáblák új lehetőségeket nyújtanak a táblák felhasználására. A következő példa egy végtelen táblát mutat be. Minden <math>n</math>-re <code>fibs[n]</code> az <math>n</math><sup>th</sup>-edik [[Fibonacci-számok|Fibonacci-szám]]ot adja a dinamikus programozás és a memorizálás segítségével: |
A metatáblák új lehetőségeket nyújtanak a táblák felhasználására. A következő példa egy végtelen táblát mutat be. Minden <math>n</math>-re <code>fibs[n]</code> az <math>n</math><sup>th</sup>-edik [[Fibonacci-számok|Fibonacci-szám]]ot adja a dinamikus programozás és a memorizálás segítségével: |
||
< |
<source lang="lua"> |
||
fibs = { 1, 1 } -- fibs[1] fibs[2] kezdőértékei. |
fibs = { 1, 1 } -- fibs[1] fibs[2] kezdőértékei. |
||
setmetatable(fibs, { |
setmetatable(fibs, { |
||
219. sor: | 249. sor: | ||
end |
end |
||
}) |
}) |
||
</source> |
|||
</syntaxhighlight> |
|||
Egy másik példa: a __call metametódus az objektumorientáltság érzetét adja: |
Egy másik példa: a __call metametódus az objektumorientáltság érzetét adja: |
||
< |
<source lang="lua"> |
||
newPerson = {} -- Új tábla 'newPerson' néven. |
newPerson = {} -- Új tábla 'newPerson' néven. |
||
236. sor: | 266. sor: | ||
print(Bill.Name, Bill.Age) -- A name és az age attributumok kiíratása. |
print(Bill.Name, Bill.Age) -- A name és az age attributumok kiíratása. |
||
</source> |
|||
</syntaxhighlight> |
|||
====Struktúrák==== |
|||
==== Struktúrák ==== |
|||
Bár a Luában nincs adatszerkezet rekordok létrehozására, mint például C-ben a <code>struct</code>, a táblák erre a célra is használhatók. Ezt a használatot a nyelv szintaktikusan támogatja: |
Bár a Luában nincs adatszerkezet rekordok létrehozására, mint például C-ben a <code>struct</code>, a táblák erre a célra is használhatók. Ezt a használatot a nyelv szintaktikusan támogatja: |
||
< |
<source lang="lua"> |
||
point = { x = 10, y = 20 } -- Új tábla |
point = { x = 10, y = 20 } -- Új tábla |
||
print(point["x"]) -- Az "x" koordináta kiíratása, itt 10 |
print(point["x"]) -- Az "x" koordináta kiíratása, itt 10 |
||
print(point.x) -- Ugyanaz, mint az előző sorban, csak másként. |
print(point.x) -- Ugyanaz, mint az előző sorban, csak másként. |
||
</source> |
|||
</syntaxhighlight> |
|||
==== Névterek ==== |
|||
====Névterek==== |
|||
A táblák összetartozó függvényeket is tárolhatnak, ezzel átvehetik a névterek szerepét: |
A táblák összetartozó függvényeket is tárolhatnak, ezzel átvehetik a névterek szerepét: |
||
< |
<source lang="lua"> |
||
Point = {} |
Point = {} |
||
Point.new = function (x, y) |
Point.new = function (x, y) |
||
257. sor: | 290. sor: | ||
point.x = x |
point.x = x |
||
end |
end |
||
</source> |
|||
</syntaxhighlight> |
|||
====Tömbök==== |
|||
==== Tömbök ==== |
|||
A Lua táblák tömbökként is használhatók: |
A Lua táblák tömbökként is használhatók: |
||
< |
<source lang="lua"> |
||
array = { "a", "b", "c", "d" } -- Az indexek automatikusan számozódnak. |
array = { "a", "b", "c", "d" } -- Az indexek automatikusan számozódnak. |
||
print(array[2]) -- A "b"-t írja ki. A Lua 1-től kezdi a tömbelemek indexelését. |
print(array[2]) -- A "b"-t írja ki. A Lua 1-től kezdi a tömbelemek indexelését. |
||
267. sor: | 302. sor: | ||
array[0] = "z" -- A 0 index használata. |
array[0] = "z" -- A 0 index használata. |
||
print(#array) -- A nulladik index nem számítódik bele a hosszba. |
print(#array) -- A nulladik index nem számítódik bele a hosszba. |
||
</source> |
|||
</syntaxhighlight> |
|||
Objektumok tömbjeként: |
Objektumok tömbjeként: |
||
< |
<source lang="lua"> |
||
function Point(x, y) -- A "Point" objektum konstruktora |
function Point(x, y) -- A "Point" objektum konstruktora |
||
return { x = x, y = y } -- Új objektum létrehozása és visszaadása |
return { x = x, y = y } -- Új objektum létrehozása és visszaadása |
||
276. sor: | 311. sor: | ||
array = { Point(10, 20), Point(30, 40), Point(50, 60) } -- Pontok tömbje |
array = { Point(10, 20), Point(30, 40), Point(50, 60) } -- Pontok tömbje |
||
print(array[2].y) -- 40-et ír ki |
print(array[2].y) -- 40-et ír ki |
||
</source> |
|||
</syntaxhighlight> |
|||
A Lua táblák tömbrésszel és assziociatív tömbrésszel vannak implementálva. Korábban az egészet asszociatív tömbbel valósították meg, de ez az ábrázolás gyorsabb.<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=2011-03-24|year=2006}}</ref> |
A Lua táblák tömbrésszel és assziociatív tömbrésszel vannak implementálva. Korábban az egészet asszociatív tömbbel valósították meg, de ez az ábrázolás gyorsabb.<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=2011-03-24|year=2006}}</ref> |
||
==Felhasználói modulok== |
== Felhasználói modulok == |
||
A Lua lehetővé teszi új modulok létrehozását. A modulok kezelésére rendelkezésre áll a Luarocks modulkezelő. |
A Lua lehetővé teszi új modulok létrehozását. A modulok kezelésére rendelkezésre áll a Luarocks modulkezelő. |
||
289. sor: | 325. sor: | ||
! Modul!! Leírás |
! Modul!! Leírás |
||
|- |
|- |
||
| LuaFileSystem|| Hozzáférés a könyvtárszerkezethez és a fájlok jogaihoz |
| LuaFileSystem || Hozzáférés a könyvtárszerkezethez és a fájlok jogaihoz |
||
|- |
|- |
||
| LuaDoc|| Dokumentációs eszköz a Lua-kódhoz. |
| LuaDoc || Dokumentációs eszköz a Lua-kódhoz. |
||
|- |
|- |
||
| LuaSocket|| Lua interfész a hálózati protokollokhoz: [[Hypertext Transfer Protocol|HTTP]], [[File Transfer Protocol|FTP]], [[Simple Mail Transfer Protocol|SMTP]], [[Multipurpose Internet Mail Extensions|MIME]], [[Uniform Resource Locator|URL]] és [[LTN12]]. |
| LuaSocket || Lua interfész a hálózati protokollokhoz: [[Hypertext Transfer Protocol|HTTP]], [[File Transfer Protocol|FTP]], [[Simple Mail Transfer Protocol|SMTP]], [[Multipurpose Internet Mail Extensions|MIME]], [[Uniform Resource Locator|URL]] és [[LTN12]]. |
||
|- |
|- |
||
| LuaSQL|| Lua interfész a következőkhöz: [[PostgreSQL]], [[Open Database Connectivity|ODBC]], [[MySQL]], [[SQLite]], [[Oracle]] és az [[OLE DB]]. |
| LuaSQL || Lua interfész a következőkhöz: [[PostgreSQL]], [[Open Database Connectivity|ODBC]], [[MySQL]], [[SQLite]], [[Oracle]] és az [[OLE DB]]. |
||
|- |
|- |
||
| stdlib|| Gyakori feladatok programkönyvtára a listákhoz, táblákhoz, a funkcionális és az objektumorientált programozáshoz, meg a reguláris kifejezésekhez. |
| stdlib || Gyakori feladatok programkönyvtára a listákhoz, táblákhoz, a funkcionális és az objektumorientált programozáshoz, meg a reguláris kifejezésekhez. |
||
|- |
|- |
||
| [[Message-Digest Algorithm 5|MD5]]|| Egyszerű kriptográfia |
| [[Message-Digest Algorithm 5|MD5]] || Egyszerű kriptográfia |
||
|- |
|- |
||
| Copas|| Párhuzamosság támogatása, a korutinok képességeinek bővítése |
| Copas || Párhuzamosság támogatása, a korutinok képességeinek bővítése |
||
|- |
|- |
||
| LuaZip|| A .zip fájlok kezeléséhez. |
| LuaZip || A .zip fájlok kezeléséhez. |
||
|- |
|- |
||
| LuaInterface|| Kapcsolatot teremt a Lua és a [[Microsoft]] [[.NET keretrendszer|.NET]] [[Common Language Runtime|Common Language Runtime (CLR)]] között. |
| LuaInterface || Kapcsolatot teremt a Lua és a [[Microsoft]] [[.NET keretrendszer|.NET]] [[Common Language Runtime|Common Language Runtime (CLR)]] között. |
||
|- |
|- |
||
| LuaBitOps|| C nyelvű kiterjesztés a számokon végzett bitenkénti műveletekhez. |
| LuaBitOps || C nyelvű kiterjesztés a számokon végzett bitenkénti műveletekhez. |
||
|- |
|- |
||
| LuaXML || Az XML és a Lua társítása. |
| LuaXML || Az XML és a Lua társítása. |
||
|- |
|- |
||
| Lanes|| Több Lua környezet párhuzamos futtatása |
| Lanes || Több Lua környezet párhuzamos futtatása |
||
|- |
|- |
||
| Penlight|| Táblák, tömbök, stringek, fájlok, könyvtárak, adatok és funkcionális eszközök kezelelésének egyszerűsítése. |
| Penlight || Táblák, tömbök, stringek, fájlok, könyvtárak, adatok és funkcionális eszközök kezelelésének egyszerűsítése. |
||
|- |
|- |
||
| Oil|| Egyszerű és hatékony Object Request Broker ([[Common Object Request Broker Architecture|CORBA]]). |
| Oil || Egyszerű és hatékony Object Request Broker ([[Common Object Request Broker Architecture|CORBA]]). |
||
|} |
|} |
||
== Hello, World! == |
== Hello, World! == |
||
A klasszikus [[„Helló, világ!” program|Hello World!]] program Lua nyelven: |
A klasszikus [[„Helló, világ!” program|Hello World!]] program Lua nyelven: |
||
<source lang="lua"> |
<source lang="lua"> |
||
324. sor: | 361. sor: | ||
</source> |
</source> |
||
==A program futtatása== |
== A program futtatása == |
||
A virtuális gép nem közvetlenül a Lua szkriptet hajtja végre, hanem futás közben bájtkódra fordítja, és ez fut. A szkriptek futtatás nélkül is fordíthatók. Maga a fordítás átlátható. |
A virtuális gép nem közvetlenül a Lua szkriptet hajtja végre, hanem futás közben bájtkódra fordítja, és ez fut. A szkriptek futtatás nélkül is fordíthatók. Maga a fordítás átlátható. |
||
344. sor: | 382. sor: | ||
10 [6] RETURN 0 1 |
10 [6] RETURN 0 1 |
||
==C API== |
== C API == |
||
A Luát alkalmazásokba ágyazott nyelvnek fejlesztették, ezért könnyen használható, robusztus C API-val látták el. Az API két részből áll: ezek a Lua core és a Lua auxiliary library.<ref name=luarefman>{{cite web| url = http://www.lua.org/manual/5.1/| title = Lua 5.1 Reference Manual| publisher = Lua.org| accessdate = 2009-05-24}}</ref> Kiküszöböli a C kézi hivatkozáskezelését. Az API a nyelvhez hasonlóan minimalisztikus; a funkcionalitás bővítéséért az auxiliary library felelős, ami preprocesszor makrókkal egyszerűsíti a táblakezelést. |
A Luát alkalmazásokba ágyazott nyelvnek fejlesztették, ezért könnyen használható, robusztus C API-val látták el. Az API két részből áll: ezek a Lua core és a Lua auxiliary library.<ref name=luarefman>{{cite web| url = http://www.lua.org/manual/5.1/| title = Lua 5.1 Reference Manual| publisher = Lua.org| accessdate = 2009-05-24}}</ref> Kiküszöböli a C kézi hivatkozáskezelését. Az API a nyelvhez hasonlóan minimalisztikus; a funkcionalitás bővítéséért az auxiliary library felelős, ami preprocesszor makrókkal egyszerűsíti a táblakezelést. |
||
===Verem=== |
|||
=== Verem === |
|||
A Lua C API verem alapú. A veremműveleteket Lua függvények valósítják meg, továbbá léteznek táblakezelő függvények is, amik a veremből is hívhatók. Ez a verem indexelhető is. A [[Python (programozási nyelv)|Python]] tömbökhöz hasonlóan negatív indexek is használhatók; ezek a verem tetejétől (-1 a legfelső elem), a pozitív indexek a verem aljától számítódnak. |
A Lua C API verem alapú. A veremműveleteket Lua függvények valósítják meg, továbbá léteznek táblakezelő függvények is, amik a veremből is hívhatók. Ez a verem indexelhető is. A [[Python (programozási nyelv)|Python]] tömbökhöz hasonlóan negatív indexek is használhatók; ezek a verem tetejétől (-1 a legfelső elem), a pozitív indexek a verem aljától számítódnak. |
||
A C ésa Lua közötti kommunikációt szintén a verem valósítja meg. A Lua függvénynek átadott argumentumok a verembe kerülnek, és az aktuális függvény <code>lua_call</code> utasítással hívható. Ha C függvényt hívunk Luából, akkor az a verem tetejéről veszi a paramétereket. |
A C ésa Lua közötti kommunikációt szintén a verem valósítja meg. A Lua függvénynek átadott argumentumok a verembe kerülnek, és az aktuális függvény <code>lua_call</code> utasítással hívható. Ha C függvényt hívunk Luából, akkor az a verem tetejéről veszi a paramétereket. |
||
===Példa=== |
|||
=== Példa === |
|||
Lua függvény hívása C-ből: |
Lua függvény hívása C-ből: |
||
< |
<source lang="c"> |
||
#include <stdio.h> |
#include <stdio.h> |
||
#include <stdlib.h> |
#include <stdlib.h> |
||
370. sor: | 413. sor: | ||
return 0; |
return 0; |
||
} |
} |
||
</source> |
|||
</syntaxhighlight> |
|||
Fordítás és futtatás: |
Fordítás és futtatás: |
||
378. sor: | 421. sor: | ||
Result: 8 |
Result: 8 |
||
</pre> |
</pre> |
||
===Speciális táblák=== |
|||
=== Speciális táblák === |
|||
A C API speciális táblákat is elérhetővé tesz, amik pszeudoindexekkel hivatkozhatók a Lua veremből. A <code>LUA_GLOBALSINDEX</code> tárolja a globális változókat, <code>_G</code> a fő névtér. A <code>LUA_REGISTRYINDEX</code>-ben tárolják a C függvények a Lua értékeket későbbi felhasználásra. |
A C API speciális táblákat is elérhetővé tesz, amik pszeudoindexekkel hivatkozhatók a Lua veremből. A <code>LUA_GLOBALSINDEX</code> tárolja a globális változókat, <code>_G</code> a fő névtér. A <code>LUA_REGISTRYINDEX</code>-ben tárolják a C függvények a Lua értékeket későbbi felhasználásra. |
||
===Kiterjesztés és kötés=== |
|||
=== Kiterjesztés és kötés === |
|||
Kiterjesztő modulok is készíthetők a Lua API használatával. Ezek a könyvtárak kiterjesztik az értelmező funkcionalitását. A Lua szempontjából ezek névterek, vagyis táblák a maguk változóival és függvényeivel. Ezek a modulok a <code>require</code> kulcsszóval tölthetők be.<ref name=luarefman /> |
Kiterjesztő modulok is készíthetők a Lua API használatával. Ezek a könyvtárak kiterjesztik az értelmező funkcionalitását. A Lua szempontjából ezek névterek, vagyis táblák a maguk változóival és függvényeivel. Ezek a modulok a <code>require</code> kulcsszóval tölthetők be.<ref name=luarefman /> |
||
387. sor: | 434. sor: | ||
Vannak csomagok a grafikus felülethez, a Perl/POSIX szabályos kifejezésekhez, a titkosításhoz, afájltömörítéshez és még sok máshoz. A legtöbb népszerű nyelvhez vannak Lua kötések, például más szkript nyelvekhez.<ref>{{cite web| url = http://lua-users.org/wiki/BindingCodeToLua| title = Binding Code To Lua| publisher = Lua-users wiki| accessdate = 2009-05-24}}</ref> A C++ megközelítés sablon alapú, és automatikus generátorokat használ. |
Vannak csomagok a grafikus felülethez, a Perl/POSIX szabályos kifejezésekhez, a titkosításhoz, afájltömörítéshez és még sok máshoz. A legtöbb népszerű nyelvhez vannak Lua kötések, például más szkript nyelvekhez.<ref>{{cite web| url = http://lua-users.org/wiki/BindingCodeToLua| title = Binding Code To Lua| publisher = Lua-users wiki| accessdate = 2009-05-24}}</ref> A C++ megközelítés sablon alapú, és automatikus generátorokat használ. |
||
==Alkalmazásai== |
== Alkalmazásai == |
||
<!--Kéretik nem videojáték témájú példákat beírni, mert akkor szinte mindegyiket felsorolhatnánk.--> |
|||
<!-- Kéretik nem videojáték témájú példákat beírni, mert akkor szinte mindegyiket felsorolhatnánk. --> |
|||
*A videojátékok fejlesztésében a játékfejlesztők elterjesztették a Luát, mivel gyors, könnyen beágyazható és könnyen tanulható.<ref>{{cite web |url=http://stackoverflow.com/questions/38338/why-is-lua-considered-a-game-language |title=Why is Lua considered a game language? |publisher=[[Stack Overflow]] |accessdate=2010-04-23}}</ref> 2012 januárjában a Game Developer Magazine a Luát hirdette győztesnek a Programming Tools kategóriában, és a Front Line Award 2011-et adományozta neki.<ref>[http://www.gdmag.com/blog/2012/01/front-line-award-winners.php Front Line Award Winners Announced]</ref> Egy példa a népszerű [[Minecraft]] nevű videojáték; a hozzá készült [[Computercraft]] mod számítógépei is Lua nyelvet használnak. |
|||
*A [[3DMLW]] plugin Luát használ háromdimenziós megjelenítésre és eseménykezelésre. |
|||
* A videojátékok fejlesztésében a játékfejlesztők elterjesztették a Luát, mivel gyors, könnyen beágyazható és könnyen tanulható.<ref>{{cite web |url=http://stackoverflow.com/questions/38338/why-is-lua-considered-a-game-language |title=Why is Lua considered a game language? |publisher=[[Stack Overflow]] |accessdate=2010-04-23}}</ref> 2012 januárjában a Game Developer Magazine a Luát hirdette győztesnek a Programming Tools kategóriában, és a Front Line Award 2011-et adományozta neki.<ref>[http://www.gdmag.com/blog/2012/01/front-line-award-winners.php Front Line Award Winners Announced]</ref> Egy példa a népszerű [[Minecraft]] nevű videojáték; a hozzá készült [[Computercraft]] mod számítógépei is Lua nyelvet használnak. |
|||
*Az [[Adobe Photoshop Lightroom]] felhasználói interfésznek. |
|||
* A [[3DMLW]] plugin Luát használ háromdimenziós megjelenítésre és eseménykezelésre. |
|||
*Az [[Apache HTTP Server]] a 2.3 verziótól kezdve képes Lua használatára bárhol a lekérési folyamatban. |
|||
* Az [[Adobe Photoshop Lightroom]] felhasználói interfésznek. |
|||
*Az [[Artweaver]] képszerkesztőben szkriptelésre. |
|||
* Az [[Apache HTTP Server]] a 2.3 verziótól kezdve képes Lua használatára bárhol a lekérési folyamatban. |
|||
*Az [[Awesome]] ablakkezelő részben Luában íródott. Konfigurációs fájlja is Lua szkript. |
|||
* Az [[Artweaver]] képszerkesztőben szkriptelésre. |
|||
*A [[The Canon Hack Development Kit]] (CHDK) nyílt forrású Canon kamerakezelőben a Lua a kettő közül az egyik szkript nyelv. |
|||
* Az [[Awesome]] ablakkezelő részben Luában íródott. Konfigurációs fájlja is Lua szkript. |
|||
*A [[Celestia]] csillagászat témájú tanítóprogram szkript nyelve. |
|||
* A [[The Canon Hack Development Kit]] (CHDK) nyílt forrású Canon kamerakezelőben a Lua a kettő közül az egyik szkript nyelv. |
|||
*A [[Cisco]] ezen a nyelven implementálja a Dynamic Access Policiest az Adaptive Security Appliance-ban. |
|||
* A [[Celestia]] csillagászat témájú tanítóprogram szkript nyelve. |
|||
*A [[Creative Technology Zen X-Fi2]] hordozható médialejátszó beállításai Luában is szerkeszthetők. |
|||
* A [[Cisco]] ezen a nyelven implementálja a Dynamic Access Policiest az Adaptive Security Appliance-ban. |
|||
*A [[Damn Small Linux]] Luát használ mind az ablakozó rendszer, mind a parancssor kényelmi funkcióihoz. |
|||
* A [[Creative Technology Zen X-Fi2]] hordozható médialejátszó beállításai Luában is szerkeszthetők. |
|||
*A [[Dolphin Computer Access]]ben a [[SuperNova]] képernyőolvasó is Lua szkript. |
|||
*A [[ |
* A [[Damn Small Linux]] Luát használ mind az ablakozó rendszer, mind a parancssor kényelmi funkcióihoz. |
||
* A [[Dolphin Computer Access]]ben a [[SuperNova]] képernyőolvasó is Lua szkript. |
|||
*A NES emulator FCE Ultra [[Fork (szoftverfejlesztés)|forkja]], a [[FCEUX]] lehetővé teszi a játékok szerkesztését Lua szkriptekkel. |
|||
* A [[Fusion]] szerkesztő Luát használ szkriptelésre és plugin prototípushoz. |
|||
*A [[Flame]], egy hírhedt számítógépes kémkedésre használt program. |
|||
* A NES emulator FCE Ultra [[Fork (szoftverfejlesztés)|forkja]], a [[FCEUX]] lehetővé teszi a játékok szerkesztését Lua szkriptekkel. |
|||
*A [[Foldit]], egy fehérjehajtogató játék, lehetővé teszi a Luában írt felhasználói szkriptek alkalmazását.<ref>[http://www.pnas.org/content/early/2011/11/02/1115898108 Algorithm discovery by protein folding game players]</ref> |
|||
* A [[Flame]], egy hírhedt számítógépes kémkedésre használt program. |
|||
*A [[FreePOPs]] levelezőrendszer webes felülete. |
|||
* A [[Foldit]], egy fehérjehajtogató játék, lehetővé teszi a Luában írt felhasználói szkriptek alkalmazását.<ref>[http://www.pnas.org/content/early/2011/11/02/1115898108 Algorithm discovery by protein folding game players]</ref> |
|||
*A [[Brazilian Digital Television System]] [[Ginga]] middlewarja Luát használ deklaratív környezetének szkript nyelveként. |
|||
* A [[FreePOPs]] levelezőrendszer webes felülete. |
|||
*A [[GrafX2]] pixel-art szerkesztő képes Lua szkripteket futtatni képgeneráláshoz és képfeldolgozáshoz. |
|||
* A [[Brazilian Digital Television System]] [[Ginga]] middlewarja Luát használ deklaratív környezetének szkript nyelveként. |
|||
*A [[Garry's Mod]] nevű videojátékban lehet a Lua segítségével úgynevezett "szkriptelt fegyvereket" készíteni, de objektumok is létrehozhatók. |
|||
* A [[GrafX2]] pixel-art szerkesztő képes Lua szkripteket futtatni képgeneráláshoz és képfeldolgozáshoz. |
|||
*Az [[Ipe]] képszerkesztő szkript és funkcionális kiterjesztései. |
|||
* A [[Garry's Mod]] nevű videojátékban lehet a Lua segítségével úgynevezett "szkriptelt fegyvereket" készíteni, de objektumok is létrehozhatók. |
|||
*A [[Lego Mindstorms NXT]] és az [[Lego Mindstorms NXT 2.0|NXT 2.0]] is bírja a Luát.<ref>[http://www.hempeldesigngroup.com/lego/pbLua/ pbLua]</ref> |
|||
* Az [[Ipe]] képszerkesztő szkript és funkcionális kiterjesztései. |
|||
*A [[lighttpd]] webszerver Luát használ a hook szkriptekhez a Cache Meta Language modern helyetteseként. |
|||
* A [[Lego Mindstorms NXT]] és az [[Lego Mindstorms NXT 2.0|NXT 2.0]] is bírja a Luát.<ref>[http://www.hempeldesigngroup.com/lego/pbLua/ pbLua]</ref> |
|||
*A [[Logitech]] G15 2.01 verziójának profilkezelője. |
|||
* A [[lighttpd]] webszerver Luát használ a hook szkriptekhez a Cache Meta Language modern helyetteseként. |
|||
*A [[LuaTeX]], a [[pdfTeX]] tervezett utóda ismeri a Luát. |
|||
* A [[Logitech]] G15 2.01 verziójának profilkezelője. |
|||
*A [[MediaWiki]] új sablonnyelve.<ref>https://en.wikipedia.org/wiki/Wikipedia:Wikipedia_Signpost/2012-01-30/Technology_report</ref> |
|||
* A [[LuaTeX]], a [[pdfTeX]] tervezett utóda ismeri a Luát. |
|||
*A [[MikroTik]] [[RouterOS]] bétája a Lua 4.x-et, a végleges kiadás a Lua 5.x-et támogatja.<ref>{{cite web|title=Manual:Lua|url=http://wiki.mikrotik.com/wiki/Lua|work=MikroTik Wiki|accessdate=2010-04-23}}</ref> |
|||
* A [[MediaWiki]] új sablonnyelve.<ref>https://en.wikipedia.org/wiki/Wikipedia:Wikipedia_Signpost/2012-01-30/Technology_report</ref> |
|||
*A [[Multimedia Fusion Developer 2]] Lua kiegészítője lehetővé teszi, hogy a játékok Lua szkripteket futtassanak. |
|||
* A [[MikroTik]] [[RouterOS]] bétája a Lua 4.x-et, a végleges kiadás a Lua 5.x-et támogatja.<ref>{{cite web|title=Manual:Lua|url=http://wiki.mikrotik.com/wiki/Lua|work=MikroTik Wiki|accessdate=2010-04-23}}</ref> |
|||
*A [[MySQL Workbench]] elfogad Lua nyelvű kiterjesztéseket. |
|||
* A [[Multimedia Fusion Developer 2]] Lua kiegészítője lehetővé teszi, hogy a játékok Lua szkripteket futtassanak. |
|||
*Az [[Nginx]] beágyazott Lua modulja API-t nyújt az Nginx eszközeihez, például a socketkezeléshez.<ref>http://wiki.nginx.org/HttpLuaModule</ref> |
|||
* A [[MySQL Workbench]] elfogad Lua nyelvű kiterjesztéseket. |
|||
*Az nmap hálózati biztonsági szkenner szkript nyelve, az nse Luán alapul.<ref>{{cite web|title=Nmap Scripting Engine|url=http://nmap.org/book/nse.html|accessdate=2010-04-10}}</ref> |
|||
* Az [[Nginx]] beágyazott Lua modulja API-t nyújt az Nginx eszközeihez, például a socketkezeléshez.<ref>http://wiki.nginx.org/HttpLuaModule</ref> |
|||
*A [[Wavecom GSM]] [[Open AT OS]] firmware-ja elfogad Lua nyelvű felhasználói alkalmazásokat. |
|||
* Az nmap hálózati biztonsági szkenner szkript nyelve, az nse Luán alapul.<ref>{{cite web|title=Nmap Scripting Engine|url=http://nmap.org/book/nse.html|accessdate=2010-04-10}}</ref> |
|||
*A [[Project Dogwaffle Professional]] Lua nyelvű szűrők létrehozását segíti. Ezt a DogLua szűrő segíti, és a szűrők megoszthatók a Project Dogwaffle, GIMP, Pixarra Twistedbrush és az ArtWeaver között. |
|||
* A [[Wavecom GSM]] [[Open AT OS]] firmware-ja elfogad Lua nyelvű felhasználói alkalmazásokat. |
|||
*A [[Prosody]] egy keresztplatformos Jabber/XMPP szerver Luában íródott. |
|||
* A [[Project Dogwaffle Professional]] Lua nyelvű szűrők létrehozását segíti. Ezt a DogLua szűrő segíti, és a szűrők megoszthatók a Project Dogwaffle, GIMP, Pixarra Twistedbrush és az ArtWeaver között. |
|||
*A [[Reason Digital Audio Workstation]]ben Luával írhatók le a távoli objektumok. |
|||
* A [[Prosody]] egy keresztplatformos Jabber/XMPP szerver Luában íródott. |
|||
*A [[Redis]] nyílt forrású adatbázisban a szerveren Lua szkriptek futtathatók, ezzel bővítve annak funkcionalitását.<ref>{{cite web|title=Redis Lua scripting|url=http://redis.io/commands/eval}}</ref> |
|||
* A [[Reason Digital Audio Workstation]]ben Luával írhatók le a távoli objektumok. |
|||
*A [[Rockbox]] nyílt forrású hanglejátszó támogatja a Lua nyelvű pluginokat. |
|||
* A [[Redis]] nyílt forrású adatbázisban a szerveren Lua szkriptek futtathatók, ezzel bővítve annak funkcionalitását.<ref>{{cite web|title=Redis Lua scripting|url=http://redis.io/commands/eval}}</ref> |
|||
*A [[SciTE]] új verziója bővíthető Lua szkriptekkel. |
|||
* A [[Rockbox]] nyílt forrású hanglejátszó támogatja a Lua nyelvű pluginokat. |
|||
*A Snort a 3.0-tól kezdve tartalmaz Lua értelmezőt.<ref>{{cite web|title=Lua in Snort 3.0|url=http://www.linuxsecurity.com/content/view/128135/171/|accessdate=2010-04-10}}</ref> |
|||
* A [[SciTE]] új verziója bővíthető Lua szkriptekkel. |
|||
*A [[Logitech]] [[Squeezebox]] zenelejátszója támogat Lua nyelvű pluginokat. |
|||
* A Snort a 3.0-tól kezdve tartalmaz Lua értelmezőt.<ref>{{cite web|title=Lua in Snort 3.0|url=http://www.linuxsecurity.com/content/view/128135/171/|accessdate=2010-04-10}}</ref> |
|||
*A [[Tarantool/Box]] [[NoSQL]] tárolt eljárásainak nyelve. |
|||
* A [[Logitech]] [[Squeezebox]] zenelejátszója támogat Lua nyelvű pluginokat. |
|||
*A [[TI-Nspire]] számológépek Lua alkalmazásokat tartalmaz specifikus API-val. |
|||
* A [[Tarantool/Box]] [[NoSQL]] tárolt eljárásainak nyelve. |
|||
*A [[Vim]] a 7.3-as verziójától kezdve támogatja a Lua szkriptelést. |
|||
* A [[TI-Nspire]] számológépek Lua alkalmazásokat tartalmaz specifikus API-val. |
|||
*A [[VLC]] a Luával segíti a szkriptelést. |
|||
* A [[Vim]] a 7.3-as verziójától kezdve támogatja a Lua szkriptelést. |
|||
*A [[WeeChat]] IRC kliens elfogad Lua szkripteket. |
|||
* A [[VLC]] a Luával segíti a szkriptelést. |
|||
*A [[WinGate]] proxyszerver eseménykezelője és házirendje Luával éri el a belső WinGate objektumokat.<ref>{{cite web|title=Vim documentation: if_lua|url=http://vimdoc.sourceforge.net/htmldoc/if_lua.html|accessdate=2011-08-17}}</ref> |
|||
* A [[WeeChat]] IRC kliens elfogad Lua szkripteket. |
|||
*A [[Wireshark]] hálózati csomagelemző protokoll dissectorai és post-dissectorai ismerik a Luát.<ref>{{cite web|title=Lua in Wireshark|url=http://wiki.wireshark.org/Lua|accessdate=2010-04-10}}</ref> |
|||
* A [[WinGate]] proxyszerver eseménykezelője és házirendje Luával éri el a belső WinGate objektumokat.<ref>{{cite web|title=Vim documentation: if_lua|url=http://vimdoc.sourceforge.net/htmldoc/if_lua.html|accessdate=2011-08-17}}</ref> |
|||
* A [[Wireshark]] hálózati csomagelemző protokoll dissectorai és post-dissectorai ismerik a Luát.<ref>{{cite web|title=Lua in Wireshark|url=http://wiki.wireshark.org/Lua|accessdate=2010-04-10}}</ref> |
|||
== Külső hivatkozások == |
== Külső hivatkozások == |
||
* [http://www.lua.org/ Lua.org] |
* [http://www.lua.org/ Lua.org] |
||
==Jegyzetek== |
== Jegyzetek == |
||
{{jegyzetek}} |
{{jegyzetek}} |
||
==Irodalom== |
== Irodalom == |
||
* {{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/}} |
* {{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/}} |
||
* {{Cite book | last1 = Ierusalimschy | first1 = R. | title = Programming in Lua <!-- Blue PiL --> | edition = 2nd | year = 2006 | publisher = Lua.org | isbn = 85-903798-2-5 | url = http://www.inf.puc-rio.br/~roberto/pil2/}} (1st ed. is available [http://www.lua.org/pil/ online]) |
* {{Cite book | last1 = Ierusalimschy | first1 = R. | title = Programming in Lua <!-- Blue PiL --> | edition = 2nd | year = 2006 | publisher = Lua.org | isbn = 85-903798-2-5 | url = http://www.inf.puc-rio.br/~roberto/pil2/}} (1st ed. is available [http://www.lua.org/pil/ online]) |
A lap 2016. november 7., 14:46-kori változata
Lua | |
Paradigma | Imperatív |
Jellemző kiterjesztés |
|
Megjelent | 1993 |
Tervező | Roberto Ierusalimschy Waldemar Celes Luiz Henrique de Figueiredo |
Fejlesztő | Roberto Ierusalimschy |
Utolsó kiadás | 5.4.6 (stabil verzió, 2023. május 14.)[1] |
Dialektusok | Metalua, Idle, GSL Shell |
Megvalósítások | Lua, LuaJIT, LLVM-Lua, Lua Alchemy |
Hatással volt rá | C++, CLU, Modula, Scheme, SNOBOL |
Befolyásolt nyelvek | Io, GameMonkey, Squirrel, Falcon, MiniD |
Operációs rendszer | többplatformos |
Licenc | MIT licenc |
Weboldal |
A Lua (portugálul: hold) programozási nyelv egy nyílt forráskódú beágyazható szkriptnyelv, amelyet 1993-ban fejlesztettek ki a brazíliai Katolikus Teológiai Egyetemen. Készítői fontosnak tartották az együttműködést a C nyelvű programokkal, programkönyvtárakkal. Platformfüggetlen; a programok futás előtt bájtkódra fordulnak. Bár önállóan is használható, de inkább beágyazott nyelvként tartják számon, ahogy a Tcl nyelvet is. Más script nyelvekhez képest nagy sebessége, bővíthetősége és 120 kB-os mérete népszerűvé tette a fejlesztők között.
Az értelmező egy C könyvtárból érhető el, ami API-ként szolgál, ha C programból hívják. Ez lehetővé teszi a két nyelv kevert használatát: a Lua is hívhat C függvényeket, és fordítva, a C is meghívhat Lua függvényeket.
ANSI C-ben készült, és az imperatív és a funkcionális paradigmákat támogatja; az objektumorientáltsághoz nem nyújt nyelvi eszközöket, mégis lehet objektumokat készíteni a tábla adattípus felhasználásával.
Szintaxisa
Nyelvi elemek
Az azonosítók betűkből, számokból, aláhúzásjelekből építkezhetnek, ahol az első jel nem lehet szám. A betűkészlet a helyi beállításoktól függ. Egy jel betű volta ellenőrizhető az isalpha
, szám volta az isalnum
függvénnyel.
A számok tartalmazhatnak törtrészt és decimális exponenst. A tizenhatos számrendszert a 0x
előtag jelzi, ahol az x lehet kis, vagy nagybetűs is.
A Lua forráskódban a kis- és nagybetűk nem minősülnek azonosnak.
Típusok
A Lua beépített típusai:
- nil
- boolean
- number
- string
- table
- function
- userdata
- thread
Egy nil típusú változónak egyetlen lehetséges értéke van, a nil
. Ez a globális változók alapértelmezett értéke; a változók törölhetők is úgy, hogy értéküket nil
-re állítjuk.
Egy logikai változónak két lehetséges értéke van: true
és false
. Fontos hibaforrás, hogy a Rubyhoz hasonlóan csak a nil
és a false
hamis, az üres string vagy a nulla nem. A logikai műveletek: and
, or
, not
.
A számok alapértelmezetten dupla pontosságú lebegőpontos számok. Nincs külön egész típus. A számokon végezhető műveletek operátorai: +
, -
, *
, /
, és a hatványozás jele, a ^
. Az összehasonlításra a ==
, ~=
(nem egyenlő), <
, >
, <=
, >=
operátorok szolgálnak.
A függvények tárolhatók változókban, és átadhatók paraméterként. A C-ben írt programkönyvtárak felhasználásának elősegítésére a C függvények is kezelhetők így. Függvényhíváskor akkor is ki kell tenni a zárójelet, ha nem adunk meg paramétereket. A Javaban megszokott this
itt self
. Metódusok hívásakor az objektumot is fel kellene sorolni a paraméterek között:
objektum.metódus(objektum, paraméterek)
de létezik egy szintaktikus cukorka ennek a lerövidítésére:
objektum:metódus(paraméterek)
A thread a többszálú programozás programszálainak típusa.
A rövid stringek megadhatók egyszeres vagy kétszeres idézőjelek között. Hosszabb stringek megadhatók hosszú szöveg
> formában is. A hosszú stringekben levő utasítások, escape sorozatok nem hajtódnak végre. Minden fajta string tárolhat tetszőleges Unicode karaktereket, amik a C fordító char
típusára képeződnek le. A fájlokat azonban mindig binárisan érdemes kezelni, mivel a nyelv az stdio
C könyvtárat használja, ami azonban nem garantálja a különféle kódolások megfelelő kezelését.
Az escape sorozatok ugyanazok, mint C-ben.
A userdata C-ben megvalósított adattípusokat tárol. Módosítani, rajta műveleteket végrehajtani csak C függvényekkel lehet, a Lua csak értékadást és egyenlőségvizsgálatot biztosít hozzá.
Táblák
A table a Lua egyetlen összetett típusa, asszociatív tömb. A kulcsok lehetnek számok (ajánlottan csak egészek), stringek, másik táblák vagy függvények. A táblák automatikus indexelése a modernebb nyelvekhez hasonlóan 1-től kezdődik, mivel a 0 index hiánya nem igényel kihasználatlan helyfoglalást.
Bejárásuk kétféle módon lehetséges: csak az egész típusú kulcsokat (és a hozzájuk tartozó értékeket) nézzük végig 1-től az első nem létező kulcsig (ipairs
) vagy az összes kulcs-érték párt (pairs
).
Táblák létrehozhatók így:
x = {3.14, "ez egy string"}
Ilyenkor az egyes értékeket sorban az 1, 2, 3, ... kulcsokhoz rendeli.
String kulcsokat így lehet használni:
x =
{
nev = "Kovács János",
kor = 46,
fizetes = {ertek = 10000, penznem = "Ft"}
}
A táblák referencia szerint adódnak át:
a_table = {x = 10} -- Új tábla, egy kulcs-érték pár: "x" kulcs a 10-es számhoz.
print(a_table["x"]) -- A string kulcshoz tartozó érték kiíratása; itt 10.
b_table = a_table
b_table["x"] = 20 -- Az "x"-hez tartozó érték megváltoztatása 20-ra.
print(b_table["x"]) -- Az új érték kiíratása: 20.
print(a_table["x"]) -- ez is 20-at ír, mert az a_table és a b_table ugyanarra a táblára hivatkozik.
Kulcsok, értékek beszúrása, eltávolítása:
myTable = {"a", "b"}
table.insert(myTable, "c")
print(unpack(myTable)) -- eredménye: a b c
table.remove(myTable, 2)
print(unpack(myTable)) -- eredménye: a c
Megjegyzések
Egysoros megjegyzés:
-- Megjegyzés
Több soros megjegyzés:
--[[Ide egy
több soros
megjegyzés
került]]
Változók
A változók nevükkel hivatkozhatók.
A táblában levő értékek hivatkozhatók a tömböknél megszokott módon, pl. a[4]
. Ha a kulcs string, akkor használható az a["nev"]
és a.nev
alak is.
A változók láthatóság szempontjából háromfélék lehetnek: globális, lokális, és táblamezők. A változók deklarációjuktól kezdve egészen a legkisebb befoglaló blokk végéig láthatók. Egy változó lokálissá tehető, ha local
kulcsszóval deklaráljuk. A függvények paraméterei is lokálisnak tekinthetők. Minden más változó globális. A deklarált, de értéket még nem kapott változók értéke nil
. A függvények látják hívási helyük lokális változóit.
Elágazás
A Lua csak a két irányú elágazást ismeri, a több ágú elágazás valójában csak szintaktikus cukorka:
if kifejezes then
blokk
else
blokk
end
if kifejezes then
blokk
elseif
blokk
elseif
blokk
...
else
blokk
end
Ciklusok
Elöltesztelő ciklus:
while (feltétel) do
-- Utasítások
end
Addig hajtja végre a ciklusmagot, amíg a feltétel igaz.
Hátultesztelő ciklus'
repeat
-- Utasítások
until feltétel
A ciklusmagot egyszer mindenképpen végrehajtja, majd utána addig hajtja végre a ciklust, amíg a feltétel hamis (igazzá nem válik). Az until ciklus valójában csak szintaktikus cukorka, nem hoz létre új láthatósági tartományt.
Számlálós ciklus:
for index = start,finish,delta do
-- Utasítások
end
Az index
ciklusváltozót kezdetben start
-ra állítja, majd minden iteráció után delta
lépésközzel megnöveli. Addig fut, amíg a ciklusváltozó kisebb vagy egyenlő, mint a finish
.
delta
= 1 esetén a lépésköz elhagyható:
for index = start,finish do
-- Utasítások
end
Iteráló ciklus:
for elem in lista do
-- Utasítások
end
A lista
összes elemén végigiterál, egészen addig, amíg nil
értéket nem kap.
Függvények
A Luában a függvények átadhatók paraméterként, sőt, visszatérési értékek is lehetnek, ahogy a következő példa mutatja:
do
local oldprint = print -- a jelenlegi print függvény eltárolása oldprint néven
function print(s) -- a print függvény újradefiniálása, itt lehet a szokásos print függvényt használni
if s == "foo" then
oldprint("bar")
else
oldprint(s)
end
end
end
A régi print függvény csak az új print függvényen keresztül érhető el.
A Lua a lezártakat is támogatja:
function addto(x)
-- Return a new function that adds x to the argument
return function(y)
--[[ When we refer to the variable x, which is outside of the current
scope and whose lifetime is longer than that of this anonymous
function, Lua creates a closure.]]
return x + y
end
end
fourplus = addto(4)
print(fourplus(3)) -- Prints 7
Valahányszor meghívódik az addto
, annyiszor új lezárt jön létre az x
változóhoz. Így a névtelen függvény mindig hozzáfér a paraméteréhez. A lezártat, mint minden más objektumot, a szemétszedő gyűjti be.
Metatáblák
A metatáblák új lehetőségeket nyújtanak a táblák felhasználására. A következő példa egy végtelen táblát mutat be. Minden -re fibs[n]
az th-edik Fibonacci-számot adja a dinamikus programozás és a memorizálás segítségével:
fibs = { 1, 1 } -- fibs[1] fibs[2] kezdőértékei.
setmetatable(fibs, {
__index = function(name, n) -- Ezt hívja, ha nincs fibs[n].
name[n] = name[n - 1] + name[n - 2] -- Kiszámolja és megjegyzi fibs[n]-et.
return name[n]
end
})
Egy másik példa: a __call metametódus az objektumorientáltság érzetét adja:
newPerson = {} -- Új tábla 'newPerson' néven.
setmetatable(newPerson, {
__call = function(table,name,age) -- A newPerson táblát functable-lé teszi.
local person = {Name = name, Age = age} -- Lokális változó a később létrehozandó person attributumaival
return person -- A person tábla visszaadása, a person tábla változóinak beállítása .
end
})
Bill = newPerson("Bill Raizer", 21) -- Új person.
print(Bill.Name, Bill.Age) -- A name és az age attributumok kiíratása.
Struktúrák
Bár a Luában nincs adatszerkezet rekordok létrehozására, mint például C-ben a struct
, a táblák erre a célra is használhatók. Ezt a használatot a nyelv szintaktikusan támogatja:
point = { x = 10, y = 20 } -- Új tábla
print(point["x"]) -- Az "x" koordináta kiíratása, itt 10
print(point.x) -- Ugyanaz, mint az előző sorban, csak másként.
Névterek
A táblák összetartozó függvényeket is tárolhatnak, ezzel átvehetik a névterek szerepét:
Point = {}
Point.new = function (x, y)
return {x = x, y = y}
end
Point.set_x = function (point, x)
point.x = x
end
Tömbök
A Lua táblák tömbökként is használhatók:
array = { "a", "b", "c", "d" } -- Az indexek automatikusan számozódnak.
print(array[2]) -- A "b"-t írja ki. A Lua 1-től kezdi a tömbelemek indexelését.
print(#array) -- 4, a tábla hossza. A # operátor adja meg a táblák és a stringek hosszát.
array[0] = "z" -- A 0 index használata.
print(#array) -- A nulladik index nem számítódik bele a hosszba.
Objektumok tömbjeként:
function Point(x, y) -- A "Point" objektum konstruktora
return { x = x, y = y } -- Új objektum létrehozása és visszaadása
end
array = { Point(10, 20), Point(30, 40), Point(50, 60) } -- Pontok tömbje
print(array[2].y) -- 40-et ír ki
A Lua táblák tömbrésszel és assziociatív tömbrésszel vannak implementálva. Korábban az egészet asszociatív tömbbel valósították meg, de ez az ábrázolás gyorsabb.[2]
Felhasználói modulok
A Lua lehetővé teszi új modulok létrehozását. A modulok kezelésére rendelkezésre áll a Luarocks modulkezelő.
Néhány modul a leggyakoribbak közül:
Modul | Leírás |
---|---|
LuaFileSystem | Hozzáférés a könyvtárszerkezethez és a fájlok jogaihoz |
LuaDoc | Dokumentációs eszköz a Lua-kódhoz. |
LuaSocket | Lua interfész a hálózati protokollokhoz: HTTP, FTP, SMTP, MIME, URL és LTN12. |
LuaSQL | Lua interfész a következőkhöz: PostgreSQL, ODBC, MySQL, SQLite, Oracle és az OLE DB. |
stdlib | Gyakori feladatok programkönyvtára a listákhoz, táblákhoz, a funkcionális és az objektumorientált programozáshoz, meg a reguláris kifejezésekhez. |
MD5 | Egyszerű kriptográfia |
Copas | Párhuzamosság támogatása, a korutinok képességeinek bővítése |
LuaZip | A .zip fájlok kezeléséhez. |
LuaInterface | Kapcsolatot teremt a Lua és a Microsoft .NET Common Language Runtime (CLR) között. |
LuaBitOps | C nyelvű kiterjesztés a számokon végzett bitenkénti műveletekhez. |
LuaXML | Az XML és a Lua társítása. |
Lanes | Több Lua környezet párhuzamos futtatása |
Penlight | Táblák, tömbök, stringek, fájlok, könyvtárak, adatok és funkcionális eszközök kezelelésének egyszerűsítése. |
Oil | Egyszerű és hatékony Object Request Broker (CORBA). |
Hello, World!
A klasszikus Hello World! program Lua nyelven:
print("Hello World!")
A program futtatása
A virtuális gép nem közvetlenül a Lua szkriptet hajtja végre, hanem futás közben bájtkódra fordítja, és ez fut. A szkriptek futtatás nélkül is fordíthatók. Maga a fordítás átlátható.
A Lua virtuális gép regiszteres, ezért a legtöbb virtuális gépnél jobban hasonlít a hardver felépítéséhez. Ez csökkenti az értékek átmásolásának és a függvényenkénti utasítások számát. A Lua 5 az egyik legrégibb regiszteres virtuális gép.[3] Az Android Dalvikja és a több nyelvre, köztük Perlre tervezett Parrot is ilyen.
Így fordítja a luac 5.1 virtuális gép a faktoriális függvényt:[4]
function <factorial.lua:1,6> (10 instructions, 40 bytes at 003D5818) 1 param, 3 slots, 0 upvalues, 1 local, 3 constants, 0 functions 1 [2] EQ 0 0 -1 ; - 0 2 [2] JMP 2 ; to 5 3 [3] LOADK 1 -2 ; 1 4 [3] RETURN 1 2 5 [5] GETGLOBAL 1 -3 ; factorial 6 [5] SUB 2 0 -2 ; - 1 7 [5] CALL 1 2 2 8 [5] MUL 1 0 1 9 [5] RETURN 1 2 10 [6] RETURN 0 1
C API
A Luát alkalmazásokba ágyazott nyelvnek fejlesztették, ezért könnyen használható, robusztus C API-val látták el. Az API két részből áll: ezek a Lua core és a Lua auxiliary library.[5] Kiküszöböli a C kézi hivatkozáskezelését. Az API a nyelvhez hasonlóan minimalisztikus; a funkcionalitás bővítéséért az auxiliary library felelős, ami preprocesszor makrókkal egyszerűsíti a táblakezelést.
Verem
A Lua C API verem alapú. A veremműveleteket Lua függvények valósítják meg, továbbá léteznek táblakezelő függvények is, amik a veremből is hívhatók. Ez a verem indexelhető is. A Python tömbökhöz hasonlóan negatív indexek is használhatók; ezek a verem tetejétől (-1 a legfelső elem), a pozitív indexek a verem aljától számítódnak.
A C ésa Lua közötti kommunikációt szintén a verem valósítja meg. A Lua függvénynek átadott argumentumok a verembe kerülnek, és az aktuális függvény lua_call
utasítással hívható. Ha C függvényt hívunk Luából, akkor az a verem tetejéről veszi a paramétereket.
Példa
Lua függvény hívása C-ből:
#include <stdio.h>
#include <stdlib.h>
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
int main()
{
lua_State *L = luaL_newstate();
if (luaL_dostring(L, "function foo (x,y) return x+y end")) exit(1);
lua_getglobal(L, "foo");
lua_pushinteger(L, 5);
lua_pushinteger(L, 3);
lua_call(L, 2, 1);
printf("Result: %d\n", lua_tointeger(L, -1));
return 0;
}
Fordítás és futtatás:
$ gcc -o hello -llua hello.c $ ./hello Result: 8
Speciális táblák
A C API speciális táblákat is elérhetővé tesz, amik pszeudoindexekkel hivatkozhatók a Lua veremből. A LUA_GLOBALSINDEX
tárolja a globális változókat, _G
a fő névtér. A LUA_REGISTRYINDEX
-ben tárolják a C függvények a Lua értékeket későbbi felhasználásra.
Kiterjesztés és kötés
Kiterjesztő modulok is készíthetők a Lua API használatával. Ezek a könyvtárak kiterjesztik az értelmező funkcionalitását. A Lua szempontjából ezek névterek, vagyis táblák a maguk változóival és függvényeivel. Ezek a modulok a require
kulcsszóval tölthetők be.[5]
A LuaRocks csomagkezelő rendszerből egyre több modul érhető el,[6] a CPANhoz, a RubyGemshez és a Python Eggshez hasonlóan. További források a LuaForge és a lua-users.org wiki Lua Addonsa.[7]
Vannak csomagok a grafikus felülethez, a Perl/POSIX szabályos kifejezésekhez, a titkosításhoz, afájltömörítéshez és még sok máshoz. A legtöbb népszerű nyelvhez vannak Lua kötések, például más szkript nyelvekhez.[8] A C++ megközelítés sablon alapú, és automatikus generátorokat használ.
Alkalmazásai
- A videojátékok fejlesztésében a játékfejlesztők elterjesztették a Luát, mivel gyors, könnyen beágyazható és könnyen tanulható.[9] 2012 januárjában a Game Developer Magazine a Luát hirdette győztesnek a Programming Tools kategóriában, és a Front Line Award 2011-et adományozta neki.[10] Egy példa a népszerű Minecraft nevű videojáték; a hozzá készült Computercraft mod számítógépei is Lua nyelvet használnak.
- A 3DMLW plugin Luát használ háromdimenziós megjelenítésre és eseménykezelésre.
- Az Adobe Photoshop Lightroom felhasználói interfésznek.
- Az Apache HTTP Server a 2.3 verziótól kezdve képes Lua használatára bárhol a lekérési folyamatban.
- Az Artweaver képszerkesztőben szkriptelésre.
- Az Awesome ablakkezelő részben Luában íródott. Konfigurációs fájlja is Lua szkript.
- A The Canon Hack Development Kit (CHDK) nyílt forrású Canon kamerakezelőben a Lua a kettő közül az egyik szkript nyelv.
- A Celestia csillagászat témájú tanítóprogram szkript nyelve.
- A Cisco ezen a nyelven implementálja a Dynamic Access Policiest az Adaptive Security Appliance-ban.
- A Creative Technology Zen X-Fi2 hordozható médialejátszó beállításai Luában is szerkeszthetők.
- A Damn Small Linux Luát használ mind az ablakozó rendszer, mind a parancssor kényelmi funkcióihoz.
- A Dolphin Computer Accessben a SuperNova képernyőolvasó is Lua szkript.
- A Fusion szerkesztő Luát használ szkriptelésre és plugin prototípushoz.
- A NES emulator FCE Ultra forkja, a FCEUX lehetővé teszi a játékok szerkesztését Lua szkriptekkel.
- A Flame, egy hírhedt számítógépes kémkedésre használt program.
- A Foldit, egy fehérjehajtogató játék, lehetővé teszi a Luában írt felhasználói szkriptek alkalmazását.[11]
- A FreePOPs levelezőrendszer webes felülete.
- A Brazilian Digital Television System Ginga middlewarja Luát használ deklaratív környezetének szkript nyelveként.
- A GrafX2 pixel-art szerkesztő képes Lua szkripteket futtatni képgeneráláshoz és képfeldolgozáshoz.
- A Garry's Mod nevű videojátékban lehet a Lua segítségével úgynevezett "szkriptelt fegyvereket" készíteni, de objektumok is létrehozhatók.
- Az Ipe képszerkesztő szkript és funkcionális kiterjesztései.
- A Lego Mindstorms NXT és az NXT 2.0 is bírja a Luát.[12]
- A lighttpd webszerver Luát használ a hook szkriptekhez a Cache Meta Language modern helyetteseként.
- A Logitech G15 2.01 verziójának profilkezelője.
- A LuaTeX, a pdfTeX tervezett utóda ismeri a Luát.
- A MediaWiki új sablonnyelve.[13]
- A MikroTik RouterOS bétája a Lua 4.x-et, a végleges kiadás a Lua 5.x-et támogatja.[14]
- A Multimedia Fusion Developer 2 Lua kiegészítője lehetővé teszi, hogy a játékok Lua szkripteket futtassanak.
- A MySQL Workbench elfogad Lua nyelvű kiterjesztéseket.
- Az Nginx beágyazott Lua modulja API-t nyújt az Nginx eszközeihez, például a socketkezeléshez.[15]
- Az nmap hálózati biztonsági szkenner szkript nyelve, az nse Luán alapul.[16]
- A Wavecom GSM Open AT OS firmware-ja elfogad Lua nyelvű felhasználói alkalmazásokat.
- A Project Dogwaffle Professional Lua nyelvű szűrők létrehozását segíti. Ezt a DogLua szűrő segíti, és a szűrők megoszthatók a Project Dogwaffle, GIMP, Pixarra Twistedbrush és az ArtWeaver között.
- A Prosody egy keresztplatformos Jabber/XMPP szerver Luában íródott.
- A Reason Digital Audio Workstationben Luával írhatók le a távoli objektumok.
- A Redis nyílt forrású adatbázisban a szerveren Lua szkriptek futtathatók, ezzel bővítve annak funkcionalitását.[17]
- A Rockbox nyílt forrású hanglejátszó támogatja a Lua nyelvű pluginokat.
- A SciTE új verziója bővíthető Lua szkriptekkel.
- A Snort a 3.0-tól kezdve tartalmaz Lua értelmezőt.[18]
- A Logitech Squeezebox zenelejátszója támogat Lua nyelvű pluginokat.
- A Tarantool/Box NoSQL tárolt eljárásainak nyelve.
- A TI-Nspire számológépek Lua alkalmazásokat tartalmaz specifikus API-val.
- A Vim a 7.3-as verziójától kezdve támogatja a Lua szkriptelést.
- A VLC a Luával segíti a szkriptelést.
- A WeeChat IRC kliens elfogad Lua szkripteket.
- A WinGate proxyszerver eseménykezelője és házirendje Luával éri el a belső WinGate objektumokat.[19]
- A Wireshark hálózati csomagelemző protokoll dissectorai és post-dissectorai ismerik a Luát.[20]
Külső hivatkozások
Jegyzetek
- ↑ Luiz Henrique de Figueiredo: [ANN Lua 5.4.6 now available] (angol nyelven), 2023. május 14. (Hozzáférés: 2023. május 14.)
- ↑ Lua 5.1 Source Code, 2006. (Hozzáférés: 2011. március 24.)
- ↑ (2005) „The implementation of Lua 5.0”. J. Of Universal Comp. Sci. 11 (7), 1159–1176. o.
- ↑ Kein-Hong Man: A No-Frills Introduction to Lua 5.1 VM Instructions, 2006
- ↑ a b Lua 5.1 Reference Manual. Lua.org. (Hozzáférés: 2009. május 24.)
- ↑ LuaRocks. LuaRocks wiki. (Hozzáférés: 2009. május 24.)
- ↑ Lua Addons. Lua-users wiki. (Hozzáférés: 2009. május 24.)
- ↑ Binding Code To Lua. Lua-users wiki. (Hozzáférés: 2009. május 24.)
- ↑ Why is Lua considered a game language?. Stack Overflow. (Hozzáférés: 2010. április 23.)
- ↑ Front Line Award Winners Announced
- ↑ Algorithm discovery by protein folding game players
- ↑ pbLua
- ↑ https://en.wikipedia.org/wiki/Wikipedia:Wikipedia_Signpost/2012-01-30/Technology_report
- ↑ Manual:Lua. MikroTik Wiki. (Hozzáférés: 2010. április 23.)
- ↑ http://wiki.nginx.org/HttpLuaModule
- ↑ Nmap Scripting Engine. (Hozzáférés: 2010. április 10.)
- ↑ Redis Lua scripting
- ↑ Lua in Snort 3.0. (Hozzáférés: 2010. április 10.)
- ↑ Vim documentation: if_lua. (Hozzáférés: 2011. augusztus 17.)
- ↑ Lua in Wireshark. (Hozzáférés: 2010. április 10.)
Irodalom
- Lua 5.1 Reference Manual. Lua.org (2006). ISBN 85-903798-3-3
- Programming in Lua, 2nd, Lua.org (2006). ISBN 85-903798-2-5 (1st ed. is available online)
- Lua Programming Gems. Lua.org (2008). ISBN 978-85-903798-4-3
- Game Programming with Python, Lua, and Ruby. Course Technology PTR (2003). ISBN 1-59200-077-0
- Game Development with Lua. Charles River Media (2005). ISBN 1-58450-404-8
- Beginning Lua Programming. Wrox Press (2007). ISBN 0-470-06917-1
- Quigley, Joseph (2007. június 1.). „A Look at Lua”. Linux Journal.
- Streicher, Martin: Embeddable scripting with Lua. developerWorks. IBM, 2006. április 28.
- Hamilton, Naomi. „The A-Z of Programming Languages: Lua”, Computerworld, IDG, 2008. szeptember 11. – Interview with Roberto Ierusalimschy
- (2011. május 12.) „Passing a Language through the Eye of a Needle”. ACM Queue, Kiadó: ACM. – How the embeddability of Lua impacted its design
- http://nyelvek.inf.elte.hu/leirasok/Lua/
- Roberto Ierusalimschy: Programmieren mit Lua, September 2006, ISBN 3-937514-22-8
- Roberto Ierusalimschy: Lua 5.1 Reference Manual, August 2006, ISBN 85-903798-3-3
- Kurt Jung, Aaron Brown: Beginning Lua Programming, 2007, ISBN 0-470-06917-1
- Paul Schuytema, Mark Manyen: Game Development with Lua, 2005, ISBN 1-58450-404-8