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




 
 
SEGÉDLETEK

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

 

Egyéb Változások

Strict Mode

AS2-ben jelent meg először a fordításidejű típus ellenőrzés, amiről már az áttekintésben is szó volt. AS3-ban ez kibővül futás idejű típus ellenőrzéssel is és mivel most már sokkal nagyobb hangsúly került a típusok megadására és a velük való munkára előfordulhatnak helyzetek amikor jobbnak látjuk kikapcsolna a fordításidejű ellenőrzést.

 

strictMode

 

Mivel ez a mód alap esetben bekapcsolva van nézzünk pár példát hogy hol okozhat fejfájást a kezdő programozóknak. Helyezzük el az alábbi kódot a root-on.

function sayHello():void{
      trace("Hello")
}

root.sayHello()

Miután ezt a kódot futtatjuk hasonló hibát kell kapnunk:
1061: Call to a possibly undefined method sayHello through a reference with static type flash.display:DisplayObject.

Azért kaptuk ezt a hibát mert a függvényünk nem találta meg a fordító a DisplayObject osztály metódusai között. Ez ezért van mivel a root típusa DisplayObject és ha jól megnézzük az nem egy dinamikus osztály így nem lehet rajta saját függvényeket elhelyezni. Amit a fordító nem tud hogy a mi root-unk MovieClip típusú ami egy dinamikus osztály és alosztálya a DisplayObject-nek de mivel nem egyezik a két típus így hibát kaptunk róla. Felmerülhet a kérdés hogy akkor miért nem MovieClip lett megadva típus ként a root-nak. Mivel nem muszáj annak lennie lehetne akár Sprite is ha nem a CS3-ra bízzuk a root osztály elkészítését hanem mondjuk saját osztályt készítünk erre a célra.

Ilyen esetekben, ha strict módban vagyunk tudatnunk kell a fordítóval, hogy milyen típusú az osztályunk. Ezt 2 módon tehetjük meg. Az első, ha konvertáljuk a típust (casting) az általunk használt típusra. Ezt a típus nevének zárójelek elé rakásával tehetjük meg, a konvertálni kívánt változót pedig a zárójelek közé kell helyeznünk.

var stringNum:String = "2"

trace(stringNum+stringNum) // "22"

var num:int = int(stringNum)

trace(num+num) // 4

Most próbáljuk ki ezt a fenti kódnál.

function sayHello():void{
      trace("Hello")
}

MovieClip(root).sayHello()

Eredmény:
--------------------------
"Hello"
--------------------------

Vigyázni kell azonban mivel ha komplex adattípusokat próbálunk konvertálni és a kiválasztott típusunk nem kompatibilis akkor hibát fogunk kapni. Nézzünk erre egy példát:

var obj:Object = new Object()
var myMovie:MovieClip = MovieClip(obj)

Ebben az esetben ismét hibát kapunk mivel az Object nem alosztálya a MovieClip-nek vagyis ha megnézzük a súgóban az Object Inheritance listáját nem találjuk meg benne a MovieClip-et. Fordítva viszont igaz így nem kapunk hibát:

var myMovie:MovieClip = new MovieClip()
var obj:Object = Object(myMovie)

trace(obj) //[object MovieClip]

as, is

A másik módszer, amivel megmondhatjuk a fordítónak, hogy valójában milyen típusú egy érték egy újonann bevezett kulcsszó mégpedig az "as" kulcsszó. Ez annyiban különbözik a felül említett módszertől hogy nem kompatibilis típusok esetén null-t ad vissza. Amíg a castolással gond nélkül tudtunk primitív típusokra konvertálni itt nem fog működni, mivel ha ezt a kulcsszót használjuk az Inheritance lista alapján történik az ellenőrzés és ha a konvertálandó típus nincs benne null-t fogunk kapni. Lehetőség szerint használjunk castolást ha tudjuk hogy nem fogunk hibát kapni mivel az gyorsabb, ha viszont nem vagyunk biztosak a konverzió sikerében használhatjuk ezt.

var stringNum:String = "2"

trace(stringNum as int) //null

Próbáljuk meghívni a sayHello() függvényünket az új kulcsszó közreműködésével.

function sayHello():void{
      trace("Hello")
}

var rootMc:MovieClip = root as MovieClip
rootMc.sayHello()

Eredmény:
--------------------------
"Hello"
--------------------------

Egy másik új kulcsszó az "as" párja aminek segítségével ellenőrizhetjük hogy egy típus kompatibilis-e egy másik típussal az "is". Ez ha kompatibilisek akkor true ha nem akkor false értéket ad.

trace(root is MovieClip) //true

A "this" értéke

AS2-ben előfordult hogy a this helyenként mást jelentett. Például ha egy onEnterFram-en belül írattuk ki az értéke attól függött, hogy melyik objektumon helyeztük el a függvényünket nem attól hogy hol lett definiálva, ezt az alábbi AS2-es kód is szemlélteti.

var num:Number = 0

var object1:Object = new Object()
object1.num = 1
object1.getNum = getNum

var object2:Object = new Object()
object2.num = 2
object2.getNum = getNum

function getNum():Number{
return this.num
}

trace(object1.getNum()) //1
trace(object2.getNum()) //2

AS3-ban viszont a this mindig oda mutat ahol a függvény deklarálva lett.

var num:Number = 0

var object1:Object = new Object()
object1.num = 1
object1.getNum = getNum

var object2:Object = new Object()
object2.num = 2
object2.getNum = getNum

function getNum():Number{
return this.num
}

trace(object1.getNum()) //0
trace(object2.getNum()) //0

Ezt fontos tudni mivel adatok betöltésénél vagy események bekövetkeztekor nem tudunk a this segítségével az esemény forrására hivatkozni.

Objektumok törlése

Amíg As2-ben szinte mindenhol tudtuk kedvünk szerint használni a delete kulcsszót a referenciák eltávolítására ez mostmár nem fog mindenhol működni. Alap esetben csak a dinamikusan létrehozott objektumokat törölhetjük, azokat amik már szerepelnek egy osztály definícióban nem tudjuk így eltávolítani. Töröljünk ki egy változót egy objektumból:

var myObject:Object = new Object()
myObject.x = 1
myObject.y = 10

delete myObject.x

trace(myObject.x)

Eredmény:
--------------------------
undefined
--------------------------

Most próbáljuk meg kitörölni magát az objektumot:

var myObject:Object = new Object()
myObject.x = 1
myObject.y = 10

delete myObject
1189: Attempt to delete the fixed property myObject. Only dynamically defined properties can be deleted.

A fordító észrevette, hogy nem megengedett műveletet akarunk végrehajtani ezért kiírt egy hibaüzenetet. Próbáljunk meg túljárni a fordító eszén, hogy ne vegye észre mit akarunk csinálni próbálja meg végrehajtani a törlést:

var myObject:Object = new Object()
myObject.x = 1
myObject.y = 10

delete this["myObject"]

trace(myObject)

Eredmény:
--------------------------
[object Object]
--------------------------

Ezúttal nem kapunk hibaüzenetet de sajnos a törlés sem hajtódik végre az objektumunk még mindig létezik. Ahhoz, hogy egy objektum kitörlődjön le kell nulláznuk a rá mutató összes referenciát, ilyenkor a Garbage Collector el fogja távolítani a memóriából.

var myObject:Object = new Object()
myObject.x = 1
myObject.y = 10

myObject = null

Akkor tudhatjuk biztosan, hogy az összes referenciát eltávolítottuk amikor már semmilyen módon nem tudjuk elérni az objektumunkat.

var myObject:Object = new Object()
myObject.x = 1
myObject.y = 10

var myObject2:Object = myObject

myObject = null

trace(myObject2.x) //1

//Referenciák eltávolítva
myObject2 = null

URLRequest

Korábbi AS verziókban amikor külső fájlokat vagy webtartalmat próbáltunk elérni egyszerűen csak átadtuk a kívánt függvénynek a String elérési útvonalat. Mostantól minden olyan osztály ami kívülről tölt be adatot vagy külső fájlokra hivatkozik nem egy String-et vár hanem egy URLRequest objektumot. Ez az osztály hivatott egy ilyen elérési útvonalat tárolni és átadni a kívánt függvényt, sőt adat küldésre is képes. Próbáljuk meg használni a régi getURL() megfelelőjével a navigateToURL()-al.

navigateToURL(new URLRequest("http://www.swf.hu"))

Futtatáskor a böngésző megnyitja a beírt webhelyet, és mint látjuk egy URLRequest-et várt paraméterül. Az régi függvények új megfelelőit megtalálhatjuk az alábbi weblapon:

http://livedocs.adobe.com/flex/2/langref/migration.html

 

 

 
 
 

© 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 >>> : .. .