Programozás bemutatás

Válassz menüt! mrgreen

Alapfogalmak

LUA

PHP

HTML

Java

Alapfogalmak, amit feltétlenül tudni kell a programozáshoz (Lua-s példákkal)

Lássuk csak, miket is kell tudni a programozáshoz? Mi az a változó, mi az az argumentum, hogyan működik egy program? (A példaprogramokat egy lua motorral futtasd le, és nézd meg mit lesz belőle, majd írkáld át és futtasd le megint, próbáld ki ;] )

Egy program több blokkból és funkcióból áll. Egy blokkon belül több funkció van, ami egy-egy utasítás.
Példának egy utasítás: print ("Hello szia!") Ez nem más, mint egy utasítás, ami kiír nekünk egy szöveget. Amikor egy program fut, az utasítások egymást követve sorban lefutnak.

Mi az a változó?

Talán ez a legfontosabb, és amit a legtöbbször kell használni egy programban. A változó nem más, mint egy objektum, aminek értéket adunk. Na de mire is jó ez? Ez arra jó, hogy dolgokat definiáljunk, vagy értéket adjunk át, esetleg operátorokba vizsgáljuk őket.
Nézzünk egy egyszerű példát:

valtozo = "Szia"
print (valtozo)

Ha a programot végignézzük, láthatjuk, hogy a valtozo-nak a Szia értéket adtuk, majd a print funkcióval kiírtuk a változó értékét. Másképpen, a print megnézte a valtozo értékét, majd kiírta azt.
Nézzünk egy másik példát:

valtozo1 = 2
valtozo2 = 3
osszeg = valtozo1 + valtozo2
print ("Az első szám " .. valtozo1 .. ", a második szám " .. valtozo2 .. " és a számok összege: " .. osszeg)

Na itt már 2 új dolog is feltűnhetett nekünk, mégpedig a .. (két pont) és az hogy a számot nem raktuk ""-ba.
Nézzük is, mi az a két pont. A 2 darab pont (más programnyevlekbe ez eltérő!) nem más mint egy hozzáfűzés. Több változót és értéket "köthetünk" össze, egy értékké. Tehát amikor a print kiírja nekünk a szöveget meg a változókat, nem össze-vissza írja ki, se nem ír hibát, hanem a szövegeket írja ki, úgy ahogy mi azt "összekötöttük".
Nézzük, hogy a szöveget miért tettük ""-ba, a számot pedig miért nem. A változóknak több típusa van, ezek lehetnek a következők:

integer - Az integer egy egész szám lehet csak (pl 5)
string - A string egy karakterlánc, több karaktert tárol (pl "Hello szia"). A stringeket mindig "" közé írjuk.
boolean - A boolean 2 értéket vehet fel, igaz vagy hamis (true, false). Ezeket operátoroknál jó használni, pl megnézzük hogy Józsi vezetékneve Kovács? Ha Kovács, akkor true, ellenkező esetbe false értéket adunk vissza.
float - Lebegőpontos szám, pl 3.14. Ezekkel nemfogunk foglalkozni.
double - Dupla lebegőpontos szám. Ezekkel nemfogunk foglalkozni.

Még egy fontos dolog, a változókat nem tesszük "" közé, mert akkor az már egy string lesz. (PHP-ba van erre egy trükk, arról a PHP programozásba írok). Példának: print "valtozo1" Végeredmény: valtozo1.

Mi az az argumentum?

Az argumentumok nem mások, mint paraméterek, amikkel funkciók tulajdonságát szabályozhatjuk/állíthatjuk, esetleg változóként használhatjuk.
Rögtön nézzünk is erre egy példát: (MTA:SA-s lua script funkció)

outputChatBox("Hello szia!")
outputChatBox("Hello szia!", player, 0, 255, 0, true)
-- ez hasonló a print funkcióhoz

Ugye hogy más a kettő? Pedig a végeredmény majdnem ugyanaz. Lényegében az outputChatBox-nak az argumentumait állítgattuk (ezt mtawiki-n nézd meg melyik argumentum mit csinál), jelen esetbe (szintaxis alapján, arról is szó lesz lejjebb) a 2. kiírásnál beállítottuk, hogy ki lássa (a játékos, vagy mindenki, itt most a játékos), adtunk neki egy színt (RGB szín), és beállítottuk hogy a stringünkbe érvényesek legyenek-e a html színkódok.
Sikeresen beállítottuk egy funkció paramétereit. Most hozzunk létre egy funkciót, majd abból hívjunk meg egy másikat, ami bekéri az argumentumait:

function ezFutLe()
	valtozo = "Hello Józsi"
	eztHivjukMeg(valtozo) -- meghívjuk ezt a funkciósort, és elküldjük argumentumként a valtozo-t
end

function eztHivjukMeg(argumentum)
	outputChatBox(argumentum)
end

A programunkba valahogy/valamivel meghívjuk a ezFutLe() funkciósorunkat, majd abba az utasítások sorba lefutnak. Először egy változó kap értéket, utánna meghív egy másik funkciósort, közbe átviszi a változót argumentumként. Egy funkcióba több argumentum is lehet, vesszővel elválasztva (pl valamiFunkcio(arg1, arg2, arg3)).
Na most a funkciósorokról nem írtam, de ezt gyorsan le is írom. A funkciósorok, nevezzük blokkoknak, általába utasításokat tartalmaznak, amit meglehet hívni valamilyen módon. Meghívás után a benne lévő utasítások lefutnak.
Következő dolog, amit észrevehettünk, az előbbi 2 példában is, a -- jelzés. Nos ez nem más, mint egy megjegyzés, amibe írhatunk jegyzeteket megunknak (hasznos lehet néha), viszont a program futáskor ezeket figyelmen kívül hagyja. A jelölés utáni rész számít megjegyzésnek, és csak arra a sorra érvényes, amibe van.
A megjegyzés lehet egysoros vagy többsoros. Minden programnyelvnek más a megjegzés jelölése, ezeket a programnyelv leáírásokba mutatom be.

Hogyan működnek az operátorok, és mik azok?

Operátorok. Már a neve is elárulja, hogy ezek nem mások, amik feltételeket vizsgálnak, ami szerint lefut a programunk. Lényegében egy ha - akkor az egész, ami egy logikai feltételt vizsgál, például változókat hasonlít össze.
Lássunk erre egy példát:

valtozo1 = 2
valtozo2 = 3

if (valtozo1 < valtozo2) then -- ha (ez és ez megfelel) akkor
	print "A feltétel igaz! 2 kisebb mint 3"
end

Na, tökéletesen működik a programunk, megvizsgálta hogy a 2 kisebb mint a 3. De mivan akkor, ha a feltételünk nem teljesül?
Erre van az else (vagy) operátor, ami akkor lép érvénybe, ha nem teljesült az if else-nk, avagy a programunk fut tovább egészen az operátor végéig (end). Lássunk erre is egy példát (most a változókat kispórolom belőle):

if (2 > 3) then
	print "A feltétel igaz!"
else
	print "A feltétel nemigaz!"
end

Na, eddig szuper az egész. De most megint felmerülhet bennünk a kérdés, mivan ha mi többször akarunk valamit megvizsgálni?
Erre van az elseif (vagyha) operátor, amivel tovább vizsgálhatunk valamit. Röviden: ha (valtozo < 3) akkor ez és ezt csináljuk, vagyha (valtozo < 2) akkor ezt és ezt csináljuk, stb...
Hát, valamennyire érthető, de talán egy példa mégjobb lesz! Lássuk:

valtozo = 5 -- ez most egy kezdőérték, ez most változik valamire.

if (valtozo < 1) then
	print "A változó kisebb mint 1"
elseif (valtozo < 2) then
	print "A változó kisebb mint 2"
elseif (valtozo < 3) then
	print "A változó kisebb mint 3"
....
elsif (valtozo < 10) then
	print "A változó kisebb mint 10"
else
	print "Ez sehogy semmivel se egyenlő"
end

Nézzünk egy olyan példát, amibe egy azonosságot vizsgálunk:

valtozo = 5

if (valtozo == 5) then
	print "A feltétel igaz."
else
	print "A feltétel nemigaz."
end

Itt egy egyenlőséget vizsgáltunk. Na de felmerül bennünk a kérdés, hogy miért van 2 egyenlőségjel? Ha egy egyenlőséget raknánk, akkor egy változót definiálnánk. Ezt így oldották meg.

Szuper, mostmár tudjuk mik azok az operátorok, és hogyan működnek.

Mi az a szintaxis?

Szintaxis. Ha már próbálgattunk programozni, 100% hogy találkoztunk ezzel a szóval. A szintaxis lényegében egy funkciónak a leírása, megmutatja hova milyen argumentumokat írhatunk be, milyen típusút.
Röviden, megmutatja, hogy egy funkcióba mit hova írj. Példának az outputChatBox funkciónk szintaxisát ismertetem most:
bool outputChatBox ( string text [, element visibleTo=getRootElement(), int r=231, int g=217, int b=176, bool colorCoded=false ] )
Elemezzük: Első ránásre a funkció egy boolean, szóval igaz vagy hamis értéket ad vissza. Az első argumentum a text, vagyis amit kiírunk, ami egy string lehet. A következő argumentum beállítja hogy ki láthatja. A következő 3 argumentum (RGB színek) integerek lehetnek, amik egész számok (RGB-be ezek 0-255). Az utolsó argumentum az, hogy a színkódok látszódjanak vagy se, ez egy boolean érték, ami true vagy false lehet.
Mostmár ha valamelyik funkciót nemismerjük eléggé, rákereshetünk a szintaxisára, hogy többet megtudjunk róla.