Operatörler 

Sayısal ifadeler ekler. Her iki ifade tam sayı olursa, toplam da bir tam sayı olur; ifadelerden biri veya her ikisi kayan nokta sayısı olursa, toplam da bir kayan nokta sayısı olur.

Yalnızca bir ifade dizeyse, diğer tüm ifadeler dizelere dönüştürülür ve toplanmak yerine bitiştirilir. Aksi takdirde, bir ifade sayı değilse, Flash^®, Player bunu bir sayıya dönüştürür.

trace(2 + 3); // 5

trace(2.5 + 3.25); // 5.75

trace("Number " + 8 + 0); // Number 80

var oldBalance:Number = 1345.23; 
var currentBalance = deposit_txt.text + oldBalance; 
trace(currentBalance); 

var oldBalance:Number = 1345.23; 
var currentBalance:Number = Number(deposit_txt.text) + oldBalance;
trace(currentBalance);

İlgili API Öğeleri

expression1 öğesine expression1 + expression2 değerini atar. Örneğin, şu iki ifade aynı sonucu verir:

x += y; 
x = x + y; 

var x:Number = 5; 
var y:Number = 10; 
x += y; 
trace(x); // 15 

İlgili API Öğeleri

myArray = [a0, a1,...aN]
myArray[i] = value 
myObject[propertyName]

Belirtilen öğeler ile (a0, vb.) yeni bir dizi veya çok boyutlu dizi başlatır veya bir dizideki öğelere erişir. Dizi erişimi operatörü, dinamik olarak örnek, değişken ve nesne adları ayarlamanızı ve almanızı sağlar. Ayrıca nesne özelliklerine erişmenize de olanak verir.

Kullanım 1: Dizi, özellikleri öğe olarak adlandırılan ve bu öğelerin her biri dizin adında bir sayıyla tanımlanan bir nesnedir. Bir dizi oluşturduğunuzda, öğeleri dizi erişimi ([]) operatörüyle (veya ayraçlarla) sararsınız. Dizi, çeşitli türlerde öğeler içerebilir. Örneğin, employee adındaki şu dizi üç öğe içerir; birincisi bir sayı ve diğer ikisi de dizedir (tırnak işaretleri içinde):

var employee:Array = [15, "Barbara", "Jay"]; 

var ticTacToe:Array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; 
			
/* Select Debug > List Variables in test mode 
to see a list of the array elements.*/ 

var my_array:Array = new Array(); 
my_array[0] = 15; 
my_array[1] = "Hello"; 
my_array[2] = true; 

my_array[3] = "George"; 

var ticTacToe:Array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; 
trace(ticTacToe[1][2]); // 6 

var obj:Object = new Object();
obj.prop1 = "foo";
trace(obj["prop" + 1]); // foo
obj.prop2 = "bar";
for (j in obj) {
	trace(obj[j]);
} 
/* Output of for loop: 
foo
bar */

var my_array:Array = []; 
var my_array:Array = new Array(); 

Şu örnek, üç öğe içeren employee_array adında bir dizi oluşturur ve dizideki üçüncü öğeyi değiştirir.

var employee_array = ["Barbara", "George", "Mary"]; 
trace(employee_array); // Barbara,George,Mary 
employee_array[2] = "Sam"; 
trace(employee_array); // Barbara,George,Sam 

var obj:Object = new Object();
obj.prop1 = "foo";
obj.prop2 = "bar";

for (var i:int = 1;i < 3;i++) {
	trace(obj["prop"+i]);
}
/* Output of for loop:
foo
bar */ 

İlgili API Öğeleri

Birinci işlenen tarafından belirtilen bir ifadenin, ikinci işlenen tarafından belirtilen veri türünün bir üyesi olup olmadığını değerlendirir. Birinci işlenen, veri türünün bir üyesiyse, sonuç birinci işlenendir. Aksi takdirde sonuç null değeridir.

İkinci işlenen için kullanılan ifadenin bir veri türü olarak değerlendirilmesi gerekir.

public var myArray:Array = ["one", "two", "three"];
trace(myArray as Array);  // one,two,three
trace(myArray as Number); // null
trace(myArray as int);    // null

İlgili API Öğeleri

expression2 (sağdaki işlenen) değerini, expression1 öğesindeki değişkene, dizi öğesine veya özelliğe atar. Atama değere veya başvuruya göre olabilir. Değere göre atama, expression2 öğesinin gerçek değerini kopyalar ve expression1 içine kaydeder. expression2 ilkel bir değer olduğunda, başka bir deyişle expression2 öğesinin veri türü Boolean, Number, int, uint veya String olduğunda, değere göre atama kullanılır. Başvuruya göre atama, expression2 öğesine yapılan bir başvuruyu expression1 içine kaydeder. Başvuruya göre atama yaygın olarak new operatörüyle kullanılır. new operatörü bellekte bir nesne oluşturur ve bellekteki bu konumun bir başvurusu bir değişkene atanır.

Not: ActionScript 3.0'da tüm değerler (ilkel değerler dahil) nesnedir ve tüm atamalar başvuruya göre yapılır ancak ilkel nesneler, değere göre atanmış gibi davranmalarını sağlayan özel operatörler içerir.

var z:Number = 5;

var x:String;
x = "hello";

var moonsOfJupiter:Array = new Array();
moonsOfJupiter[0] = "Callisto";

var mercury:Object = new Object();
mercury.diameter = 3030; // in miles
trace(mercury.diameter); // 3030

var merkur:Object = mercury;
merkur.diameter = 4878;  // in kilometers
trace(mercury.diameter); // 4878

İlgili API Öğeleri

 myXML.@attributeName 

Bir XML veya XMLList nesnesinin niteliklerini tanımlar. Örneğin, myXML.@id, myXML XML nesnesi için id adındaki nitelikleri tanımlar. Niteliklere ulaşmak için şu sözdizimini de kullanabilirsiniz: myXML.attribute("id"), myXML["@id"] ve myXML.@["id"]. myXML.@id sözdizimi önerilir. Tüm nitelik adlarının bir XMLList nesnesini döndürmek için, @* öğesini kullanın. Ayrılmış bir ActionScript kelimesiyle eşlenen adı içeren bir nitelik döndürmek için, @ operatörü yerine attribute() yöntemini kullanın.

var myXML:XML = 
	<item id = "42">
		<catalogName>Presta tube</catalogName>
		<price>3.99</price>
	</item>;

trace(myXML.@id); // 42

var xml:XML =<example id='123' color='blue'/>
 var xml2:XMLList = xml.@*;
 trace(xml2 is XMLList); // true
 trace(xml2.length());  // 2
 for (var i:int = 0; i < xml2.length(); i++)
 { 
	trace(typeof(xml2[i]));    // xml
	trace(xml2[i].nodeKind()); // attribute
	trace(xml2[i].name());     // id and color
 } 

var xml:XML = <example class='123'/>
trace(xml.attribute("class"));

İlgili API Öğeleri

expression1 ve expression2 öğelerini 32-bit işaretsiz tam sayılara dönüştürür ve tam sayı parametrelerinin her bitinde bir Boolean AND işlemi gerçekleştirir. Ondalık işaretinden sonraki basamaklar atılarak kayan nokta sayıları tam sayılara dönüştürülür. Sonuç ise yeni bir 32-bit bir tam sayıdır.

Pozitif bir tamsayı maksimum 4294967295 veya 0xFFFFFFFF değerli imzasız bir onaltılık değere dönüştürülür; maksimumdan daha büyük değerlerin en önemli basamakları değerin 32 bit şeklinde kalması için atılır. Negatif bir sayı imzasız bir onaltılık değere ikinin tümleme bildirimini kullanarak dönüştürülür ve minimum değer -2147483648 veya 0x800000000 olur; minimumdan düşük bir sayı en önemli basamakları atılmadan önce ikinin tümlemesine daha yüksek bir kesinlikle dönüştürülür.

Sonuç, 32-bit ikiye tümleme sayısı olarak yorumlanır, böylece sonuç -2147483648 ile 2147483647 aralığında bir tam sayıdır.

var insert:Number = 13; 
var update:Number = 11; 
trace(insert & update); // 9 (or 1001 binary) 

  1101
& 1011
  ----
  1001

Şu örnekler, döndürme değeri dönüştürmesinin davranışını gösterir:

trace(0xFFFFFFFF); // 4294967295 
trace(0xFFFFFFFF & 0xFFFFFFFF); // -1 
trace(0xFFFFFFFF & -1); // -1 
trace(4294967295 & -1); // -1 
trace(4294967295 & 4294967295); // -1 

İlgili API Öğeleri

expression1 öğesine expression1 & expression2 değerini atar. Örneğin, şu iki ifade eşdeğerdir:

x &= y; 
x = x & y; 

var x:Number = 15; 
var y:Number = 9; 
trace(x &= y); // 9 

İlgili API Öğeleri

expression1 ve shiftCount öğesini 32-bit tam sayılara dönüştürür ve expression1 öğesindeki tüm bitleri, shiftCount öğesinin dönüştürülmesinde ortaya çıkan tam sayının belirttiği basamak sayısı kadar sola kaydırır. Bu işlemin sonucunda boşaltılan bit konumları 0 ile doldurulur ve sola kaydırılan bitler atılır. Değerin bir konum sola kaydırılması, o değerin 2 ile çarpılmasına eşdeğerdir.

Ondalık işaretinden sonraki basamaklar atılarak kayan nokta sayısı tam sayıya dönüştürülür. Pozitif bir tamsayı maksimum 4294967295 veya 0xFFFFFFFF değerli imzasız bir onaltılık değere dönüştürülür; maksimumdan daha büyük değerlerin en önemli basamakları değerin 32 bit şeklinde kalması için atılır. Negatif bir sayı imzasız bir onaltılık değere ikinin tümleme bildirimini kullanarak dönüştürülür ve minimum değer -2147483648 veya 0x800000000 olur; minimumdan düşük bir sayı en önemli basamakları atılmadan önce ikinin tümlemesine daha yüksek bir kesinlikle dönüştürülür.

Sonuç, 32-bit ikiye tümleme sayısı olarak yorumlanır, böylece sonuç -2147483648 ile 2147483647 aralığında bir tam sayıdır.

Sonuç negatif bir tam sayıysa, sonucu uint türünde bir değişkene atamayı denediğinizde bir çalışma zamanı hatası oluşur. ActionScript herhangi bir "işaretsiz bitsel sola kaydırma" operatörü içermese de, uint(expression1 << shiftCount) öğesini kullanarak aynı etkiyi elde edebilir ve çalışma zamanı hatasını önleyebilirsiniz:

var num1:uint = 0xFF;
var num2:uint = uint(num1 << 24); // uint() prevents runtime error

x = 1 << 10

   00000000001 binary 
<<          10 decimal
--------------
   10000000000 binary equals 1024 decimal 

Şu örnekte, 7 tam sayısı 8 bit sola kaydırılır:

x = 7 << 8

   00000000111 binary 
<<           8 decimal
--------------
   11100000000 binary equals 1792 decimal 

Şu trace ifadesi, bitlerin üç konum sola itildiğini gösterir:

// 1 binary == 0001 
// 8 binary == 1000 
trace(1 << 3); // 8 

İlgili API Öğeleri

[Bitsel sola kaydırma (<<=) işlemi gerçekleştirir ve sonuç olarak içerikleri expression1 öğesinde saklar. Şu iki ifade eşdeğerdir:

A <<= B
A = (A << B)

var x:Number = 4; 
// Shift all bits one slot to the left. 
x <<= 1; 
trace(x); // 8 
// 4 decimal = 0100 binary 
// 8 decimal = 1000 binary 

İlgili API Öğeleri

expression öğesini 32-bit işaretli bir tam sayıya dönüştürür ve sonra bitsel bire tümlemeyi uygular. Başka bir deyişle, 0 olan her bit sonuçta 1 olarak ayarlanır ve 1 olan her bit sonuçta 0 olarak ayarlanır. Sonuç ise işaretli 32-bit bir tam sayıdır. Bu operatör, bire tümleme operatörü veya bitsel tümleme operatörü olarak da bilinir.

Örneğin, 0x7777 onaltılık değeri şu ikili sayıyla temsil edilir:

0111011101110111

Bu onaltılık değerin (~0x7777) bitsel olumsuzlaması şu ikili sayıdır:

1000100010001000

Onaltılık olarak bu şöyledir: 0x8888. Bu nedenle, ~0x7777, 0x8888 olur.

Bitsel operatörler en yaygın olarak bayrak bitlerinin (her biri 1 bit olarak paketlenmiş Boolean değerleri) temsil edilmesinde kullanılır.

Ondalık işaretinden sonraki basamaklar atılarak kayan nokta sayısı tam sayıya dönüştürülür. Pozitif bir tamsayı maksimum 4294967295 veya 0xFFFFFFFF değerli imzasız bir onaltılık değere dönüştürülür; maksimumdan daha büyük değerlerin en önemli basamakları değerin 32 bit şeklinde kalması için atılır. Negatif bir sayı imzasız bir onaltılık değere ikinin tümleme bildirimini kullanarak dönüştürülür ve minimum değer -2147483648 veya 0x800000000 olur; minimumdan düşük bir sayı en önemli basamakları atılmadan önce ikinin tümlemesine daha yüksek bir kesinlikle dönüştürülür.

Sonuç, 32-bit ikiye tümleme sayısı olarak yorumlanır, böylece sonuç -2147483648 ile 2147483647 aralığında bir tam sayıdır.

var ReadOnlyFlag:int = 0x0001; // defines bit 0 as the read-only flag 
var flags:int = 0; 
trace(flags); 
/* To set the read-only flag in the flags variable, 
   the following code uses the bitwise OR: 
*/
flags |= ReadOnlyFlag; 
trace(flags); 
/* To clear the read-only flag in the flags variable, 
   first construct a mask by using bitwise NOT on ReadOnlyFlag. 
   In the mask, every bit is a 1 except for the read-only flag. 
   Then, use bitwise AND with the mask to clear the read-only flag. 
   The following code constructs the mask and performs the bitwise AND: 
*/ 
flags &= ~ReadOnlyFlag; 
trace(flags); 
// 0 1 0 

İlgili API Öğeleri

expression1 ve expression2 öğelerini 32-bit işaretsiz tam sayılara dönüştürür ve expression 1 veya expression2 öğesinin karşılık gelen bitlerinin 1 olduğu her bit konumuna 1 değerini yerleştirir.

Ondalık işaretinden sonraki basamaklar atılarak kayan nokta sayısı tam sayıya dönüştürülür. Pozitif bir tamsayı maksimum 4294967295 veya 0xFFFFFFFF değerli imzasız bir onaltılık değere dönüştürülür; maksimumdan daha büyük değerlerin en önemli basamakları değerin 32 bit şeklinde kalması için atılır. Negatif bir sayı imzasız bir onaltılık değere ikinin tümleme bildirimini kullanarak dönüştürülür ve minimum değer -2147483648 veya 0x800000000 olur; minimumdan düşük bir sayı en önemli basamakları atılmadan önce ikinin tümlemesine daha yüksek bir kesinlikle dönüştürülür.

Sonuç, 32-bit ikiye tümleme sayısı olarak yorumlanır, böylece sonuç -2147483648 ile 2147483647 aralığında bir tam sayıdır.

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 | 1001 = 1111 
trace(a | b); // returns 15 decimal (1111 binary) 

İlgili API Öğeleri

expression1 öğesine expression1 | expression2 değerini atar. Örneğin, şu iki ifade eşdeğerdir:

x |= y; 
x = x | y; 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 |= 1001 = 1111 
trace(a |= b); // returns 15 decimal (1111 binary) 

İlgili API Öğeleri

expression ve shiftCount öğesini 32-bit tam sayılara dönüştürür ve expression öğesindeki tüm bitleri, shiftCount öğesinin dönüştürülmesinde ortaya çıkan tam sayının belirttiği basamak sayısı kadar sağa kaydırır. Sağa kaydırılan bitler atılır. Orijinal ifadenin işaretini korumak için, expression öğesinin en önemli biti (sola en uzak olan bit) 0 ise, soldaki bitler 0 ile doldurulur ve en önemli bit 1 ise 1 ile doldurulur. Bir değerin bir konum sağa kaydırılması, değerin 2'ye bölünüp kalanın atılmasına eşdeğerdir.

Ondalık işaretinden sonraki basamaklar atılarak kayan nokta sayısı tam sayıya dönüştürülür. Pozitif bir tamsayı maksimum 4294967295 veya 0xFFFFFFFF değerli imzasız bir onaltılık değere dönüştürülür; maksimumdan daha büyük değerlerin en önemli basamakları değerin 32 bit şeklinde kalması için atılır. Negatif bir sayı imzasız bir onaltılık değere ikinin tümleme bildirimini kullanarak dönüştürülür ve minimum değer -2147483648 veya 0x800000000 olur; minimumdan düşük bir sayı en önemli basamakları atılmadan önce ikinin tümlemesine daha yüksek bir kesinlikle dönüştürülür.

Sonuç, 32-bit ikiye tümleme sayısı olarak yorumlanır, böylece sonuç -2147483648 ile 2147483647 aralığında bir tam sayıdır.

var a:Number = 65535 >> 8; 
trace(a); // 255

    00000000000000001111111111111111 binary (65535 decimal)
>>                                 8 decimal
--------------------
    00000000000000000000000011111111 binary (255 decimal)

var a:Number = -8 >> 1;
trace(a); // -4

    11111111111111111111111111111000 binary (-8 decimal)
>>							    1 decimal
--------------------
    11111111111111111111111111111100 binary (-4 decimal)

İlgili API Öğeleri

Bitsel sağa kaydırma işlemini gerçekleştirir ve sonucu expression içine kaydeder.

Şu iki ifade eşdeğerdir:

A >>= B; 
A = (A >> B);

function convertToBinary(numberToConvert:Number):String { 
	var result:String = ""; 
	for (var i = 0; i < 32; i++) { 
		// Extract least significant bit using bitwise AND. 
		var lsb:Number = numberToConvert & 1; 
		// Add this bit to the result.
		result = (lsb ? "1" : "0")+result; 
		// Shift numberToConvert right by one bit, to see next bit. 
		numberToConvert >>= 1; 
	} 
	return result; 
} 
trace(convertToBinary(479)); 
// Returns the string 00000000000000000000000111011111. 
// This string is the binary representation of the decimal number 479.

İlgili API Öğeleri

Soldaki bitler her zaman 0 ile doldurulduğundan orijinal ifadenin işaretini korumaması dışında, bitsel sağa kaydırma (>>) operatörüyle aynıdır.

Ondalık işaretinden sonraki basamaklar atılarak kayan nokta sayısı tam sayıya dönüştürülür. Pozitif bir tamsayı maksimum 4294967295 veya 0xFFFFFFFF değerli imzasız bir onaltılık değere dönüştürülür; maksimumdan daha büyük değerlerin en önemli basamakları değerin 32 bit şeklinde kalması için atılır. Negatif bir sayı imzasız bir onaltılık değere ikinin tümleme bildirimini kullanarak dönüştürülür ve minimum değer -2147483648 veya 0x800000000 olur; minimumdan düşük bir sayı en önemli basamakları atılmadan önce ikinin tümlemesine daha yüksek bir kesinlikle dönüştürülür.

Sonuç, 32-bit işaretsiz tam sayı olarak yorumlanır, böylece sonuç 0 ile 4294967295 aralığında bir tam sayıdır.

Not: ActionScript, tamamlayıcı bir "bitsel işaretsiz sola kaydırma" operatörüne sahip değildir ancak uint(expression << shiftCount) öğesini kullanarak aynı etkiyi elde edebilirsiniz.

var a:Number = -1 >>> 1; 
trace(a); // 2147483647 

İlgili API Öğeleri

İşaretsiz bitsel sağa kaydırma işlemini gerçekleştirir ve sonucu expression içine kaydeder. Şu iki ifade eşdeğerdir:

A >>>= B; 
A = (A >>> B); 

var a:Number = -1;
a >>>= 1; 
trace(a); // 2147483647 

İlgili API Öğeleri

expression1 ve expression2 öğelerini 32-bit işaretsiz tam sayılara dönüştürür ve expression 1 veya expression2 öğesinde (ancak her ikisinde değil) karşılık gelen bitlerin 1 olduğu her bit konumuna 1 değerini yerleştirir.

Ondalık işaretinden sonraki basamaklar atılarak kayan nokta sayısı tam sayıya dönüştürülür. Pozitif bir tamsayı maksimum 4294967295 veya 0xFFFFFFFF değerli imzasız bir onaltılık değere dönüştürülür; maksimumdan daha büyük değerlerin en önemli basamakları değerin 32 bit şeklinde kalması için atılır. Negatif bir sayı imzasız bir onaltılık değere ikinin tümleme bildirimini kullanarak dönüştürülür ve minimum değer -2147483648 veya 0x800000000 olur; minimumdan düşük bir sayı en önemli basamakları atılmadan önce ikinin tümlemesine daha yüksek bir kesinlikle dönüştürülür.

Sonuç, 32-bit ikiye tümleme sayısı olarak yorumlanır, böylece sonuç -2147483648 ile 2147483647 aralığında bir tam sayıdır.

// 15 decimal = 1111 binary 
// 9 decimal = 1001 binary 
var a:Number = 15 ^ 9; 
trace(a); 
// 1111 ^ 1001 = 0110 
// returns 6 decimal (0110 binary) 

İlgili API Öğeleri

expression1 öğesine expression1^ expression2 değerini atar. Örneğin, şu iki ifade eşdeğerdir:

x ^= y 
x = x ^ y 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
trace(a ^= b); // returns 6 decimal (0110 binary) 

İlgili API Öğeleri

/* comment */

/* comment

   comment */

Komut dosyası yorumlarının bir veya daha fazla satırını sınırlar. Açılış sınırlayıcı (/*) ile kapanış sınırlayıcı (*/) arasında görüntülenen karakterler yorum olarak yorumlanır ve ActionScript derleyicisi tarafından yok sayılır. Art arda birden çok satırda komutları tanımlamak için bu sınırlayıcıları kullanın; tek satırlık yorumlar için // sınırlayıcısını kullanın.

Kapanış bloğu yorum sınırlayıcısını (*/) çıkarırsanız veya yorumları yuvalamayı denerseniz bir hata mesajı alırsınız. Bir açılış sınırlayıcısı (/*) kullanıldıktan sonra, öncesinde bulunan açılış sınırlayıcılarının sayısı dikkate alınmaksızın birinci kapanış sınırlayıcısı (*/) yorumu sonlandırır.

/* records the X and Y positions of 
the ball and bat movie clips */ 
var ballX:Number = ball_mc._x; 
var ballY:Number = ball_mc._y; 
var batX:Number = bat_mc._x; 
var batY:Number = bat_mc._y; 

/* This is an attempt to nest comments. 
/* But the first closing tag will be paired 
with the first opening tag */ 
and this text will not be interpreted as a comment */ 

İlgili API Öğeleri

 myXML = <{tagName} {attributeName} = {attributeValue}>{content}

XML veya XMLList başlatıcıda kullanılan bir ifadeyi değerlendirir. XML veya XMLList başlatıcı, XML ya da XMLList türünde bir değişkene atanan değişmez bir değerdir. XML veya XMLList başlatıcıda, değişmez adlar ya da değerler yerine, XML { ve } operatörleriyle sınırlanan bir ifade kullanılabilir. tagName, attributeName, attributeValue ve content yerinde bir ifade kullanılabilir.

var tagname:String = "item"; 
var attributename:String = "id"; 
var attributevalue:String = "5"; 
var content:String = "Chicken"; 
var x:XML = <{tagname} {attributename}={attributevalue}>{content}</{tagname}>; 
trace(x.toXMLString()); // <item id="5">Chicken</item>

İlgili API Öğeleri

 myXML[expression]

Bir XML veya XMLList nesnesinin özelliğine ya da niteliğine erişir. Ayraç operatörü, nokta (.) operatörü ile erişilemeyen özellik adlarına erişmenize olanak sağlar.

var myXML:XML = <a><foo-bar>44</foo-bar></a>;
trace(myXML["foo-bar"]);

İlgili API Öğeleri

Önce expression1, sonra expression2 öğesini değerlendirir ve bu şekilde devam eder. Bu operatör asıl olarak for döngüsü ifadesiyle ve genellikle parantez () operatörüyle birlikte kullanılır.

for (i = 0, j = 0; i < 3 && j < 3; i++, j+=2) { 
	trace("i = " + i + ", j = " + j); 
} 
// output: 
// i = 0, j = 0 
// i = 1, j = 2

var v:Number = 0; 
v = 4, 5, 6; 
trace(v); // 4 

var v:Number = 0; 
v = (4, 5, 6); 
trace(v); // 6 

var v:Number = 0; 
var z:Number = 0; 
v = v + 4 , z++, v + 6; 
trace(v); // 4 
trace(z); // 1 

var v:Number = 0; 
var z:Number = 0; 
v = (v + 4, z++, v + 6); 
trace(v); // 6 
trace(z); // 1 

İlgili API Öğeleri

Dizeleri bitiştirir (birleştirir). Yalnızca bir ifade dizeyse, diğer ifadelerin tümü dizelere dönüştürülür ve bitiştirilir.

Her iki ifade de sayıysa, bu operatör bir toplama operatörü olarak hareket eder.

var lastName:String = "Cola"; 
var instrument:String = "Drums"; 
trace(lastName + " plays " + instrument); // Cola plays Drums 

trace("Number " + 8 + 0); // Number 80

var a:String = 3 + 10 + "asdf"; 
trace(a); // 13asdf 
var b:String = "asdf" + 3 + 10; 
trace(b); // asdf310 

İlgili API Öğeleri

expression1 + expression2

XML veya XMLList değerlerini bir XMLList nesnesinde bitiştirir (birleştirir). Yalnızca her iki işlenen de XML veya XMLList değeri olduğunda bir XMLList nesnesi döndürülür.

var x1:XML = 
		<employee id = "42">
			<firstName>Joe</firstName>
			<lastName>Smith</lastName>
		</employee>;

var x2:XML = 
		<employee id = "43">
			<firstName>Susan</firstName>
			<lastName>Jones</lastName>
		</employee>;

var myXMLList:XMLList = x1 + x2;
	
trace(myXMLList.toXMLString()); 

trace ifadesi şu çıktıyı üretir:

<employee id = "42">
	<firstName>Joe</firstName>
	<lastName>Smith</lastName>
</employee>
<employee id = "43">
	<firstName>Susan</firstName>
	<lastName>Jones</lastName>
</employee>
	

İlgili API Öğeleri

expression1 öğesine expression1 + expression2 değerini atar. Örneğin, şu iki ifade aynı sonucu verir:

x += y; 
x = x + y;

var x1:String = "My name is "; 
x1 += "Gilbert"; 
trace(x1); // My name is Gilbert 

İlgili API Öğeleri

expression1 += expression2

Bir XMLList nesnesi olan expression1 öğesine expression1 + expression2 değerini atar. Örneğin, şu iki ifade aynı sonucu verir:

x += y; 
x = x + y; 

var x1:XML = <location>Athens</location>;	
var x2:XML = <location>Paris</location>;		
myXMLList = x1 + x2;

var x3:XML = <location>Springfield</location>;
myXMLList += x3;
		    
trace(myXMLList.toXMLString());

trace ifadesi şu çıktıyı üretir:

<location>Athens</location>
	
<location>Paris</location>	

<location>Springfield</location>

İlgili API Öğeleri

expression1 ? expression2 : expression3

expression1 öğesini değerlendirir ve expression1 değeri true olursa, sonuç expression2 değeri olur; aksi takdirde sonuç expression3 değeri olur.

var x:Number = 5; 
var y:Number = 10; 
var z = (x < 6) ? x: y; 
trace(z); // returns 5

var timecode:String = (new Date().getHours() < 11) ? "AM" : "PM"; 
trace(timecode); 

if (new Date().getHours() < 11) { 
	var timecode:String = "AM"; 
} else { 
	var timecode:String = "PM"; 
}
trace(timecode); 

--expression

expression--

İşlenenden 1 çıkarır. İşlenen, bir değişken, dizideki bir öğe veya bir nesne özelliği olabilir. Operatörün eksiltme öncesi formu (--expression), expression öğesinden 1 çıkarır ve sonucu döndürür. Operatörün eksiltme sonrası formu (expression--), expression öğesinden 1 çıkarır ve expression öğesinin başlangıç değerini (eksiltme öncesi değer) döndürür.

var x:Number = 3; 
var y:Number = --x; // y is equal to 2

var x:Number = 3; 
var y:Number = x--; // y is equal to 3

for (var i = 10; i > 0; i--) { 
	trace(i); 
}

 delete reference

reference tarafından belirtilen nesne özelliğini yok eder; işlem tamamlandıktan sonra özellik bulunmuyorsa true, aksi takdirde false sonucunu verir. delete operatörü, varolmayan bir özellik üzerinde veya bir sınıfta tanımlı olmayan dinamik bir özellik üzerinde çağrılırsa true değerini döndürür.

reference parametresi silinemezse, delete operatörü başarısız olup falsedeğerini döndürebilir. var ifadesiyle bildirilen sabit özellikleri veya değişkenleri silemezsiniz. Sabit özellik, bir sınıf tanımında tanımlanan bir değişken veya yöntemdir.

Bir sınıf çalışma zamanında eklenmiş dinamik bir sınıf değilse, delete operatörü o sınıfın bir özelliğini yok etmek için kullanılamaz. Mühürlü sınıfların özellikleri delete kullanılarak yok edilemez. Bunun yerine özelliği null değerine ayarlayın.

Not: Bir nesneyi silemezsiniz ancak o nesnenin tüm başvurularını kaldırarak o nesneyi çöp toplama için uygun hale getirebilirsiniz. En yaygın nesne başvurusu, o nesneyi işaret eden bir değişkendir. Değişkeni null değerine ayarlayarak bu tür bir başvuruyu kaldırabilirsiniz. Çöp toplayıcı, başvurusu olmayan nesneleri kaldırır.

// create the new object "account" 
var account:Object = new Object(); 
// assign property name to the account 
account.name = "Jon"; 
// delete the property 
delete account.name; 
trace(account.name); // undefined

// delete a nonexistent property
var fooDeleted:Boolean = delete account.foo;
trace(fooDeleted); // true

Şu örnek, bir dizi öğesinin değerini siler ancak length özelliğinin değeri değişmez:

var my_array:Array = new Array(); 
my_array[0] = "abc"; // my_array.length == 1 
my_array[1] = "def"; // my_array.length == 2 
my_array[2] = "ghi"; // my_array.length == 3 
// my_array[2] is deleted, but Array.length is not changed 
delete my_array[2]; 
trace(my_array.length); // 3 
trace(my_array); // abc,def,

Şu örnek, delete öğesinden döndürülen Boolean değerinin, gelecekteki kod çalıştırması için bir koşul olarak nasıl kullanılabileceğini gösterir. Bir öğe önceden silindiyse, o öğede tekrar delete öğesinin çağrılmasının false değerini döndüreceğini unutmayın.

var my_array:Array = [ "abc", "def", "ghi" ];
var deleteWasSuccessful:Boolean

deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[1];
deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[2];

trace(my_array) // outputs: undefined,undefined,ghi

İlgili API Öğeleri

 delete reference

reference tarafından belirtilen XML öğelerini veya niteliklerini siler.

 
var x1:XML = <x1>
				<a id = "52">AYY</a>
				<a>AYY 2 </a>
				<b>BEE</b>
				<c>CEE</c>
			</x1>;

trace(x1.toXMLString());
trace("___________");

delete x1.a.@id;

trace(x1.toXMLString());
trace("___________");

delete x1.b;

trace(x1.toXMLString());
trace("___________");

delete x1.a;

trace(x1.toXMLString());

Çıktı şudur:

<x1>
  <a id="52">AYY</a>
  <a>AYY 2</a>
  <b>BEE</b>
  <c>CEE</c>
</x1>
___________
<x1>
  <a>AYY</a>
  <a>AYY 2</a>
  <b>BEE</b>
  <c>CEE</c>
</x1>
___________
<x1>
  <a>AYY</a>
  <a>AYY 2</a>
  <c>CEE</c>
</x1>
___________
<x1>
  <c>CEE</c>
</x1>

 
var xml:XML = 
			<order>
				<item id="121">hamburger</item>
				<item id="122">fries</item>
				<item id="123">chocolate shake</item>
			</order>;
delete xml.item[1].*;
delete xml.item[1].@*;
trace(xml);

Bu örneğin çıktısı şudur:

<order>
  <tem id="121">hamburger</item>
  <item/>
  <item id="123">chocolate shake</item>
</order>

 myXML..childElement1..@attributeName 

Bir XML veya XMLList nesnesinin alt öğelerinde gezinir veya (@ operatörü ile birleştiğinde) alt öğelerin eşleşen niteliklerini bulur. Eşleşen öğelerin veya niteliklerin, XML ya da XMLList nesnesinin doğrudan alt öğeleri olması gerekmez; ağaçta düşük düzeyde de bulunabilirler (örneğin, alt alt öğe). Birden çok alt öğe veya nitelik eşleşebildiğinden, sonuç bir XMLList nesnesidir.

Döndürülen XMLList nesnesindeki düğümlerin sırası, derinlik öncelikli geçişin sonucudur. Örneğin, şunu göz önünde bulundurun:

var myXML:XML = <a>
			<b>one
				<c> 
					<b>two</b> 
				</c> 
			</b>
			<b>three</b>
		</a>;

trace(myXML..b[0].toXMLString());
trace("______________");
trace(myXML..b[1].toXMLString());
trace("______________");
trace(myXML..b[2].toXMLString());

Şu çıktı şu sonucu verir:

<b>
  one
  <c>
    <b>two</b>
  </c>
</b>
______________
<b>two</b>
______________
<b>three</b>

Ayrılmış ActionScript kelimeleriyle eşlenen adları içeren alt öğeleri döndürmek için descendant (..) operatörü yerine şu örnekteki gibi XML.descendants() operatörünü kullanın:

var xml:XML = 
<enrollees>
	<student id="239">
		<class name="Algebra" />
 		<class name="Spanish 2"/>
	</student>
	<student id="206">
		<class name="Trigonometry" />
 		<class name="Spanish 2" />
	</student>
 </enrollees>;
 trace(xml.descendants("class")); 
 

var myXML:XML = 
	<employees>
		<employee id = "42">
			<firstName>Billy</firstName>
			<lastName>Einstein</lastName>
		</employee>
		<employee id = "43">
			<firstName>Sally</firstName>
			<lastName>Shostakovich</lastName>
		</employee>
	</employees>
	
trace(myXML..firstName); 
	// <firstName>Billy</firstName>
	// <firstName>Sally</firstName>
				
trace(myXML..@id); //4243

İlgili API Öğeleri

expression1 öğesini expression2 öğesine böler. Bölme işleminin sonucu, çift kesinlikli bir kayan nokta sayısıdır.

trace(3/0);   // Infinity
trace(-3/0);  // -Infinity
trace(0/0);   // NaN

İlgili API Öğeleri

expression1 öğesine expression1&expression2 değerini atar. Örneğin, şu iki ifade eşdeğerdir:

x /= y; 
x = x / y;

var a:Number = 10; 
var b:Number = 2; 
a /= b; trace(a); // 5 

İlgili API Öğeleri

object.property_or_method

Sınıf değişkenlerine ve yöntemlerine erişir, nesne özelliklerini alır ve ayarlar, içe aktarılan paketleri veya sınıfları sınırlar.

import flash.utils.Timer;

var obj:Object = new Object();
obj.propertyA = "hello";
trace(obj.propertyA);  // hello

İlgili API Öğeleri

myXML.childElement
myXML.@attributeName 

Bir XML veya XMLList nesnesinin alt öğelerinde gezinir veya (@ operatörü ile birleştirildiğinde) bir XML veya XMLList nesnesinin niteliklerini döndürür. Birden çok alt öğe veya nitelik eşleşebildiğinden, sonuç bir XML nesnesidir.

Ayrılmış ActionScript kelimeleriyle eşleşen adları içeren öğeleri döndürmek için XML dot (.) operatörü yerine şu örnekteki gibi XML.elements() yöntemini veya XML.descendants operatörünü kullanın:

var xml:XML = 
	<student id="206">
		<class name="Trigonometry" />
		<class name="Spanish 2" />
	</student>;
trace(xml.elements("class"));
trace(xml.descendants("class")); 

var myXML:XML = 
	<employee id = "42">
		<firstName>Billy</firstName>
		<lastName>Einstein</lastName>
	</employee>;

trace(myXML.firstName); // Billy
trace(myXML.@id);       // 42

İlgili API Öğeleri

İki ifadeyi eşitlik için test eder. İfadeler eşit olursa, sonuç true olur.

İki işlenenin veri türü eşleşirse, eşitlik tanımı işlenenlerin veri türüne bağlı olur:

• Aynı değerlere sahip olmaları durumunda int, uint ve Boolean türünün değerlerinin eşit olduğu düşünülür.
• Her ikisi de NaN olmadığı sürece, eşleşen değerlere sahip sayıların eşit olduğu düşünülür.
• Her iki işlenenin de değeri null veya undefined olursa, bunların eşit olduğu düşünülür.
• Dize ifadeleri, aynı sayıda aynı karakterleri içeriyorsa eşittir.
• XML nesneleri için:
  • İşlenenlerden biri metin veya nitelik düğümüyse ve diğeri de basit bir içeriğe sahipse, her iki işlenen toString() yöntemiyle dizelere dönüştürülür ve sonuçta elde edilen dizeler eşleşirse bu işlenenlerin eşit olduğu düşünülür.
  • Aksi takdirde, yalnızca her iki nesne için de nitelikli ad, nitelik ve alt öğe özellikleri eşleşirse nesnelerin eşit olduğu düşünülür.
• XMLList nesneleri aynı sayıda özellik içeriyorsa ve özelliklerin sırası ve değerleri eşleşiyorsa, XMLList nesnelerinin eşit olduğu düşünülür.
• Namespace nesneleri için, her iki nesnenin de uri özellikleri eşleşirse değerlerin eşit olduğu düşünülür.
• QName nesneleri için, her iki nesnenin uri özellikleri eşleşirse ve localName özellikleri de eşleşirse, değerlerin eşit olduğu düşünülür.
• Nesneleri, dizileri ve işlevleri temsil eden değişkenler başvuruya göre karşılaştırılır. Bu tür değişkenler, aynı nesneyi, diziyi veya işlevi ifade ederse eşittir. İki ayrı dizi aynı sayıda öğe içerse de bu iki ayrı dizinin eşit olduğu düşünülmez.

• İşlenenin değerleri undefined ve null olduğunda, bu durumda sonuç true olur.
• Otomatik veri türü dönüştürme, String, Boolean, int, uint ve Number değerlerinin veri türlerini uyumlu türlere dönüştürdüğünde ve dönüştürülen değerler eşit olduğunda durum işlenenlerinin eşit olduğu düşünülür.
• İşlenenlerden biri basit içerik barındıran XML türünde olduğunda (hasSimpleContent() == true) ve her iki işlenen de toString() yöntemiyle dizelere dönüştürüldükten sonra sonuçta elde edilen dizeler eşleştiğinde.
• İşlenenlerden biri XMLList türünde olup şu koşullardan herhangi biri doğru olduğunda:
  • XMLList nesnesinin length özelliği 0 olur ve diğer nesne undefined olur.
  • XMLList nesnesinin length özelliği 1 olduğunda ve XMLList nesnesinin bir öğesi diğer işlenenle eşleştiğinde.

var a:String = "David"
var b:String = "David"; 
if (a == b) { 
	trace("David is David"); 
} 

var a:Number = 5; 
var b:String = "5"; 
trace(a == b); // true

var c:Number = 1; 
var d:Boolean = true; 
trace(c == d); // true
var e:Number = 0; 
var f:Boolean = false; 
trace(e == f); // true

var g:String = "true";
var h:Boolean = true;
trace(g == h); // false

var firstArray:Array = new Array("one", "two", "three"); 
var secondArray:Array = new Array("one", "two", "three"); 
trace(firstArray == secondArray); // false 
/* Arrays are only considered equal 
if the variables refer to the same array. */
var thirdArray:Array = firstArray; 
trace(firstArray == thirdArray); // true 

İlgili API Öğeleri

İki ifadeyi karşılaştırır ve expression1 öğesinin expression2 öğesinden yüksek olup olmadığını belirler; yüksek olması durumunda sonuç true olur. expression1 öğesi, expression2 öğesinden düşük veya bu öğeye eşit olursa, sonuç false olur.

Her iki işlenen de String türündeyse, işlenenler alfabetik sırayla karşılaştırılır; tüm büyük harfler küçük harflerden önce gelir. Aksi takdirde, işlenenler ilk önce sayıya dönüştürülür ve sonra karşılaştırılır.

var a:String = "first";
var b:String = "First";
trace(a > b); // true

var c:Number = 5;
var d:String = "4";
trace(c > d); // true

var e: Number = 2;
var f:Boolean = true;
trace(e > f); // true

İki ifadeyi karşılaştırır ve expression1 öğesinin expression2 öğesinden yüksek veya bu öğeye eşit mi olduğunu (true) yoksa expression1 öğesinin expression2 öğesinden düşük mü olduğunu (false) belirler.

if (new Date().getHours() >= 12) { 
	trace("good afternoon"); 
} else { 
	trace("good morning"); 
}

İlgili API Öğeleri

Bir özelliğin belirli bir nesnenin parçası olup olmadığını değerlendirir. in operatörünü kullanmak için ilk işlenen olarak özellik ismi, ikinci işlenen olarak nesne belirtin. Eğer belirttiğiniz nesne öyle bir özellik içeriyorsa sonuç true; içermiyorsa false olur.

Belirtilmiş nesne bir Array nesnesiyse, in operatörünü belirli bir dizin sayısının geçerli olup olmadığını kontrol etmek için kullanabilirsiniz. İlk işlenen olarak bir tamsayı iletirseniz, dizin, dizin sayılarının geçerli aralığındaysa sonuç true; değilse false olur.

trace("PI" in Math);         // true
trace("myProperty" in Math); // false

Şu örnek, 0, 1 ve 2 sayılarının, myArray nesnesindeki geçerli dizin sayıları olduğunu ancak 3 sayısının geçerli dizin sayısı olmadığını göstermek için in operatörünü kullanır.

public var myArray:Array = ["zero", "one", "two"];
trace(0 in myArray); // true
trace(1 in myArray); // true
trace(2 in myArray); // true
trace(3 in myArray); // false

İlgili API Öğeleri

++expression

 expression++

Bir ifadeye 1 ekler. İfade, bir değişken, dizideki bir öğe veya bir nesne özelliği olabilir. Operatörün artırma öncesi formu (++expression), expression öğesine 1 ekler ve sonucu döndürür. Operatörün artırma sonrası formu (expression++), expression öğesine 1 ekler ve expression öğesinin başlangıç değerini (ekleme öncesi değer) döndürür.

var preInc:Array = new Array(); 
var i:int = 0; 
while (i < 10) { 
    preInc.push(++i); 
} 
trace(preInc); // 1,2,3,4,5,6,7,8,9,10 

 
var postInc:Array = new Array(); 
var i:int = 0; 
while (i < 10) { 
   postInc.push(i++); 
} 
trace(postInc); // 0,1,2,3,4,5,6,7,8,9 

var i:int = 0; 
while (i++ < 5) { 
	trace("this is execution " + i); 
} 
/* output: 
   this is execution 1 
   this is execution 2 
   this is execution 3 
   this is execution 4 
   this is execution 5 
*/

Eşitlik (==) operatörünün tam tersi için test yapar. expression1 ile expression2 eşit olursa, sonuç false olur. Eşitlik (==) operatöründe olduğu gibi, eşitlik tanımı, karşılaştırılan veri türlerine bağlıdır.

İki işlenenin veri türü eşleşirse, eşitlik tanımı işlenenlerin veri türüne bağlı olur:

• Aynı değerlere sahip olmaları durumunda int, uint ve Boolean türünün değerlerinin eşit olduğu düşünülür.
• Her ikisi de NaN olmadığı sürece, eşleşen değerlere sahip sayıların eşit olduğu düşünülür.
• Her iki işlenenin de değeri null veya undefined olursa, bunların eşit olduğu düşünülür.
• Dize ifadeleri, aynı sayıda aynı karakterleri içeriyorsa eşittir.
• XML nesneleri için:
  • İşlenenlerden biri metin veya nitelik düğümüyse ve diğeri de basit bir içeriğe sahipse, her iki işlenen toString() yöntemiyle dizelere dönüştürülür ve sonuçta elde edilen dizeler eşleşirse bu işlenenlerin eşit olduğu düşünülür.
  • Aksi takdirde, yalnızca her iki nesne için de nitelikli ad, nitelik ve alt öğe özellikleri eşleşirse nesnelerin eşit olduğu düşünülür.
• XMLList nesneleri aynı sayıda özellik içeriyorsa ve özelliklerin sırası ve değerleri eşleşiyorsa, XMLList nesnelerinin eşit olduğu düşünülür.
• Namespace nesneleri için, her iki nesnenin de uri özellikleri eşleşirse değerlerin eşit olduğu düşünülür.
• QName nesneleri için, her iki nesnenin uri özellikleri eşleşirse ve localName özellikleri de eşleşirse, değerlerin eşit olduğu düşünülür.
• Nesneleri, dizileri ve işlevleri temsil eden değişkenler başvuruya göre karşılaştırılır. Bu tür değişkenler, aynı nesneyi, diziyi veya işlevi ifade ederse eşittir. İki ayrı dizi aynı sayıda öğe içerse de bu iki ayrı dizinin eşit olduğu düşünülmez.

• İşlenenin değerleri undefined ve null olduğunda, bu durumda sonuç true olur.
• Otomatik veri türü dönüştürme, String, Boolean, int, uint ve Number değerlerinin veri türlerini uyumlu türlere dönüştürdüğünde ve dönüştürülen değerler eşit olduğunda durum işlenenlerinin eşit olduğu düşünülür.
• İşlenenlerden biri basit içerik barındıran (hasSimpleContent() == true) XML türünde olduğunda ve her iki işlenen de toString() yöntemiyle dizelere dönüştürüldükten sonra ortaya çıkan dizeler eşleşir.
• İşlenenlerden biri XMLList türünde olup şu koşullardan herhangi biri doğru olduğunda:
  • XMLList nesnesinin length özelliği 0 olur ve diğer nesne undefined olur.
  • XMLList nesnesinin length özelliği 1 olduğunda ve XMLList nesnesinin bir öğesi diğer işlenenle eşleştiğinde.

trace(5 != 8); // true 
trace(5 != 5); // false 

var a:String = "David";
var b:String = "Fool";
if (a != b) { 
	trace("David is not a fool"); 
}

var a:Function = function() { trace("foo"); }; 
var b:Function = function() { trace("foo"); }; 
a(); // foo 
b(); // foo 
trace(a != b); // true 
a = b; 
a(); // foo 
b(); // foo 
trace(a != b); // false

var a:Array = [ 1, 2, 3 ]; 
var b:Array = [ 1, 2, 3 ]; 
trace(a);      // 1,2,3 
trace(b);      // 1,2,3 
trace(a != b); // true 
a = b; 
trace(a);      // 1,2,3 
trace(b);      // 1,2,3 
trace(a != b); // false

İlgili API Öğeleri

Bir ifadenin prototip zincirinin, function için prototip nesnesi içerip içermediğini değerlendirir. instanceof operatörü ECMAScript 3. sürümü ile geriye doğru uyumluluk için dahil edilmiştir ve sınıflar yerine yapıcı işlevleriyle prototip tabanlı miras kullanmayı tercih eden ileri düzey programcılar için yararlı olabilir.

Bir nesnenin belirli bir veri türünün üyesi olup olmadığını kontrol etmek için is operatörünü kullanın.

Bir sınıfın prototip zinciri o sınıfın tüm üst sınıflarını içerdiğinden, instanceof operatörü sınıflarla kullanıldığında is operatörüne benzer. Ancak arabirimler prototip zincirlerine dahil edilmez, bu nedenle arabirimlerle kullanıldığında instanceof operatörü her zaman false sonucunu verirken, nesne belirli bir arabirimi uygulayan bir sınıfa ait olduğunda, is operatörü true sonucunu verir.

Not: ActionScript is operatörü, Java instanceof operatörüne eşdeğerdir.

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof Sprite);        // true
trace(mySprite instanceof DisplayObject); // true

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof IBitmapDrawable); // false
trace(mySprite is IBitmapDrawable);         // true

İlgili API Öğeleri

Bir nesnenin, belirli bir veri türü, sınıf veya arabirimle uyumlu olup olmadığını değerlendirir. Tür karşılaştırmaları için instanceof operatörü yerine is operatörünü kullanın. Bir nesnenin arabirim uygulayıp uygulamadığını kontrol etmek için de is operatörünü kullanabilirsiniz.

import flash.display.*;
import flash.events.IEventDispatcher;

var mySprite:Sprite = new Sprite();
trace(mySprite is Sprite);           // true
trace(mySprite is DisplayObject);    // true
trace(mySprite is IEventDispatcher); // true

İlgili API Öğeleri

İki ifadeyi karşılaştırır ve expression1 öğesinin expression2 öğesinden düşük olup olmadığını belirler; düşük olması durumunda sonuç true olur. expression1 öğesi, expression2 öğesinden yüksek veya bu öğeye eşit olursa, sonuç false olur.

Her iki işlenen de String türündeyse, işlenenler alfabetik sırayla karşılaştırılır; tüm büyük harfler küçük harflerden önce gelir. Aksi takdirde, işlenenler ilk önce sayıya dönüştürülür ve sonra karşılaştırılır.

trace(5 < 10); // true 
trace(2 < 2);            // false 
trace(10 < 3);           // false 
trace("Allen" < "Jack"); // true 
trace("Jack" < "Allen"); // false 
trace("11" < "3");       // true 
trace("11" < 3);         // false (numeric comparison) 
trace("C" < "abc");      // true 
trace("A" < "a");        // true 

İki ifadeyi karşılaştırır ve expression1 öğesinin expression2 öğesinden düşük veya bu öğeye eşit olup olmadığını belirler; düşük veya eşit olması durumunda sonuç true olur. expression1 öğesi expression2 öğesinden yüksekse, sonuç false olur.

Her iki işlenen de String türündeyse, işlenenler alfabetik sırayla karşılaştırılır; tüm büyük harfler küçük harflerden önce gelir. Aksi takdirde, işlenenler ilk önce sayıya dönüştürülür ve sonra karşılaştırılır.

trace(5 <= 10); // true 
trace(2 <= 2);            // true 
trace(10 <= 3);           // false 
trace("Allen" <= "Jack"); // true 
trace("Jack" <= "Allen"); // false 
trace("11" <= "3");       // true 
trace("11" <= 3);         // false (numeric comparison) 
trace("C" <= "abc");      // true 
trace("A" <= "a");        // true 

Bir komut dosyası yorumunun başlangıcını belirtir. Yorum sınırlayıcı (//) ile satır sonu karakteri arasında görüntülenen karakterler yorum olarak yorumlanır ve yoksayılır. Bu sınırlayıcıyı tek satırlık yorumlar için kullanın; art arda birden çok satırdan oluşan yorumlar için /* ve */ sınırlayıcılarını kullanın.

// Any text following a line comment delimiter is ignored during compilation

İlgili API Öğeleri

false değerindeyse veya false değerine dönüştürülebiliyorsa expression1 öğesini, aksi takdirde expression2 öğesini döndürür. false değerine dönüştürülebilen değer örnekleri arasında 0, NaN, null ve undefined yer alır. Bir işlev çağrısını expression2 olarak kullanırsanız, expression1 öğesi false olarak değerlendirildiğinde işlev çağrılmaz.

Her iki işlenen de Boolean türünde olursa, şu tabloda gösterildiği gibi, yalnızca her iki işlenen de true değerinde olursa, sonuç true olur:

var turns:Number = 2; 
var score:Number = 77; 
if ((turns <= 3) && (score >= 75)) { 
	trace("You Win the Game!"); 
} else { 
	trace("Try Again!"); 
} 

İlgili API Öğeleri

expression1 öğesine expression1 && expression2 değerini atar. Örneğin, şu iki ifade eşdeğerdir:

x &&= y; 
x = x && y; 

var myVar:String = 'tag';
			myVar &&= "<" + myVar + "/>";
			trace (myVar); // output: <tag/>