İfadeler, Anahtar Kelimeler ve Direktifler 

function functionName(parameter0, parameter1, ...rest){ 
	// statement(s) 
} 

Bir işlevin herhangi sayıda virgül sınırlı argümanları kabul edeceğini belirtir. Argümanlar listesi, işlev gövdesi üzerinden kullanılabilir olan bir dizi haline gelir. Dizinin adı, parametre bildirimindeki ... karakterlerinden sonra belirtilir. Parametreler, ayrılmış bir sözcük olmayan herhangi bir ada sahip olabilir.

Diğer parametrelerle kullanılırsa, ... (rest) parametresi bildiriminin belirtilen son parametre olması gerekir. ... (rest) parametresi dizisi, yalnızca işleve iletilen argüman sayısı diğer parametrelerin sayısını aşarsa doldurulur.

Virgül sınırlı argüman listesindeki her bir argüman, dizinin bir öğesine yerleştirilir. Array sınıfının bir örneğini iletirseniz, tüm dizi ... (rest) parametre dizisinin tek bir öğesine yerleştirilir.

Bu parametrenin kullanılması, arguments nesnesini kullanılamaz hale getirir. ... (rest) parametresi, arguments dizisi ve arguments.length özelliğiyle aynı işlevselliği sağlasa da, arguments.callee tarafından sağlanana benzer bir işlevsellik sağlamaz. ... (rest) parametresini kullanmadan önce, arguments.callee öğesini kullanmanız gerekmediğinden emin olun.

package {
	import flash.display.MovieClip;
	
	public class RestParamExample extends MovieClip {
		public function RestParamExample() {
			traceParams(100, 130, "two"); // 100,130,two
			trace(average(4, 7, 13));     // 8
		}
	}
}


function traceParams(... rest) {
 	trace(rest);
 }
 
function average(... args) : Number{
	var sum:Number = 0;
	for (var i:uint = 0; i < args.length; i++) {
		sum += args[i];
	}
	return (sum / args.length);
}

İlgili API Öğeleri

Çekirdek ActionScript sınıflarının, prototip değil sabit olan yöntem ve özelliklerini tanımlar. "-as3" derleyici seçeneğini true (Flex Builder 2'de varsayılan ayar) olarak ayarlarsanız, tüm çekirdek sınıflar için AS3 ad alanı otomatik olarak açılır. Başka bir deyişle, çekirdek sınıf örneği, sınıfın prototip nesnesine eklenen bu aynı özellik ve yöntemlerin sürümleri yerine sabit özellik ve yöntemleri kullanır. Sabit özelliklerin kullanılması genellikle daha iyi performans sağlar ancak ECMAScript sürüm 3 dil belirtimi (ECMA-262) ile geriye dönük uyumluluk yoktur.

İlgili API Öğeleri

Bir döngü içinde (for, for..in, for each..in, do..while veya while veya switch ifadesinde belirli bir durumla ilişkilendirilmiş ifadeler bloğunda görüntülenir. Bir döngüde kullanıldığında, break ifadesi Flash uygulamasına döngü gövdesinin kalanını atlamasını, döngü eylemini durdurmasını ve döngü ifadesini takip eden ifadeyi çalıştırmasını bildirir. Bir switch öğesinde kullanıldığında, break ifadesi Flash uygulamasına o case bloğundaki ifadelerin kalanını atlamasını ve kapsayan switchifadesini takip eden birinci ifadeye atlamasını bildirir.

Yuvalanmış döngülerde, break yalnızca hızlı döngünün kalanını atlar ve yuvalanmış döngü serisinin tamamının dışına çıkmaz. Yuvalanmış döngü serisinin tamamının dışına çıkmak için, label veya try..catch..finally.

break ifadesi, dış etiketli bir ifadeyle eşleşmesi gereken isteğe bağlı bir etiket içerebilir. Dış ifadesinin etiketiyle eşleşmeyen bir etiket kullanılması sözdizimi hatasıdır. Yuvalanmış döngü ifadelerinin, switch ifadelerinin veya block ifadelerinin birden çok düzeyinin dışına çıkmak için, break etiketli ifadeler kullanılabilir. Örneğin, label ifadesinin girişine bakın.

var i:int = 0;
while (true) { 
	trace(i); 
	if (i >= 10) { 
		break; // this will terminate/exit the loop 
	} 
	i++; 
} 
/*
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10*/

İlgili API Öğeleri

case jumpTarget: statements

switch ifadesi için bir atlama hedefi tanımlar. jumpTarget parametresi, sıkı eşitlik (===) kullanan switch ifadesinin expression parametresine eşit olursa, Flash Player bir break ifadesiyle veya switch ifadesinin sonuyla karşılaşıncaya kadar statements parametresindeki ifadeleri çalıştırır.

switch ifadesi dışında case ifadesini kullanırsanız, bu bir hata oluşturur ve komut dosyası derleme yapmaz.

var thisMonth:int = new Date().getMonth(); 
switch (thisMonth) { 
	case 0 : 
		trace("January"); 
		break; 
	case 1 : 
		trace("February"); 
		break; 
	case 5 : 
	case 6 : 
	case 7 : 
		trace("Some summer month"); 
		break; 
	case 8 : 
		trace("September"); 
		break; 
	default : 
		trace("some other month"); 
}

İlgili API Öğeleri

[dynamic] [public | internal] [final] class className [ extends superClass ] [ implements interfaceName[, interfaceName... ] ] { 
	// class definition here
}

Tanımladığınız yöntem ve özellikleri paylaşan nesneler başlatmanızı sağlayan bir sınıf tanımlar. Örneğin, bir fatura izleme sistemi geliştiriyorsanız, her faturanın içermesi gereken yöntem ve özelliklerin tümünü tanımlayan bir Invoice sınıfı oluşturabilirsiniz. Daha sonra Invoice nesneleri oluşturmak için new Invoice() komutunu kullanırsınız.

ActionScript kaynak dosyalarının her biri, diğer kaynak dosyalarına veya komut dosyalarına görünebilen yalnızca bir sınıf içerebilir. Harici olarak görünebilir sınıf genel veya dahili bir sınıf olabilir ve bir paket ifadesi içinde tanımlanmalıdır. Aynı dosyaya başka sınıfları dahil ederseniz, sınıfların paket ifadesi dışına veya dosyanın sonuna yerleştirilmesi gerekir.

Harici olarak görünebilir sınıfın adı, sınıfı içeren ActionScript kaynak dosyasının adıyla eşleşmelidir. Kaynak dosyasının adı, eklenen .as dosya uzantısının yer aldığı sınıfın adı olmalıdır. Örneğin, bir sınıfı Student olarak adlandırırsanız, sınıfı tanımlayan dosyanın Student.as olarak adlandırılması gerekir.

Sınıf tanımlarını yuvalayamazsınız; başka bir deyişle, bir sınıf tanımı içinde ek sınıflar tanımlayamazsınız.

Her yeni bir sınıf örneği oluşturulduğunda çalıştırılan bir yöntem niteliğindeki yapıcı yöntemini tanımlayabilirsiniz. Yapıcı yönteminin adının, sınıfın adıyla eşleşmesi gerekir. Bir yapıcı yöntemi tanımlamazsanız, sizin için varsayılan bir yapıcı oluşturulur.

Nesnelerin çalışma zamanında dinamik özellikler ekleyebildiğini ve bu özelliklere erişebildiğini belirtmek için, sınıf ifadesinin önüne dynamic anahtar sözcüğünü ekleyin. Bir sınıfın bir arabirim uyguladığını bildirmek için, implements anahtar sözcüğünü kullanın. Bir sınıfın alt sınıflarını oluşturmak için, extends anahtar sözcüğünü kullanın. (Bir sınıf yalnızca bir sınıfı genişletebilir ancak birçok arabirimi uygulayabilir.) Tek bir ifadede implements ve extends öğelerini kullanabilirsiniz. Şu örnek, implements ve extends anahtar sözcüklerinin tipik kullanımlarını göstermektedir:

class C implements Interface_i, Interface_j // OK 
class C extends Class_d implements Interface_i, Interface_j // OK 
class C extends Class_d, Class_e // not OK 

// Filename Plant.as 
package {
  public class Plant { 
	// Define property names and types 
	private var _leafType:String; 
	private var _bloomSeason:String; 
	// Following line is constructor 
	// because it has the same name as the class 
	public function Plant(param_leafType:String, param_bloomSeason:String) { 
		// Assign passed values to properties when new Plant object is created 
		_leafType = param_leafType; 
		_bloomSeason = param_bloomSeason; 
	} 
	// Create methods to return property values, because best practice 
	// recommends against directly referencing a property of a class 
	public function get leafType():String { 
		return _leafType; 
	} 
	public function get bloomSeason():String { 
		return _bloomSeason; 
	} 
  }
}

var pineTree:Plant = new Plant("Evergreen", "N/A"); 
// Confirm parameters were passed correctly 
trace(pineTree.leafType); 
trace(pineTree.bloomSeason); 

İlgili API Öğeleri

const identifier = value 

Yalnızca bir kez değer atanabilen bir değişken olan sabiti belirtir.

Bir sabitin sonuna, ardından veri türü gelen iki nokta (:) karakterini ekleyerek, o sabiti katı şekilde türleyebilirsiniz.

const MIN_AGE:int = 21;
MIN_AGE = 18; // error

const product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); // array operations are allowed
product_array = ["Other"];  // assignment is an error
trace(product_array); 

İlgili API Öğeleri

continue [label]

En içteki döngüdeki geri kalan tüm ifadeleri atlayarak geçer ve sanki denetim normal şekilde döngünün sonuna geçmiş gibi döngünün sonraki yinelemesini başlatır. continue ifadesinin döngü dışında bir etkisi yoktur. Yuvalanmış döngülerde, en içteki döngülerden daha fazlasını atlamak için isteğe bağlı label parametresini kullanın.

continue ifadesi, dış etiketli bir ifadeyle eşleşmesi gereken isteğe bağlı bir etiket içerebilir. Dış ifadesinin etiketiyle eşleşmeyen bir etiket kullanılması sözdizimi hatasıdır. continue etiketli ifadeler, yuvalanmış döngü ifadelerinin birden çok düzeyini atlamak için kullanılabilir.

var i:int = 0; 
while (i < 10) { 
	if (i % 3 == 0) { 
		i++; 
		continue; 
	} 
	trace(i); 
	i++; 
}

 
for (var i:int = 0; i < 10; i++) { 
	if (i % 3 == 0) { 
		continue; 
	} 
	trace(i); 
}

İlgili API Öğeleri

default: statements 

switch ifadesi için varsayılan durumu tanımlar. switch ifadesinin expression parametresi, belirli bir switch ifadesi için case anahtar sözcüklerini izleyen herhangi bir expression parametresine eşit olmazsa (sıkı eşitlik [===] işlemini kullanarak), ifadeler çalıştırılır.

switch ifadesi, bir default durum ifadesi gerektirmez. default durum ifadesinin listede en sonuncu olması gerekmez. switch ifadesi dışında default ifadesini kullanırsanız, bu bir hata oluşturur ve komut dosyası derleme yapmaz.

var dayOfWeek:int = new Date().getDay(); 
switch (dayOfWeek) { 
	case 1 : 
		trace("Monday"); 
		break; 
	case 2 : 
		trace("Tuesday"); 
		break; 
	case 3 : 
		trace("Wednesday"); 
		break; 
	case 4 : 
		trace("Thursday"); 
		break; 
	case 5 : 
		trace("Friday"); 
		break; 
	default : 
		trace("Weekend"); 
}

İlgili API Öğeleri

default xml namespace direktifi, XML nesneleri için kullanılacak varsayılan ad alanını ayarlar.

default xml namespace öğesini ayarlamazsanız, varsayılan ad alanı adlandırılmamış ad alanı olur (URI boş bir dizeye ayarlanmış). default xml namespace bildiriminin kapsamı, değişken kapsamı gibi bir işlev bloğu içindedir.

var nsDefault1:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault1;
	    
var x1:XML = ;
trace("x1 ns: " + x1.namespace());
			
scopeCheck();	

var x2:XML = ;
trace("x2 ns: " + x2.namespace());
		
function scopeCheck(): void {
	
	var x3:XML = ;
	trace("x3 ns: " + x3.namespace());
				
	var nsDefault2:Namespace = new Namespace("http://schemas.xmlsoap.org/soap/envelope/");
	default xml namespace = nsDefault2;
		    
	var x4:XML = ;
	trace("x4 ns: " + x4.namespace());

}

var nsDefault:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault;
            
var x1:XML = ;

trace(x1.namespace());
	// http://www.example.com/namespaces/

var x2:XML = ;
trace(x2.namespace());
	// http://www.w3.org/1999/XSL/Transform/

var x3:XML = ;
trace(x3.namespace());
	// http://www.example.com/namespaces/

İlgili API Öğeleri

do { statement(s) } while (condition)

while döngüsüne benzer, farklı olduğu tek nokta, koşulun ilk değerlendirilmesinden önce ifadelerin bir kez çalıştırılmasıdır. Ardından, yalnızca koşullar true olarak değerlendirilirse ifadeler çalıştırılır.

do....while döngüsü, döngü içindeki kodun en az bir defa çalıştırılmasını sağlar. Ayrıca while döngüsü başlamadan önce çalıştırılacak ifadelerin bir kopyasını yerleştirerek bir while döngüsüyle de bunu yapabilirsiniz, çoğu programcı while döngülerinin daha kolay okunduğuna inanır.

Eğer koşul değerlendirmesi her zaman true değeri ile sonuçlanıyorsa, do....while döngüsü sonsuzdur. Sonsuz bir döngü girerseniz, Flash Player ile ilgili sorunlarla karşılaşırsınız ve sonunda bir uyarı mesajı alır veya oynatıcıyı bozarsınız. Mümkün olduğunca, döngü oluşturmak istediğiniz sayıyı biliyorsanız for döngüsünü kullanın. for döngüleri daha kolay okunup hata ayıklaması yapılsa da her koşuldado..while döngülerinin yerini alamazlar.

var myVar:Number = 0; 
do { 
	trace(myVar); 
	myVar++; 
} 
while (myVar < 5); 
/*
0 
1 
2 
3 
4
*/

İlgili API Öğeleri

dynamic class className { // class definition here }

Bir sınıfın örneklerinin çalışma süresinde eklenen dinamik özelliklere sahip olabileceğini belirtir. Bir sınıfta dynamic niteliğini kullanırsanız, çalışma zamanında o sınıfın örneklerine özellikler ekleyebilirsiniz. dynamic olarak işaretli olmayan sınıflar sealed olarak değerlendirilir, bu da o sınıfın örneklerine özellikler eklenemeyeceği anlamına gelir.

Bir sınıf mühürlü ise (dinamik değilse), sınıf örnekleri üzerinde özellikleri alma veya ayarlama girişimleri bir hataya yol açar. Derleyiciniz katı moduna ayarlıysa ve örnekler oluşturduğunuzda veri türünü belirtirseniz, mühürlü nesnelere özellik ekleme girişimleri bir derleyici hatası oluşturur; aksi takdirde bir çalışma zamanı hatası gerçekleşir.

dynamic niteliği alt sınıflar tarafından miras alınmaz. Bir dinamik sınıfı genişletirseniz, yalnızca dynamic niteliğiyle alt sınıfı bildirdiğinizde alt sınıf dinamik olur.

package {

	dynamic class Expando  {
	}
	
	class Sealed {
	}
}

var myExpando:Expando = new Expando();
myExpando.prop1 = "new";
trace(myExpando.prop1); // new

var mySealed:Sealed = new Sealed();
mySealed.prop1 = "newer"; // error

İlgili API Öğeleri

if (condition) { 
	// statement(s)
} 
else {
	// statement(s)
}

if ifadesindeki koşul false döndürürse çalıştırılacak ifadeleri belirtir. Yalnızca bir ifade çalıştırılacaksa, else ifadesi tarafından çalıştırılacak ifadeleri kapsayan küme parantezleri ({}) gerekmez.

if (age_txt.text>=18) { 
	trace("welcome, user"); 
} 
else { 
	trace("sorry, junior"); 
	userObject.minor = true; 
	userObject.accessAllowed = false;
}

if (age_txt.text>18) { 
	trace("welcome, user");
} 
else trace("sorry, junior");

if (score_txt.text>90) { 
	trace("A"); 
} 
else if (score_txt.text>75) { 
	trace("B"); 
} 
else if (score_txt.text>60) { 
	trace("C"); 
} 
else { 
	trace("F"); 
}

İlgili API Öğeleri

class className extends otherClassName {}
interface interfaceName extends otherInterfaceName {} 

Başka bir sınıfın alt sınıfı olan bir sınıf tanımlar. Alt sınıf, üst sınıfta tanımlanan tüm yöntemleri, özellikleri, işlevleri, vb. miras alır. final olarak işaretli sınıflar genişletilemez.

Bir arabirimi genişletmek için extends anahtar sözcüğünü de kullanabilirsiniz. Başka bir arabirimi genişleten bir arabirim, orijinal arabirimin tüm yöntem bildirimlerini içerir.

package {
	class Vehicle { 
	    var numDoors:Number; 
	    var color:String; 
	    public function Vehicle(param_numDoors:Number = 2, param_color:String = null) { 
	        numDoors = param_numDoors; 
	        color = param_color; 
	    } 
	    public function start():void { 
	        trace("[Vehicle] start"); 
	    } 
	    public function stop():void { 
	        trace("[Vehicle] stop"); 
	    } 
	    public function reverse():void { 
	        trace("[Vehicle] reverse"); 
	    } 
	}	
}

package {

	public class Car extends Vehicle { 
	    var fullSizeSpare:Boolean; 
	    public function Car(param_numDoors:Number, param_color:String, param_fullSizeSpare:Boolean) { 
	        numDoors = param_numDoors; 
	        color = param_color; 
	        fullSizeSpare = param_fullSizeSpare; 
	    } 
	    public function activateCarAlarm():void { 
	        trace("[Car] activateCarAlarm"); 
	    } 
	    public override function stop():void { 
	        trace("[Car] stop with antilock brakes"); 
	    } 
	}
}

var myNewCar:Car = new Car(2, "Red", true); 
myNewCar.start(); // [Vehicle] start 
myNewCar.stop(); // [Car] stop with anti-lock brakes 
myNewCar.activateCarAlarm(); // [Car] activateCarAlarm

package {
	class Truck extends Vehicle {
		var numWheels:Number;
		public function Truck(param_numDoors:Number, param_color:String, param_numWheels:Number) { 
			super(param_numDoors, param_color); 
			numWheels = param_numWheels; 
		} 
		public override function reverse():void { 
			beep();
			super.reverse();
		} 
		public function beep():void { 
			trace("[Truck] make beeping sound"); 
		} 
	}
}

var myTruck:Truck = new Truck(2, "White", 18); 
myTruck.reverse(); // [Truck] make beeping sound [Vehicle] reverse 
myTruck.stop(); // [Vehicle] stop

İlgili API Öğeleri

false

Yanlışı temsil eden Boolean değeri. Boolean değeri true veya false olur; false değerinin tersi, true olur.

Otomatik veri türleme, false öğesini bir sayıya dönüştürdüğünde 0 olur; false öğesini bir dizeye dönüştürdüğünde "false" olur.

Not: "false" dizesi, true Boolean değerine dönüştürülür.

var bool1:Boolean = Boolean(false);

// converts it to the number 0
trace(1 + bool1); // outputs 1

// converts it to a string
trace("String: " + bool1); // outputs String: false

trace(Boolean("false")); // true

if ("false") {
	trace("condition expression evaluated to true");
}
else {
	trace("condition expression evaluated to false");
}
// condition expression evaluated to true

İlgili API Öğeleri

final function methodName() { 
	// your statements here 
}
final class className {}

Bir yöntemin geçersiz kılınamayacağını veya bir sınıfın genişletilemeyeceğini belirtir. final ile işaretli olarak bir yöntemi geçersiz kılma veya bir sınıfı genişletme girişimi bir hataya yol açar.

İlgili API Öğeleri

Proxy sınıfının yöntemlerini tanımlar. Proxy alt sınıfınızın herhangi bir Proxy sınıfı yöntemi adlarıyla eşleşen örnek yöntem adlarını içermesi durumlarında ad çakışmalarını önlemek için, Proxy sınıfı yöntemleri kendi ad alanlarında bulunur.

İlgili API Öğeleri

for ([init]; [condition]; [next]) { 
	// statement(s)
}

init (başlat) ifadesini bir kez değerlendirir ve sonra bir döngü sırası başlatır. Döngü sırası, condition ifadesi değerlendirilerek başlatılır. condition ifadesi true olarak değerlendirilirse, statement çalıştırılır ve next değerlendirilir. Daha sonra condition ifadesinin değerlendirilmesiyle tekrar döngü sırası başlatılır.

Yalnızca bir ifade çalıştırılacaksa, for ifadesi tarafından çalıştırılacak ifadeler bloğunu kapsayan küme parantezleri ({}) gerekli değildir.

var my_array:Array = new Array(); 
for (var i:Number = 0; i < 10; i++) { 
	my_array[i] = (i + 5) * 10;  
} 
trace(my_array); // 50,60,70,80,90,100,110,120,130,140 

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) { 
	sum += i; 
} 
trace(sum); // 5050

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) 
	sum += i; 
trace(sum); // 5050

İlgili API Öğeleri

for (variableIterant:String in object){ 
	// statement(s)
} 

Bir nesnenin dinamik özelliklerini veya bir dizideki öğeleri yineler ve her özellik ya da öğe için statement öğesini çalıştırır. Nesne özellikleri belirli bir sırada tutulmaz, bu nedenle özellikler rastgele sırada görüntülenebilir. Bir sınıfta tanımlı sabit özellikler (örn. değişkenler ve yöntemler), for..in ifadesi tarafından numaralandırılmaz.. Sabit özelliklerin bir listesini almak için, flash.utils paketindeki describeType() işlevini kullanın.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var prop in myObject) { 
	trace("myObject."+prop+" = "+myObject[prop]); 
} 
/*
myObject.firstName = Tara 
myObject.age = 27 
myObject.city = San Francisco
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var name in myObject) { 
	if (typeof (myObject[name]) == "string") { 
		trace("I have a string property named "+name); 
	} 
}
/*
I have a string property named city
I have a string property named firstName
*/

İlgili API Öğeleri

for each (variableIterant in object){ 
	// statement(s)
} 

Bir koleksiyonun öğelerini yineler ve her bir öğe için statement öğesini çalıştırır. E4X dil uzantılarının bir bölümü olarak tanıtılır, for each..in ifadesi yalnızca XML nesneleri için değil, nesneler ve diziler için de kullanılabilir. for each..in ifadesi, sabit özellikler üzerinden değil, yalnızca bir nesnenin dinamik özellikleri üzerinden yinelenir. Sabit özellik, sınıf tanımının parçası olarak tanımlanan bir özelliktir. Kullanıcı tanımlı bir sınıf örneğiyle for each..in ifadesini kullanmak için, dynamic niteliğiyle sınıfı bildirmeniz gerekir.

for..in ifadesinden farklı olarak, for each..in ifadesi, özellik adları yerine, nesne özelliklerinin değerlerini yineler.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
	trace(item); 
} 
/*
Tara
27
San Francisco
*/

var myArray:Array = new Array("one", "two", "three"); 
for each(var item in myArray) 
	trace(item); 
/*
one
two
three
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
	if (item is String) {  
		trace("I have a string property with value " + item); 
	} 
}

/*
I have a string property with value Tara
I have a string property with value San Francisco
*/

var doc:XML = 
		
			
Hello
			
Hola
			

			
Bonjour
		;
for each (var item in doc.p) {
	trace(item);
}

/*
Hello
Hola
Bonjour
*/

function functionName([parameter0, parameter1,...parameterN]) : returnType{ 
	// statement(s) 
} 
var functionName:Function = function ([parameter0, parameter1,...parameterN]) : returnType{ 
	// statement(s) 
} 

Belirli bir görevi gerçekleştirmek için tanımladığınız bir ifadeler kümesini kapsar. Tek bir konumda bir işlevi tanımlayabilir ve SWF dosyasındaki farklı komut dosyalarından çağırabilirsiniz. Bir işlevi tanımladığınızda, o işlevin parametrelerini de belirtebilirsiniz. Parametreler, üzerinde işlevin çalıştığı değerlerin yer tutucularıdır. Bir işlevi her çağırdığınızda o işleve farklı parametreler iletebilirsiniz, böylece işlevi farklı durumlarda yeniden kullanabilirsiniz.

Bir işlevin bir değer oluşturmasını veya döndürmesini sağlamak için işlevin statement(s) bloğunda return ifadesini kullanın.

Kullanım 1: Belirtilen işlev adı, parametreler ve ifadelerle bir işlevi tanımlamak için function anahtar sözcüğünü kullanabilirsiniz. Komut dosyası bir işlev çağırdığında, işlevin tanımındaki ifadeler çalıştırılır. İleri başvuruya izin verilir; aynı komut dosyası içinde bir işlev çağrıldıktan sonra bildirilebilir. Bir işlev tanımı, aynı işlevin önceki tanımlarının yerini alır. Bir ifadeye izin verilen her yerde bu sözdizimini kullanabilirsiniz.

Kullanım 2: Adsız bir işlev oluşturmak ve bu işleve bir başvuru döndürmek için function öğesini de kullanabilirsiniz. Bu sözdizimi ifadelerde kullanılır ve özellikle nesnelere yöntem yüklenmesinde kullanışlıdır.

Ek işlevsellik için, işlev tanımınızda arguments nesnesini kullanabilirsiniz. Parametrelerin değişken sayısını kabul eden bir işlev oluşturmak ve yinelenen adsız bir işlev oluşturmak için yaygın olarak arguments nesnesi kullanılır.

function sqr(xNum:Number) { 
	return Math.pow(xNum, 2); 
} 
var yNum:Number = sqr(3); 
trace(yNum); // 9

var yNum:Number = sqr(3); 
trace(yNum); // 9 
function sqr(xNum:Number) { 
	return Math.pow(xNum, 2); 
}

İlgili API Öğeleri

function get property() : returnType{ 
	// your statements here 
}

Özellik gibi okunabilen bir yöntem niteliğindeki alıcıyı tanımlar. Alıcı, var veya const anahtar sözcüğüyle bildirilen bir özellik değerini döndüren özel bir işlevdir. Diğer yöntemlerden farklı olarak alıcı, parantezler (()) olmadan çağrılır ve bu da alıcının bir değişken olarak görüntülenmesini sağlar.

Alıcılar, özel bir özellik için genel bir arabirim oluşturmanıza olanak sağlayarak bilgi gizleme ilkesini uygulamanızı sağlar. Bilgi gizlemenin avantajı, özel özelliğin alttaki uygulaması değişse de, genel arabirimin aynı şekilde kalmasıdır.

Alıcıların başka bir avantajı da, var veya const ile bildirilen özellikler alt sınıflarda geçersiz kılınamazken, alıcıların alt sınıflarda geçersiz kılınabilmesidir.

Okuma-yazma özelliği oluşturmak için bir alıcı bir ayarlayıcıyla birleştirilebilir. Salt okunur bir özellik oluşturmak için, karşılık gelen ayarlayıcı olmadan bir alıcı oluşturun. Salt yazılır bir özellik oluşturmak için, karşılık gelen alıcı olmadan bir ayarlayıcı oluşturun.

package {
	public class Team { 
		var teamName:String; 
		var teamCode:String; 
		var teamPlayers:Array = new Array(); 
		public function Team(param_name:String, param_code:String) { 
			teamName = param_name; 
			teamCode = param_code; 
		} 
		public function get name():String { 
			return teamName; 
		} 
		public function set name(param_name:String):void { 
			teamName = param_name; 
		}
	} 
}

var giants:Team = new Team("San Fran", "SFO"); 
trace(giants.name); 
giants.name = "San Francisco"; 
trace(giants.name); 
/*
San Fran San Francisco */

if (condition) {
	// statement(s)
}

Çalıştırılacak sonraki ifadeyi belirlemek için bir koşulu değerlendirir. Koşul true olursa, Flash Player, küme parantezi ({}) içinde koşulu takip eden ifadeleri çalıştırır. Koşul false olursa, Flash Player, küme parantezi içindeki ifadeleri atlar ve küme parantezlerini takip eden ifadeleri çalıştırır. Komut dosyalarınızda dallandırma mantığı oluşturmak için if ifadesini else ifadesiyle birlikte kullanın.

Yalnızca bir ifade çalıştırılacaksa, if ifadesi tarafından çalıştırılacak ifadeleri kapsayan küme parantezleri ({}) gerekli değildir.

İlgili API Öğeleri

myClass implements interface01 [, interface02 , ...] 

Bir sınıfın bir veya daha fazla arabirim uyguladığını belirtir. Sınıf bir arabirim uyguladığında, sınıfın o arabirimde bildirilen tüm yöntemleri tanımlaması gerekir. Bir arabirim uygulayan herhangi bir sınıf örneği, arabirim tarafından tanımlanan veri türünün bir üyesi olarak değerlendirilir. Sonuç olarak, sınıf örneği birinci işlenen ve arabirim ikinci işlenen olduğunda, is operatörü true öğesini döndürür; ayrıca arabirim çalışması tarafından tanımlanan veri türüne ve bu veri türünden tür zorlanır.

İlgili API Öğeleri

import packageName.className 
import packageName.*

Harici olarak tanımlı sınıfları ve paketleri kodunuzun kullanabilmesini sağlar. Örneğin, flash.display.Sprite sınıfını bir komut dosyasında kullanmak isterseniz, bu sınıfı içe aktarmanız gerekir. Bu gereksinim, import direktifinin isteğe bağlı olduğu önceki ActionScript sürümlerinden farklıdır.

import direktifini kullandıktan sonra paket adını içeran sınıf adının tamamını veya yalnızca sınıf adını kullanabilirsiniz.

 
import flash.display.Sprite; 

// name of class only
var mySprite:Sprite = new Sprite();

// full class name
var mySprite:flash.display.Sprite = new flash.display.Sprite();

Pakette erişmek istediğiniz birçok sınıf varsa, şu örnekte gösterildiği gibi, bunların tümünü tek bir ifadede içe aktarabilirsiniz:

import flash.display.*;

import direktifi, yalnızca içe aktarılan paketin üst düzeyinde bulunan sınıfları, işlevleri ve değişkenleri içe aktarır. Yuvalanmış paketlerin açıkça içe aktarılması gerekir.

Bir sınıfı içe aktarırsanız ancak komut dosyanızda kullanmazsanız, sınıf SWF dosyasının parçası olarak dışa aktarılmaz. Başka bir deyişle, SWF dosyasının boyutunu sorun etmeden büyük paketleri içe aktarabilirsiniz; bir sınıfla ilişkilendirilmiş bayt kodu yalnızca o sınıf gerçekten kullanılırsa SWF dosyasına dahil edilir. Sınıfları içe aktarmanın gerek duymadığınız tek dezavantajı, ad çakışmalarının benzerliğini artırmanızdır.

// On Frame 1 of a FLA: 
import adobe.example.*; 
var myFoo:foo = new foo();

include "[path]filename.as"

Belirtilen dosyanın içeriğini; dosyadaki komutlar, çağıran komut dosyasının parçasıymış gibi dahil eder. Derleme zamanında include direktifi çağrılır. Bu nedenle, dahil edilen bir dosyada herhangi bir değişiklik yaparsanız, dosyayı kaydetmeniz ve bu dosyayı kullanan SWF dosyalarını yeniden derlemeniz gerekir.

 interface InterfaceName [extends InterfaceName ] {}

Bir arabirimi tanımlar. Arabirimler, bir yöntemler kümesini tanımlayan veri türleridir; yöntemlerin arabirimi uygulayan herhangi bir sınıf tarafından tanımlanması gerekir.

Arabirim, şu önemli farklılıklarla bir sınıfa benzer:

• Arabirimler, yöntemlerin uygulamasını değil, yalnızca bildirimlerini içerir. Başka bir deyişle, bir arabirim uygulayan her sınıfın, arabirimde bildirilen her yöntem için bir uygulama sağlaması gerekir.
• Arabirim yöntemi tanımları, public veya private gibi nitelik içeremez, ancak uygulanan yöntemlerin, arabirimi uygulayan sınıfın tanımında public olarak işaretlenmesi gerekir.
• extends ifadesi yoluyla bir arabirim tarafından veya implements ifadesi yoluyla bir sınıf tarafından birden çok arabirim miras alınabilir.

ActionScript 2.0'dan farklı olarak ActionScript 3.0, arabirim tanımlarında alıcı ve ayarlayıcı yöntemlerinin kullanılmasına olanak sağlar.

İlgili API Öğeleri

[internal] var varName
[internal] const kName
[internal] function functionName()  { 
	// your statements here 
}
[internal] class className{
	// your statements here 
}
[internal] namespace nsName

Bir sınıf, değişken, sabit veya işlevin aynı paket içindeki herhangi bir çağıran için kullanılabilir olduğunu belirtir. Sınıflar, özellikler ve yöntemler, varsayılan olarak internal ad alanına aittir.

İlgili API Öğeleri

label: statement
label: {
    statements
}

Bir ifadeyi break veya continue tarafından başvurulabilecek bir tanımlayıcı ile ilişkilendirir. Yuvalanmış döngülerde, bir etikete başvurmayan break veyacontinue ifadeleri yalnızca hızlı döngünün kalanını atlayabilir ve döngü serisinin tamamını atlamaz. Ancak, döngü serisinin tamamını tanımlayan ifade, ilişkilendirilmiş bir etiket içeriyorsa, break veya continue ifadesi döngü serisinin tamamını o etikete başvurarak atlayabilir.

Ayrıca etiketler bir blok ifadesinin dışına çıkmanıza olanak verir. Blok ifadesi döngünün parçası olmadıkça, bir etikete başvurmayan break ifadesini blok ifadesinin içine yerleştiremezsiniz. Blok ifadesi ilişkilendirilmiş bir etiket içeriyorsa, o etikete başvuran bir breakifadesini blok ifadesi içine yerleştirebilirsiniz.

outerLoop: for (var i:int = 0; i < 10; i++) {
	for (var j:int = 0; j < 10; j++) {
		if ( (i == 8) && (j == 0)) {
			break outerLoop;
		}
		trace(10 * i + j);
	}
}
/*
1
2
...
79
*/

foo: {
	trace("a");
	break foo;
	trace("b");
}
// a

İlgili API Öğeleri

namespace name [= uri]

Tanımların görünürlüğünü kontrol etmenizi sağlar. Önceden tanımlı ad alanları arasında public, private, protected ve internal yer alır.

Şu adımlar, nasıl bir ad alanı oluşturulduğunu, uygulandığını ve bir ad alanına nasıl başvurulduğunu gösterir:

• İlk olarak, namespace anahtar sözcüğünü kullanarak özel ad alanını tanımlayın. Örneğin, namespace version1 kodu, version1 adında bir ad alanı oluşturur.
• İkinci olarak, özellik veya yöntem bildirinizde özel ad alanınızı kullanarak bir özellik veya yönteme ad alanını uygulayın. Örneğin, version1 myProperty:String kodu, version1 ad alanına ait myProperty adında bir özellik oluşturur
• Üçüncü olarak, use anahtar sözcüğünü kullanarak veya bir tanımlayıcının önüne ad alanını ekleyerek ad alanına başvurun. Örneğin, use namespace version1; kodu, kodun sonraki satırları için version1 ad alanına başvurur ve version1::myProperty kodu, myProperty özelliği için version1 ad alanına başvurur.

İlgili API Öğeleri

native function functionName();
class className { 
	native function methodName();
}

Bir işlev veya yöntemin Flash Player tarafından yerel kodla uygulandığını belirtir. Flash Player, ActionScript uygulaması programlama arabiriminde (API) işlevleri ve yöntemleri bildirmek için dahili olarak native anahtar sözcüğünü kullanır. Bu anahtar sözcük kendi kodunuzda kullanılamaz.  

null

Değişkenlere atanabilen veya herhangi bir veri sağlanmadıysa bir işlev tarafından döndürülen özel bir değer. Eksik olan veya tanımlı bir veri türü içermeyen değerleri temsil etmek için null öğesini kullanabilirsiniz.

null değeri, undefined özel değeriyle karıştırılmamalıdır. null ve undefined öğeleri eşitlik (==) operatörüyle karşılaştırıldığında, eşit olurlar. Ancak null ve undefined öğeleri katı eşitlik (===) operatörüyle karşılaştırıldığında, eşit olmazlar.

var testArray:Array = new Array();
testArray[0] = "fee";
testArray[1] = "fi";
testArray[4] = "foo";

for (i = 0; i < 6; i++) {
    if (testArray[i] == null) {
        trace("testArray[" + i + "] == null");
    }
}

/* 
testArray[2] == null
testArray[3] == null
testArray[5] == null
*/

İlgili API Öğeleri

ObjectProxy sınıfının yöntemlerini tanımlar. Proxy alt sınıfının herhangi bir Proxy sınıfı yöntemi adlarıyla eşleşen örnek yöntem adlarını içermesi durumlarında ad çakışmalarını önlemek için, ObjectProxy sınıfı yöntemleri kendi ad alanlarında bulunur.

override function name() { 
	// your statements here 
}

Bir yöntemin miras alınan bir yöntemin yerine geçtiğini belirtir. Miras alınan bir yöntemi geçersiz kılmak için, override niteliğini kullanmanız ve parametre adının, sınıf özellikği niteliğinin, sayısının, türünün ve döndürme türünün tam olarak eşleştiğinden emin olmanız gerekir. override niteliği kullanılmadan bir yöntemi geçersiz kılma girişimi bir hataya yol açar. Aynı şekilde, yöntemin eşleşen bir miras alınmış yöntemi yoksa override niteliğinin kullanılması da bir hataya yol açar.

Şunlardan herhangi birinde override niteliğini kullanamazsınız:

• Değişkenler
• Sabitler
• Statik yöntemler
• Miras alınmayan yöntemler
• Bir arabirim yöntemi uygulayan yöntemler
• Üst sınıfta final olarak işaretli miras alınan yöntemler

var veya const ile bildirilen bir özelliği geçersiz kılamasanız da, temel sınıf özelliğini alıcı-ayarlayıcı haline getirerek ve get ve set ile tanımlanan yöntemleri geçersiz kılarak benzer işlevselliği elde edebilirsiniz.

İlgili API Öğeleri

package packageName {
    class someClassName { 
    } 
}

Kodunuzu, başka komut dosyalarının içine aktarılabilir ayrı ayrı gruplar halinde organize etmenizi sağlar. Sınıfın bir paket üyesi olduğunu belirtmek için package anahtar sözcüğünü kullanmanız gerekir.

İlgili API Öğeleri

class className{ 
	private var varName;
	private const kName;
	private function methodName() { 
		// your statements here 
	}
	private namespace nsName;
}

Bir değişken, sabit veya yöntemin yalnızca onu bildiren veya tanımlayan sınıf için kullanılabilir olduğunu belirtir. ActionScript 2.0'dan farklı olarak ActionScript 3.0'da private öğesi artık alt sınıflara erişilmesini sağlamaz. Üstelik private öğesi hem derleme zamanında hem de çalışma zamanında erişimi kısıtlar. Varsayılan olarak bir değişken veya işlev, aynı paketteki herhangi bir çağıran için kullanılabilir durumdadır. Bir değişkene veya işleve erişimi kısıtlamak istiyorsanız bu anahtar sözcüğü kullanın.

Bu anahtar sözcüğü arabirim tanımlarında değil, yalnızca sınıf tanımlarında kullanabilirsiniz. Bir sınıfa veya başka bir paket düzeyindeki tanımlara private öğesi uygulayamazsınız.

class A { 
  private var alpha:String = "visible only inside class A"; 
  public var beta:String = "visible everywhere"; 
}
	
class B extends A {
  function B() {
    alpha = "Access attempt from subclass"; // error
  }
}

İlgili API Öğeleri

class className{ 
	protected var varName;
	protected const kName;
	protected function methodName() { 
		// your statements here 
	}
	protected namespace nsName;
}

Bir değişken, sabit, yöntem veya ad alanının yalnızca onu tanımlayan sınıf için ve o sınıfın alt sınıfları için kullanılabilir olduğunu belirtir. ActionScript 3.0'da protected tanımı, private öğesinin ActionScript 2.0 sürümünün tanımına benzer, tek farkı protected öğesinin hem derleme zamanında hem de çalışma zamanında erişimi kısıtlamasıdır. Varsayılan olarak bir değişken veya işlev, aynı paketteki herhangi bir çağıran için kullanılabilir durumdadır. Bir değişkene veya işleve erişimi kısıtlamak istiyorsanız bu anahtar sözcüğü kullanın.

Bu anahtar sözcüğü arabirim tanımlarında değil, yalnızca sınıf tanımlarında kullanabilirsiniz. Bir sınıfa veya başka bir paket düzeyindeki tanımlara private öğesi uygulayamazsınız.

ActionScript 3.0'da protected tanımı, Java programlama dilindeki protected tanımından daha kısıtlayıcıdır. ActionScript 3.0'da protected, alt sınıflara erişimi katı şekilde sınırlarken, Java'da protected aynı paketteki sınıflara da erişilmesini sağlar. Örneğin, Base adında bir sınıf, protected olarak işaretli bir özellik içeriyorsa, ActionScript 3.0'da yalnızca Base öğesini genişleten sınıflar korumalı özelliğe erişebilir. Java'da, Base ile aynı paketteki tüm sınıflar, Base alt sınıfında olmasa da korumalı özelliğe erişebilir.

class A { 
  private var alpha:String = "visible only inside class A"; 
  protected var beta:String = "visible inside class A and its subclasses"; 
}
	
class B extends A {
  public function B() {
    beta = "Access attempt from subclass succeeded";
    trace(beta);  // Access attempt from subclass succeeded
  }
}

İlgili API Öğeleri

public var varName
public const kName
public function functionName()  { 
	// your statements here 
}
public class className {
	// your statements here 
}
public namespace nsName

Bir sınıf, değişken, sabit veya yöntemin herhangi bir çağıran için kullanılabilir olduğunu belirtir. Sınıflar, değişkenler ve yöntemler varsayılan olarak dahilidir, başka bir deyişle, yalnızca geçerli paket içinde görünebilirler. Bir sınıfı, değişkeni veya yöntemi tüm çağıranlara görünür yapmak için, public niteliğini kullanmanız gerekir.

class User { 
	public var age:Number; 
	public var fname:String; 
} // end of class User definition
 
var jimmy:User = new User(); 
jimmy.age = 27; 
jimmy.fname = "jimmy";
trace(jimmy.age, jimmy.fname); // 27 jimmy

İlgili API Öğeleri

function functionName () {
	return [expression]
}

Çalıştırmanın hemen çağırma işlevine dönmesine neden olur. return ifadesinin ardından bir ifade geliyorsa, ifade değerlendirilir ve sonuç döndürülür.

İşlev tanımı bir döndürme türü içeriyorsa, return ifadesinin ardından bir ifade gelmelidir. Herhangi bir döndürme türü belirtilmezse ve return ifadesi tek başına kullanılırsa, undefined öğesi döndürülür.

Birden çok değer döndüremezsiniz. Bunu yapmayı denerseniz, yalnızca son değer döndürülür. Şu örnekte c döndürülür:

return a, b, c ;

Birden çok değer döndürmeniz gerekirse, bunun yerine bir dizi veya nesne kullanın.

function sum(a:Number, b:Number, c:Number):Number { 
	return (a + b + c); 
} 
var newValue:Number = sum(4, 32, 78); 
trace(newValue); // 114

İlgili API Öğeleri

function set property(newValue:*) : void{ 
	// your statements here 
}

Genel arabirimde bir özellik olarak görüntülenen bir yöntem niteliğindeki ayarlayıcıyı tanımlar. Ayarlayıcı, var anahtar sözcüğüyle bildirilen bir özellik değerini ayarlayan özel bir yöntemdir. Diğer yöntemlerden farklı olarak ayarlayıcı, parantezler (()) olmadan çağrılır ve bu da ayarlayıcının bir değişken olarak görüntülenmesini sağlar.

Ayarlayıcılar, özel bir özellik için genel bir arabirim oluşturmanıza olanak sağlayarak bilgi gizleme ilkesini uygulamanızı sağlar. Bilgi gizlemenin avantajı, özel özelliğin alttaki uygulaması değişse de, genel arabirimin aynı şekilde kalmasıdır.

Ayarlayıcıların başka bir avantajı da, var ile bildirilen özellikler alt sınıflarda geçersiz kılınamazken, ayarlayıcıların alt sınıflarda geçersiz kılınabilmesidir.

Ayarlayıcının döndürme türü void veya belirtilmemiş olmalıdır.

Okuma-yazma özelliği oluşturmak için bir ayarlayıcı bir alıcıyla birleştirilebilir. Salt okunur bir özellik oluşturmak için, karşılık gelen ayarlayıcı olmadan bir alıcı oluşturun. Salt yazılır bir özellik oluşturmak için, karşılık gelen alıcı olmadan bir ayarlayıcı oluşturun.

package {
	class User { 
	    private var userAge:Number; 
	    
	    public function get age():Number {
	    	return userAge;
	    }
	    
	    public function set age(x:Number):void {
	    	userAge = x;	
	    }
	} 
} 

var myUser:User = new User();
myUser.age = 25;
trace(myUser.age); // 25

İlgili API Öğeleri

class someClassName{ 
	static var varName; 
	static const kName;
	static function methodName() { 
		// your statements here
	} 
}

Bir değişken, sabit veya yöntemin sınıfın örneklerine değil, sınıfın kendisine ait olduğunu belirtir.

Statik sınıf üyesine erişmek için, örnek adı yerine sınıf adını kullanın. Örneğin, Date sınıfı, yalnızca şu sözdizimi kullanılarak çağrılabilen parse() adında statik bir yöntem içerir:

Date.parse()

parse() yöntemi, Date sınıfı örneğinde çağrılamaz. Örneğin, şu kod bir hata oluşturur:

var myDate:Date = new Date();
            myDate.parse("Jan 01 00:00:00 2006"); // error

static öğesini arabirim tanımlarında değil, yalnızca sınıf tanımlarında kullanabilirsiniz.

Statik sınıf üyeleri miras alınmaz. Java veya C++ uygulamalarında yapabildiğiniz gibi, bir alt sınıfın adını kullanarak statik sınıf üyesine başvuramazsınız. Ancak, herhangi bir niteleyici kullanmadan bir sınıf veya alt sınıf içinde statik bir değişkene ya da yönteme başvurabilirsiniz. Aşağıdaki örneğe bakın.

Statik bir yöntem içinde super ifadesini veya this anahtar sözcüğünü kullanamazsınız.

class Users { 
	private static var numInstances:Number = 0; 
	function Users() { 
		numInstances++; 
	} 
	static function get instances():Number { 
		return numInstances; 
	} 
}

trace(Users.instances); 
var user1:Users = new Users(); 
trace(Users.instances); 
var user2:Users = new Users(); 
trace(Users.instances); 

class PowerUsers extends Users{
    function PowerUsers() {
        instances++;  // unqualified reference to static property Users.instances is legal
    }
}

trace(PowerUsers.instances); // error, cannot access static property using PowerUsers class

super([arg1, ..., argN])
super.method([arg1, ..., argN])

Bir yöntem veya yapıcının üst sınıf veya üst sürümünü çağırır. Sınıf yapıcısının gövdesinde kullanıldığında, super() ifadesi, yapıcının üst sınıf sürümünü çağırır. Üst sınıf yapıcısına yapılan çağrı, doğru sayıda argüman içermelidir. Açıkça çağırsanız da çağırmasanız da, üst sınıf yapıcısının her zaman çağrıldığını unutmayın. Açıkça çağırmazsanız, alt sınıf yapıcısının gövdesindeki birinci ifadeden önce herhangi bir argüman içermeyen bir çağrı otomatik olarak eklenir. Başka bir deyişle, yapıcı işlevini bir alt sınıfta tanımlarsanız ve üst sınıf yapıcısı bir veya daha fazla argüman alırsa, doğru sayıda argüman içeren üst sınıf yapıcısını açıkça çağırmanız gerekir, aksi takdirde bir hata oluşur. Ancak, üst sınıf yapıcısına yapılan çağrının, ActionScript 2.0'da gerekli olduğu gibi, alt sınıf yapıcınızdaki birinci ifade olması gerekmez.

super öğesi bir örnek yönteminin gövdesinde kullanıldığında, bir yöntemin üst sınıf sürümünü çağırmak için nokta (.) operatörüyle birlikte kullanılabilir ve isteğe bağlı olarak (arg1 ... argN) argümanlarını üst sınıf yöntemine iletebilir. Bu, yalnızca üst sınıf yöntemlerine ek davranış eklemekle kalmayıp aynı zamanda üst sınıf yöntemlerinin orijinal davranışını gerçekleştirmek için üst sınıf yöntemlerini de çağıran alt sınıf yöntemlerinin oluşturulmasında yararlıdır.

Statik yöntemde super ifadesini kullanamazsınız.

İlgili API Öğeleri

switch (expression) {
	caseClause: 
	[defaultClause:] 
}

Kontrolün, ifadenin değerine bağlı olarak birkaç ifadeden birine aktarılmasına neden olur. Tüm switch ifadeleri, hiçbir case ifadesi ile ifade eşleşmediğinde çalıştırılacak varsayılan bir durumu içermelidir. Her bir case ifadesi, başarısızlık hatasını önleyecek şekilde bir break ifadesiyle sonlandırılmalıdır. Bir durum başarısız olduğunda, durum test ifadesiyle eşleşmeyebilse de, sonraki case ifadesindeki kodu çalıştırır.

var switchExpression:int = 3;
		
switch (switchExpression) {
	case 0:
		trace(0);
		break;
	case 1:
		trace(1);
		break;
	case 2:
		trace(2);
		break;
	default:
		trace("Not 0, 1, or 2");
}

// Not 0, 1, or 2

İlgili API Öğeleri

this

Bir yöntemin kapsayıcı nesnesine bir başvuru. Bir komut dosyası çalıştırıldığında, this anahtar sözcüğü, komut dosyasını içeren nesneye başvurur. Yöntem gövdesinin içinde, this anahtar sözcüğü, çağrılan yöntemi içeren sınıf örneğine başvurur.

// incorrect version of Simple.as
/*
dynamic class Simple {
    function callfunc() {
        func();
    }
}
*/
// correct version of Simple.as
dynamic class Simple {
    function callfunc() {
        this.func();
    }
}

var simpleObj:Simple = new Simple();
simpleObj.func = function() {
	trace("hello there");
}
simpleObj.callfunc();

throw expression 

İşlenebilecek veya catch kod bloğu tarafından yakalanabilecek bir hata oluşturur ya da atar. Bir istisna catch bloğu tarafından yakalanmazsa, atılan değerin dize olarak temsili Çıktı paneline gönderilir. Bir istisna catch veya finally bloğu tarafından yakalanmazsa, atılan değerin dize olarak temsili günlük dosyasına gönderilir. Tipik olarak, Error sınıfının veya alt sınıflarının örneklerini atarsınız (bkz. Örnek bölümü).

Tipik olarak, Error sınıfının veya alt sınıflarının örneklerini atarsınız (bkz. Örnek bölümü).

function checkEmail(email:String) { 
	if (email.indexOf("@") == -1) { 
		throw new Error("Invalid email address"); 
	} 
} 
checkEmail("someuser_theirdomain.com");

try { 
	checkEmail("Joe Smith"); 
} 
catch (e) { 
	trace(e); 
}
// Error: Invalid email address.

// Define Error subclass InvalidEmailError 
class InvalidEmailAddress extends Error { 
    public function InvalidEmailAddress() {
    	message = "Invalid email address."; 
    }
}

import InvalidEmailAddress; 
function checkEmail(email:String) { 
	if (email.indexOf("@") == -1) { 
		throw new InvalidEmailAddress(); 
	} 
} 
try { 
	checkEmail("Joe Smith"); 
} 
catch (e) { 
	trace(e);
}
// Error: Invalid email address.

İlgili API Öğeleri

true

Doğruyu temsil eden Boolean değeri. Boolean değeri true veya false olur; true değerinin tersi, false olur. Otomatik veri türleme, true öğesini bir sayıya dönüştürdüğünde 1 olur; true öğesini bir dizeye dönüştürdüğünde "true" olur.

var shouldExecute:Boolean;
// ...
// code that sets shouldExecute to either true or false goes here
// shouldExecute is set to true for this example:

shouldExecute = true;

if (shouldExecute == true) {
    trace("your statements here");
}

// true is also implied, so the if statement could also be written:
// if (shouldExecute) {
//         trace("your statements here");
// }

var myNum:Number;
myNum = 1 + true;
trace(myNum); // 2

İlgili API Öğeleri

try { 
    // try block 
} finally { 
    // finally block  
} 

try { 
    // try block 
} catch(error[:ErrorType1]) {
    // catch block 
} [catch(error[:ErrorTypeN]) { 
    // catch block 
}] [finally {
    // finally block 
}]

Hata olabilecek bir kod bloğunu kapsar ve sonra hataya yanıt verir. İstisna işleme, try..catch..finally ifadeleri kullanılarak uygulanır ve ActionScript 3.0'daki çalışma zamanı hatalarını işleme için birincil mekanizmadır. Bir çalışma zamanı hatası gerçekleştiğinde, Flash Player bir istisna atar, başka bir deyişle Flash Player normal çalışmayı askıya alır ve özel bir Hata türü nesnesi oluşturur. Daha sonra Flash Player hata nesnesini kullanılabilir birinci catch bloğuna iletir veya atar. Herhangi bir catch bloğu kullanılabilir değilse, istisnanın yakalanmamış bir istisna olduğu düşünülür. Yakalanmamış istisnalar, komut dosyasının sonlandırılmasına neden olur.

Kodunuzda açıkça istisnalar atmak için throw ifadesini kullanabilirsiniz. Herhangi bir değeri atabilirsiniz ancak nesne, esneklik sağladığından ve Flash Player uygulamasının davranışıyla eşleştiğinden, en iyi uygulama bir nesne atmaktır.

İster Flash Player tarafından, isterse kendi kodunuz tarafından atılmış olsun, bir istisnayı yakalamak için, istisnayı atabilecek kodu try bloğuna yerleştirin. try bloğundaki kodlardan herhangi biri istisna atarsa kontrol, catch bloğuna ve sonra varsa finally bloğuna iletimleri kontrol eder. İstisna atılmış olup olmamasına bakılmaksızın, finally bloğu her zaman çalıştırılır. try bloğu içindeki kod bir istisna atmazsa (başka bir deyişletry bloğu normal şekilde tamamlanırsa), catch bloğunun içindeki kod yok sayılır ancak is ignored, finally bloğunun içindeki kod çalıştırılır. return ifadesi kullanılarak try bloğu çıksa da, finally bloğu çalıştırılır.

try bloğunun ardından bir catch bloğu, bir finally bloğu veya her ikisi gelmelidir. Tek bir try bloğu birden çok catch bloğu içerebilirken yalnızca bir finally bloğu içerebilir. try bloklarını istediğiniz kadar derin düzeylerde yuvalayabilirsiniz.

catch işleyicisinin içinde belirtilen error parametresi e veya theException veya x gibi basit bir tanımlayıcı olmalıdır. Parametre türlü de olabilir. Türlü parametreler birden çok catch bloğuyla kullanıldığında, tek bir try bloğundan atılan birden çok hata nesnesi türünü yakalamanıza olanak sağlar.

Atılan istisna bir nesneyse, atılan nesnenin belirtilen türde bir alt sınıf olması durumunda tür eşleşir. Belirli türde bir hata atılırsa, karşılık gelen hatayı işleyen catch bloğu çalıştırılır. Belirtilen türde olmayan bir istisna atılırsa, catch bloğu çalıştırılmaz ve try bloğundan istisna ile eşleşen catch işleyicisine otomatik olarak istisna atılır.

Bir işlev içinde hata atılırsa ve işlev catch işleyicisini içermiyorsacatchbloğu bulununcaya kadar Flash Player bu işlevden ve diğer çağıran işlevlerinden çıkar. Bu işlem süresince tüm düzeylerde finally işleyicileri çağrılır.

Not: Bir try bloğunda olay işleyicisini çağıran bir olay göndericisi varsa, catch bloğu olay işleyicisinde oluşturulan hatayı yakalamaz. Bundan sonra oluşturulan tüm hatalar LoaderInfo.uncaughtErrorEvents dinlenerek yakalanabilir.

import flash.display.Sprite;

var spr:Sprite = new Sprite();
try {
	spr.addChild(spr);
}
catch (e:ArgumentError) {
	trace (e); // ArgumentError: Error #2024: An object may not be added as a child of itself.
}

class RecordSetException extends Error { 
	public function RecordSetException () {
		message = "Record set exception occurred."; 
	}
}

class MalformedRecord extends Error { 
	public function MalformedRecord {
		message = "Malformed record exception occurred."; 
	}
}

class RecordSet { 
	public function sortRows() { 
		var returnVal:Number = randomNum(); 
		if (returnVal == 1) { 
			throw new RecordSetException(); 
		} 
		else if (returnVal == 2) { 
			throw new MalformedRecord(); 
		} 
	}
	public function randomNum():Number { 
		return Math.round(Math.random() * 10) % 3; 
	}
}

import RecordSet; 
var myRecordSet:RecordSet = new RecordSet();
try { 
	myRecordSet.sortRows(); 
	trace("everything is fine"); 
} 
catch (e:RecordSetException) { 
	trace(e.toString()); 
} 
catch (e:MalformedRecord) { 
	trace(e.toString()); 
}

İlgili API Öğeleri

use namespace ns1[, ns2, ...nsN]

Belirtilen ad alanlarının açık ad alanları kümesine eklenmesini sağlar. Geçerli kod bloğundan çıkıldığında, belirtilen ad alanları, açık ad alanları kümesinden kaldırılır. use namespace direktifi, bir program, paket tanımı veya sınıf tanımının üst düzeyinde görüntülenebilir.

İlgili API Öğeleri

var variableName [= value1][...,variableNameN[=valueN]] 

Bir değişkeni belirtir. Bir işlev içinde değişkenleri bildirirseniz, değişkenler yerel olur. Bu değişkenler işlev için tanımlanır ve işlev çağrısının sonunda zaman aşımına uğrar.

Başka bir nesnenin kapsamındaki bir değişkeni yerel bir değişken olarak bildiremezsiniz.

my_array.length = 25; // ok 
var my_array.length = 25; // syntax error 

Bir değişkenin sonuna, ardından veri türü gelen iki nokta karakterini ekleyerek, o değişkene veri türü atayabilirsiniz.

Bildirimleri virgüllerle ayırarak (bu sözdizimi, kodunuzdaki netliği azaltabilse de), tek bir ifadede birden çok değişken bildirebilirsiniz:

var first:String = "Bart", middle:String = "J.", last:String = "Bartleby";

var product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); 
trace(product_array); 
// Studio,Dreamweaver,Flash,ColdFusion,Contribute,Breeze,Flex

İlgili API Öğeleri

while (condition) { 
	// statement(s)
}

Bir koşulu değerlendirir ve koşul true olarak değerlendirilirse, koşulu tekrar değerlendirmeye dönmeden önce bir veya daha fazla ifadeyi çalıştırır. Koşul false olarak değerlendirildikten sonra ifadeler atlanır ve döngü sona erer.

while ifadesi şu adım serisini gerçekleştirir. 1 ile 4 arasındaki adımların her bir tekrarı, döngünün yinelemesi olarak adlandırılır. Şu adımlarda gösterildiği gibi, her yinelemenin başında koşul test edilir:

1. condition ifadesi değerlendirilir.
2. condition öğesi true olarak değerlendirilirse veya true Boolean değerine dönüştürülen bir değer (örn. sıfır dışında bir sayı) olarak değerlendirilirse, adım 3'e gidin. Aksi takdirde, while ifadesi tamamlanır ve çalıştırma while döngüsünden sonra bir sonraki ifadede yeniden başlatılır.
3. statement(s) ifade bloğunu çalıştırın. continue ifadesiyle karşılaşılırsa, kalan ifadeleri atlayın ve adım 1'e gidin. break ifadesiyle karşılaşılırsa, while ifadesi tamamlanır ve çalıştırma, while döngüsünden sonra bir sonraki ifadede yeniden başlatılır.
4. Adım 1'e gidin.

Döngü, genellikle bir sayaç değişkeni belirtilen bir değerden düşük olduğunda eylem gerçekleştirmek için kullanılır. Her döngünün sonunda, belirtilen değere ulaşılıncaya kadar sayaç artırılır. Bu noktada, condition öğesi artık true olmaz ve döngü sona erer.

Yalnızca bir ifade çalıştırılacaksa, while ifadesi tarafından çalıştırılacak ifadeleri kapsayan küme parantezleri ({}) gerekli değildir.

var i:Number = 0; 
while (i < 20) { 
	trace(i); 
	i += 3; 
}
/*
0 
3 
6 
9 
12
15 
18
*/

İlgili API Öğeleri

with (object:Object) { 
	// statement(s)
}

Bir veya birkaç ifadenin çalıştırılması için kullanılacak varsayılan bir nesne oluşturarak potansiyel olarak yazılması gereken kod miktarını azaltır.

object parametresi, statement(s) parametresindeki özelliklerin, değişkenlerin ve işlevlerin okunduğu bağlam olur. Örneğin, object öğesi my_array olursa ve belirtilen özelliklerden ikisi length ve concat olursa, bu özellikler otomatik şekilde my_array.length ve my_array.concat olarak okunur. Başka bir örnekte, object öğesi state.california olursa, with ifadesi içindeki eylem veya ifadeler, california örneğinin içinden çağrılır.

ActionScript, statement(s) parametresinde bir tanımlayıcının değerini bulmak için, object tarafından belirtilen kapsam zincirinin başından başlayarak belirli bir sırayla kapsam zincirindeki düzeylerin her birinde tanımlayıcıyı arar.

Tanımlayıcıları çözümlemek için with ifadesi tarafından kullanılan kapsam zinciri, şu listedeki birinci öğeyle başlar ve son öğeye kadar devam eder:

• En içteki with ifadesinde object parametresinde belirtilen nesne
• En dıştaki with ifadesinde object parametresinde belirtilen nesne
• Activation nesnesi (komut dosyası işlevde çağrılan yerel değişkenleri tutan bir işlevi çağırdığında otomatik olarak oluşturulan geçici bir nesne)
• Geçerli olarak çalıştırılan komut dosyasını içeren nesne
• Global nesnesi (Math ve String gibi yerleşik nesneler)

with ifadesinin içine bir değişken ayarlamak için, with ifadesinin dışında değişkeni bildirmiş olmanız ya da değişkenin bulunmasını istediğiniz Zaman Çizelgesine tam yolu girmeniz gerekir. with ifadesinde bir değişkeni bildirmeden ayarlarsanız, with ifadesi, kapsam zincirine göre değer arar. Değişken yoksa, yeni değer, with ifadesinin çağrıldığı Zaman Çizelgesinde ayarlanır.

function polar(r:Number):void { 
	var a:Number, x:Number, y:Number; 
	with (Math) { 
		a = PI * pow(r, 2); 
		x = r * cos(PI); 
		y = r * sin(PI / 2); 
	} 
	trace("area = " + a); 
	trace("x = " + x); 
	trace("y = " + y); 
} polar(3);
/* 
area = 28.2743338823081 
x = -3 
y = 3
*/