Lua

A Wikipédiából, a szabad enciklopédiából
Lua
Paradigma Imperatív
Megjelent 1993
Tervező Roberto Ierusalimschy
Waldemar Celes
Luiz Henrique de Figueiredo
Utolsó kiadás 5.2.0 (2011. december 16.)
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 License
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 Pontifical Catholic Universityn. 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.

Tartalomjegyzék

Szintaxisa [szerkesztés]

Nyelvi elemek [szerkesztés]

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 nagybetűérzékeny.

Típusok [szerkesztés]

A Lua beépített típusai:

  • nil
  • boolean
  • number
  • string
  • table
  • function
  • userdata
  • thread

A nil típusnak egyetlen eleme van, a nil. A globális változók alapértelmezett értéke; a változók törölhetők is úgy, hogy értéküket nilre állítjuk. 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 ==, ~=, <, >, <=, >= 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, legfeljebb 255 karakteres stringek megadhatók egyszeres vagy kétszeres idézőjelek között. Hosszabb stringek megadhatók különböző szintű határolók között. Az n-edik szintű határolók: egy nyitó zárójel, n egyenlőségjel, egy másik nyitó zárójel, majd a string végén egy hasonló jelsorozat, csak csukó zárójelekkel. A hosszú stringek így egymásba ágyazhatók. A hosszú stringek nem értelmeződnek, a bennük 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 a stdio C könyvtárat használja, ami azonban nem garantálja a különféle kódolások megfelelő kezelését. A számok és a stringek automatikusan konvertálódnak.

Az escape sorozatok ugyanazok, mint a C-ben.

A userdata C típusú adatokat 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 [szerkesztés]

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ömb típusú táblák létrehozhatók így:

x={3.14, [[ez egy string]], {}}

Asszociatív tömb esetén az egyes kulcsokhoz egyenként kell értéket rendelni.

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:

local myTable={"a","b"}
table.insert(myTable,"c") --print(unpack(myTable)) --> a   b   c
table.remove(myTable,2) --print(unpack(myTable)) --> a   c

Megjegyzések [szerkesztés]

Egysoros megjegyzés:

-- Megjegyzés

Többsoros megjegyzés:

--[[Ide egy
többsoros
megjegyzés
került]]

Változók [szerkesztés]

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[i]. Ha a kulcs string, akkor szabad a[i] és a.i alakban is hivatkozni rá; ez azonban különbözik az a[i] értéktől.

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 localnak 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 [szerkeszté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 [szerkesztés]

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 [szerkesztés]

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énymindig hozzáfér a paraméteréhez. A lezártat, mint minden más objektumot, a szemétszedő gyűjti be.

Metatáblák [szerkesztés]

A metatáblák új lehetőségeket nyújtanak a táblák felhasználására. A következő példaegy végtelen táblát mutat be. Minden n-re fibs[n] az nth-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 [szerkesztés]

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 [szerkesztés]

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 [szerkesztés]

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.[1]

Felhasználói modulok [szerkesztés]

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 Microsofts .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! [szerkesztés]

A klasszikus Hello World! program Lua nyelven:

print("Hello World!")

A program futtatása [szerkesztés]

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.[2] 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:[3]

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 [szerkesztés]

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.[4] Kiküszöböli a C kézi hivatkozáskezelését. Az API a nyelvhez hasonó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 [szerkesztés]

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 [szerkesztés]

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 [szerkesztés]

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 [szerkeszté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.[4]

A LuaRocks csomagkezelő rendszerből egyre több modul érhető el,[5] a CPANhoz, a RubyGemshez és a Python Eggshez hasonlóan. További források a LuaForge és a lua-users.org wiki Lua Addonsa.[6]

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.[7] A C++ megközelítés sablon alapú, és automatikus generátorokat használ.

Alkalmazásai [szerkesztés]

  • A videójá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ó.[8] 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.[9] Egy példa a népszerű Minecraft nevű videójá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árom dimenzió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.[10]
  • 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ű videójá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.[11]
  • 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.[12]
  • A MikroTik RouterOS bétája a Lua 4.x-et, a végleges kiadás a Lua 5.x-et támogatja.[13]
  • 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.[14]
  • Az nmap hálózati biztonsági szkenner szkript nyelve, az nse Luán alapul.[15]
  • 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.[16]
  • 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.[17]
  • 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.[18]
  • A Wireshark hálózati csomagelemző protokoll dissectorai és post-dissectorai ismerik a Luát.[19]

Külső hivatkozások [szerkesztés]

Jegyzetek [szerkesztés]

  1. ↑ Lua 5.1 Source Code, 2006. (Hozzáférés: 2011. március 24.)
  2. ↑ (2005.) „The implementation of Lua 5.0”. J. Of Universal Comp. Sci. 11 (7), 1159–1176. o.  
  3. ↑ Kein-Hong Man: A No-Frills Introduction to Lua 5.1 VM Instructions, 2006
  4. ^ a b Lua 5.1 Reference Manual. Lua.org. (Hozzáférés: 2009. május 24.)
  5. ↑ LuaRocks. LuaRocks wiki. (Hozzáférés: 2009. május 24.)
  6. ↑ Lua Addons. Lua-users wiki. (Hozzáférés: 2009. május 24.)
  7. ↑ Binding Code To Lua. Lua-users wiki. (Hozzáférés: 2009. május 24.)
  8. ↑ Why is Lua considered a game language?. Stack Overflow. (Hozzáférés: 2010. április 23.)
  9. ↑ Front Line Award Winners Announced
  10. ↑ Algorithm discovery by protein folding game players
  11. ↑ pbLua
  12. ↑ http://en.wikipedia.org/wiki/Wikipedia:Wikipedia_Signpost/2012-01-30/Technology_report
  13. ↑ Manual:Lua. MikroTik Wiki. (Hozzáférés: 2010. április 23.)
  14. ↑ http://wiki.nginx.org/HttpLuaModule
  15. ↑ Nmap Scripting Engine. (Hozzáférés: 2010. április 10.)
  16. ↑ Redis Lua scripting
  17. ↑ Lua in Snort 3.0. (Hozzáférés: 2010. április 10.)
  18. ↑ Vim documentation: if_lua. (Hozzáférés: 2011. augusztus 17.)
  19. ↑ Lua in Wireshark. (Hozzáférés: 2010. április 10.)

Irodalom [szerkesztés]

P computing.svg Ez az informatikai tárgyú lap egyelőre csonk (erősen hiányos). Segíts te is, hogy igazi szócikk lehessen belőle!
A lap eredeti címe: „http://hu.wikipedia.org/w/index.php?title=Lua&oldid=13335664”