Az alprogramok egyik legfontosabb tulajdonsága, hogy ezek is változók. A nyelv a függvényeket és eljárásokat nem különíti el. Átlapolásra (és így operátor–átlapolásra) nincs lehetőség. Ha függvényen belül a var kulcsszóval deklarálunk egy változót, akkor az a változó csak a függvény lefutásáig él. Abban az esetben ha a var kulcsszót nem használjuk, és úgy hozunk létre új változót, akkor az a változó a függvény lefutása után is megmarad. (var használatával lehetőség van változó eltakarására)
1. Szintaxis
Függvényeket kétféle szintaxissal is megadhatunk, és ezeknek nem csak megjelenése, de jelentése és működése is különböző.
1.1. Állításként (function statement)
Egyik lehetőségünk a függvény állításként való megadása. Ez ismerős lehet a C++ szintaxisából:
function függvénynév(formális paraméterek):visszatérési típus {
utasítások;
}Előnye, hogy:
- tömör, megszokott, átláthatóbb
- konzisztensebb a használata (a pont szintaxis használható minden esetben, ha almetódus)
- elérhető már a konkrét állítás előtt az adott láthatósági szinten
Hátránya, hogy:
- futási időben nem felüldefiniálható
- mindvégig a memóriában marad.
1.2. Kifejezésként (function expression)
Másik lehetőségünk úgy használni a függvényt, mint ami valójában: egy változó. Ilyenkor egy változónak értékül adunk egy kifejezést; egy függvény literált:
var függvénynév:Function = function(formális paraméterek):visszatérési típus {
utasítások;
}Előnye, hogy:
- dinamikusabb (futási időben megváltoztatható egy függvény működése!)
- jobban visszaadja a függvények megvalósításának hátterét
- ha már nincs rá szükség, törölhető.
Hátránya, hogy:
- a pont szintaxissal strict módban csak a dinamikus osztályok metódusai érhetőek el (különben obj["függvény"](); módon kell)
- törölhetjük, pedig még kéne
- csak deklarálás után érhető el.
2. Paraméterátadás
Az egyszerű típusok érték, az összetettek cím szerint adódnak át. Az egyszerű típusok cím szerinti átadását úgy lehet megoldani, hogy Object-ként fogadjuk őket. Érdekesség, hogy lényegében az egyszerűek is cím szerint adódnak át, csak automatikusan készül belőlük egy másolat, de már a függvényen belül.
Mivel a függvények változók, függvénnyel is lehet paraméterezni, ezt felhasználhatjuk például operátorok megvalósítására (mivel operátor override nincs - lásd példa!), vagy gyakorlatban gyakrabban használatos (sőt muszáj így használni) az eseménykezelők megadásánál.
Paraméterezés függvénnyel:
function duplázás(szám:Number):Number {
return szám*2;
}
function pluszegy(szám:Number):Number {
return szám+1;
}
function függvény(fv:Function, szám:Number):Number {
return (fv(szám));
}
trace (függvény(duplázás, 7)); // 14
trace (függvény(pluszegy, 7)); // 8
trace (függvény(Math.sqrt,7)); // 2.64575131106453. ActionScript 3.0
Alapértelmezett paraméter-érték
AS3-ban lehetőségünk nyílik megadni alapértékeket azoknak a függvény-paramétereknek, amiket nem használunk függvényhíváskor. Ez biztosan ismerős azoknak, akik programoztak már pl. php-ban.
function setCords(x:int,y:int,z:int=0):void{
trace(x) //12
trace(y) //12
trace(z) //0
}
setCords(12,12)
A ... (rest) paraméter
Ez egy újfajta paraméter-deklaráció, amit függvényeknél helyezhetünk el a paraméter listában. A ... (rest, többi) paraméter segítségével, szinte végtelen számú opcionális paramétert adhatunk át a függvényünknek. Az opcionálisan átadott paraméterek a ... után megadott nevű változónkban fognak helyet kapni, ami egy tömb, vagyis Array típusú. A különbség e között és a régebbi AS verziókban megtalálható arguments objektum között az, hogy az arguments mindig az összes paramétert tartalmazta, míg a rest pedig csak azokat amiket a paraméter-listában megadott változóinkon felül küldtünk át.
function myFuntion(param1:int, ... args):void{
for(var i:int=0; i<'args.length; i++){
trace(i+". elem:",args[i])
}
}
myFuntion(1,2,3,4,5,6)
Eredmény:
--------------------------
0. elem: 2
1. elem: 3
2. elem: 4
3. elem: 5
4. elem: 6
--------------------------
Amint látjuk majdnem az összes elemünk megvan, kivéve az első, ami az 1 volt, mivel azt megadtuk a paraméter-listában. Ha valaki nagyon szemfüles volt, észrevehetett még valami furcsaságot a kódban: A trace használatánál az args kiírásakor nem "+" jelet, hanem vesszőt használtam. AS3-ban a trace több paramétert is fogad, amit vesszővel lehet elválasztani, mivel ott is a rest-et használják.
4. Beágyazott függvények
Lehetőségünk van beágyazott függvények létrehozására, azaz függvényen belül függvény deklarálására (ez tulajdonképpan azért lehetséges, mert a függvények objektumok, és mivel egy objektumnak lehetnek alobjektumai, nyugodtan lehet az az alobjektum egy függvény is).
A beágyazott függvényeket így természetszerűleg csak az adott függvényen belül érjük el (vagy a függvény objektumra meghívva).
5. Függvények változói
Mivel a függvények objektumok, attribútumaik lehetnek (s mivel a Function osztály dinamikus, futási időben rendelhetünk hozzájuk attribútumokat).
5.1. Az arguments
Az egyik ilyen kiemelt attribútum az arguments. Ez egy Array, amiben eltárolódnak az aktuális paraméterek (a formális paramétereken túliak is!). Ezzel lehetőségünk nyílik akár tetszőleges sorrendben megadott paraméterek kezelésére típusellenőrzéssel, ha eltérő típusú paramétereket várunk.
Az argumentsnek, mint tömbnek van néhány előre definiált alváltozója is, melyek hasznosak lehetnek:
- arguments.length - az aktuális paraméterek száma
- arguments.callee - a függvényt meghívó objektum
Az arguments tömböt nem érjük el, ha a ... (rest) paraméter megadási módot használtuk!
5.2. A length
A length változó tárolja a formális paraméterek számát.
5.3. Egyéni attribútumok
Saját attribútumokat is definiálhatunk, melyek hasonlóképp viselkednek, mint egy osztályváltozó. Például:
someFunction.counter = 0;
function someFunction():void {
someFunction.counter++;
}
someFunction();
someFunction();
trace(someFunction.counter); // 2