. .. : Swf.hu 1.0 archívum : Swf.hu főoldal >>> : .. .




 
 
SEGÉDLETEK

  feltöltve: 1970.01.01 | szerző: ismeretlen | olvasva: alkalommal

 

Változók

Mivel ahogy már felül is említettem hogy szinte egy teljesen új nyelvről van szó ezért, mint minden más nyelvnél itt is az alapoknál kell elkezdenünk, vagyis a változók létrehozásánál. Akinek nem volt gondja ezzel As2-ben annak nagy problémákkal itt sem kell szembenéznie, de azért vannak említésre méltó változások.

Változók deklarálása

Régebbi verziókban megengedett volt a var kulcsszó nélkül változókat deklarálni például:

myVar = "Hello World"

Most már mindenképpen ki kell tennünk a var kulcsszót, ha nem tesszük a fordító hibát fog dobni ezért muszáj ezt minimálisan az alábbi módon megtennünk:

var myVar = "Hello World"

Lehetőség van típust adni a változónknak az As2-ben már megszokott módon a ":" használatával.

var myVar:String = "Hello World"

Ha nagyobb projekteken dolgozunk, fontos lehet mindig típussal ellátni a változóinkat, mivel így csökkenthetjük a memória használatot, valamint gyorsíthatjuk a kódot is. Amíg As2-ben futás időben nem volt semmi haszna a változók típusának itt már optimalizálási szempontokból nem mindegy. A futás idejű típus ellenőrzés miatt pedig értesítést kaphatunk arról ha nem megfelelő típusú változót próbálunk tárolni így könnyedén fellelhetjük az ebből fakadó hibákat.

Másik fontos dolog, hogy míg régebbi AS verziókban megengedett volt egy változót többször deklarálni például így:

if(isTrue){
      var myNum:Number = 0
}else{
      var myNum:Number = 1
}

As3-ban ez már nem megengedett és hibát fogunk kapni ha futtatni próbáljuk. A megoldás kívül elhelyezni a változónkat:

var myNum:Number;

if (isTrue) {
      myNum = 0;
} else {
      myNum = 1;
}

Változók alap értéke

Minden változó alap esetben kap egy értéket, hogyha alap esetben nem tároltunk el benn még semmit ez As2-ben a jól ismert undefined volt. Amikor meg akartunk bizonyosodni arról, hogy valamelyik változónk nem tartalmaz értéket akkor csak meg kellett néznük, hogy undefined-e. Ez As3-ban annyival bonyolódott, hogy minden típusos változó kap egy undefined tól különböző alap értéket. Ez az alap érték változótól függően más és más ezeket az alábbi táblázat foglalja össze.

default_value
 

Ha nem adunk meg típust egy változónak, akkor azt a fordító típustalan-ként fogja értelmezni, ami azt jelenti, hogy alap értéke undefined-lesz és akármilyen értéket rakhatunk bele, ami lehet szám vagy szöveg. Ha jelezni is szeretnénk, hogy egy változót szándékosan típustalannak deklarálunk, akkor ezt megtehetjük a * segítségével, ami így néz ki:

var myVar:*
var myVar2:* = new Object()

Konstansok

Megjelent egy újfata változó deklációjának lehetősége is, mégpedig a konstansoké. A konstansok olyan változók, amiknek csak 1x lehet értéket adni majd nincs lehetőség a megváltoztatásukra. A const kulcsszó változó név elé írásával hozhatunk létre konstansokat:

const CONSTANT:String = "konstans";

//1049: Illegal assignment to a variable specified as constant.
CONSTANT = "új érték"

A konstansokat csupa nagybetűvel szokás írni, hogy könnyen megkülönböztethetőek legyenek a többi változótól. Elég sok olyan új actionscript osztály van As3-ban amik csak statikus konstansokat definiálnak, nem tartalmaznak semmi mást. Evvel a fejlesztők dolgát próbálják megkönnyíteni, mivel egyszerűen kiválasztható egy szerkesztő által felajánlott listából a használni kívánt érték, és elírás esetén azonnal értesítést kapunk a hibánkról.

Típus konverzió

Régebbi AS verziókban is volt típus konverzió ezt itt sincs máként, As3 a primitív típusokat automatikusan konvertálja, ha nincs típusegyezés. Ez azt jelenti, hogyha mi például egy int-et szeretnék elhelyezni egy Boolean típusban, nem kapunk hibát maximum egy figyelmeztetést cs3-ban ami közli velünk, hogy konverzió fog történni hogyha fordításkor már látszik ez a szándékunk. Még a komplexebb objektumok is konvertálhatóak primitív típusokra.

Érdemes lehet megemlíteni néhány típust hogyan viselkedik Boolean-ra konvertálás esetén, mivel feltételek készítésekor ilyen például az if(){} szerkezet elég hasznos lehet meglátásom szerint.

Az üres String false, az amelyikben szerepel valamilyen karakter true Boolean értéket kap:

var myVar:String = ""

if(myVar){
      trace("Nem Üres")
}else{
      trace("Üres")
}

Az eredmény:
--------------------------
"Üres"
--------------------------

Akármelyik szám ha 0 a Boolean értéke false ha bármi más akkor true Ezt jó tudni ha például az indexOf-os kereséseket akarjuk leegyszerűsíteni:

var myString:String = "ez egy minta szöveg"
var keresett:String = "ez"

if(myString.indexOf(keresett)+1){
      trace("Benne van")
}else{
      trace("Nincs benne")
}

Az eredmény:
--------------------------
"Benne van"
--------------------------

A komplex objektumok, ha null értékük van akkor false különben true Bolean értéket kapnak. Ezt hasznos lehet tudni, mivel ha megpróbálunk egy null objektumon valamilyen függvényt meghívni vagy változót elérni hibát kapunk, és ha nem kezeltük le ezt egy ablak fog megjelenni, ami tájékoztat erről. Ezt egyszerűen el lehet kerülni azzal, ha előtte leellenőrizzük hogy null-e az objektumunk:

var myObject:Object

trace(myObject)

if(myObject){
     trace(myObject.toString())
}else{
     trace("null az objektumunk")
}

myObject = new Object()

if(myObject){
     trace(myObject.toString())
}else{
     trace("null az objektumunk")
}

Az eredmény:
--------------------------
null
null az objektumunk
[object Object]
--------------------------

Függvények

Függvényeket az As2-ben megszokott módon deklarálhatunk a function kulcsszó segítségével.

function myFunction(myVar:Object):void{
}

He elég szemfülesek vagyunk, akkor feltűnhet egy apró különbség, mégpedig hogy a void, ami azt jelzi a fordítónak, hogy a függvényünknek nincs visszatérési értéke kis betűvel kezdődik az As2-ben megszokott Void helyett. Erre azért volt szükség, mert az ECMAScript specifikáció szerint a void kulcsszó, és ezért kis betűsnek lett megjelölve. Cs3 nem kényszerít minket rá a használatára, a Flex fordító viszont értesít róla.

Alapértelmezett praraméter érték

As3-ban lehetőségünk nyílt megadni alap értékeket azoknak a függvény paramétereknek, amiket nem használtunk függvényhíváskor. Ez biztosan ismerős lesz azoknak, akik programoztak már php-ban.

function setCords(x:int,y:int,z:int=0):void{
      trace(x) //12
      trace(y) //12
      trace(z) //0
}

setCords(12,12)

Ennek az új módszernek a segítségével lehetőségünk van opcionális paraméterek megadására, amiket nem kötelező átadni a függvényünknek. Fontos még hogy az alap értékkel rendelkező paramétereknek mindig hátrébb kell állniuk, mint azoknak, amiknek nincs ilyen érték megadva.

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, 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ódomban. 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 veszővel lehet elválasztani mivel ott is a rest-et használják.

Függvény mint objektum

AS3-ban mint minden a függvények is objektumok ami azt jelenti hogy másoláskor csak referencia adódik át nem maga a függvény másolata. Ami újdonság lehet, hogy most már egy függvénynek is van length tulajdonsága, ami a benne definiált paraméterek számát adja meg.

function myFuntion(param1:int, param2:int,param3:int ):void{
}

trace(myFuntion.length) //3

Enumeráció

Régebbi AS verziókban könnyedén végigjárhattuk egy objektum elemeit a jól ismert for in segítségével ami az általunk megadott változóba a String kulcsot helyezte el. Lehetőség volt az értékek elrejtésére is az efajta enumeráció elől a már talán kevesebbek által ismert ASSetPropFlags segítségével.
A globális függvények amik a _global-on voltak elhelyezve rejtve voltak a for in elől így azt lefuttatva nem kaptunk semmilyen használható értéket. Próbáljuk ki a következőt egy régebbi AS verzióval:

ASSetPropFlags(_global,null,6,true);

for(i in _global){
      trace(i)
}

Eredmény:
--------------------------
XMLUI
CustomActions
MMSave
Cookie
TextSnapshot
PrintJob
MovieClipLoader
...
--------------------------

Kapunk egy szép kis listát amiben számos általunk gyakran használt függvény vagy osztály is szerepel. Ezek közül, aztán ha kedvünk tartja ki is törülhetünk.

_global.Stage = null

trace(Stage.width) // undefined

Úgy néz ki, hogy mostantól a Stage nem elérhető. Ebből is tisztán látszik, hogy volt mit javítani a nyelven. Adobe szakemberei ezt meg is tették és új szabályokat állítottak fel az enumeráció terén. Eddig amint láthattuk a for in vagy trükkök segítségével betekintést nyerhettünk abba, hogy egy osztály milyen változókat definiál és akár kedvünk szerint át is írhattuk azokat.

AS3 már csak a dinamikusan hozzáadott objektumokat engedi listáztatni. Azonban ezeknél is lehetőség van elrejteni a definícióinkat az Object osztály által definiált
setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void függvény segítségével.

var myObject:Object = new Object()

myObject.x = 1
myObject.y = 2
myObject.z = 3

for(var key:String in myObject){
      trace(key)
}

Eredmény:
--------------------------
x
y
z
-------------------------

Most próbáljuk meg elrejteni mondjuk az x-et.

var myObject:Object = new Object()

myObject.x = 1
myObject.y = 2
myObject.z = 3
myObject.setPropertyIsEnumerable("x",false)

for(var key:String in myObject){
      trace(key)
}

Eredmény:
--------------------------
y
z
--------------------------

Ha azt szeretnék vizsgálni hogy enumerálható-e egy adott változó, akkor használhatjuk a propertyIsEnumerable(name:String):Boolean függvényt amit szintén az Object osztály tartalmaz.

for each in

Most már lehetőségünk nyílik egy újabb módon körbejárni egy objektum elemeit. Az eddig használt for in csak a String kulcsokat adta vissza ha már a kulcshoz tartozó értékre is kíváncsiak voltunk le kellett azt kérni az objektumtól az alábbi módon:

var myObject:Object = new Object()

myObject.x = 1
myObject.y = 2
myObject.z = 3

for(var key:String in myObject){
      var objValue:Object = myObject[key]
      trace(objValue)
}

Ez az új fajta szintaxis megkönnyíti a dolgunkat ha csak az objektum által tárolt értékekre vagyunk kíváncsiak mivel nem a String kulcsot hanem rögtön az objektumban tárolt értékeket adja vissza.

var myObject:Object = new Object()

myObject.x = 1
myObject.y = 2
myObject.z = 3

for each(var val:int in myObject){
trace(val)
}

Eredmény:
--------------------------
1
2
3
--------------------------

A "val" az a változó, amibe majd az értékek belekerülnek, így ha megadjuk a típusát annak egyeznie kell az objektumunkban tárolt adatok típusával. Lehetőség van típustalannak is deklarálni ami így nézne ki:

for each(var val:* in myObject){
      trace(val)
}

 

 
 
 

© Devnet.hu. A segédletek semmilyen formában nem másolhatók, publikálhatók a Devnet.hu és a szerzők közös írásos engedélye nélkül.
 
. .. : Swf.hu 1.0 archívum : Swf.hu főoldal >>> : .. .