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/>

var myVar:String = 'tag';
			if (myVar != '') {
			  myVar = "<" + myVar + "/>";
			}
			trace (myVar); // output: <tag/>

İlgili API Öğeleri

Bir değişkenin veya ifadenin Boolean değerini tersine çevirir. expression öğesi, true mutlak veya dönüştürülmüş değerine sahip bir değişkense, !expression öğesinin değeri false olur. x && y ifadesi false olarak değerlendirilirse, !(x && y) ifadesi true olarak değerlendirilir.

Şu ifadeler, mantıksal NOT (!) operatörünün kullanılmasının sonucunu gösterir:

• !true öğesi false değerini döndürür.
• !false öğesi true değerini döndürür.

var happy:Boolean = false; 
if (!happy) { 
	trace("don't worry, be happy"); // don't worry, be happy 
} 

İlgili API Öğeleri

true değerindeyse veya true değerine dönüştürülebiliyorsa expression1 öğesini, aksi takdirde expression2 öğesini döndürür. Bir işlev çağrısını expression2 olarak kullanırsanız, expression1 öğesi true olarak değerlendirildiğinde işlev çağrılmaz.

Şu tabloda gösterildiği gibi, her iki işlenen de Boolean türündeyse, ifadelerin biri veya ikisi true olduğunda sonuç true olur; yalnızca her iki ifade de false olduğunda sonuç false olur:

var a:Number = 10; 
var b:Number = 250; 
var start:Boolean = false; 
if ((a > 25) || (b > 200) || (start)) { 
    trace("the logical OR test passed"); // the logical OR test passed 
} 

Şu örnek, bir işlev çağrısının ikinci işlenen olarak kullanılmasının nasıl beklenmeyen sonuçlara yol açtığını gösterir. Operatörün solundaki ifade true olarak değerlendirilirse, sağdaki ifade değerlendirilmeden (fx2() işlevi çağrılmadan) sonuç döndürülür.

function fx1():Boolean { 
	trace("fx1 called"); 
	return true; 
} 
function fx2():Boolean { 
	trace("fx2 called"); 
	return true; 
} 
if (fx1() || fx2()) { 
	trace("IF statement entered");
}

İlgili API Öğeleri

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

x ||= y; 
x = x || y; 

myVar ||= "default";

İlgili API Öğeleri

expression2 öğesine bölünen expression1 öğesinin kalanını hesaplar. İşlenenlerden herhangi biri sayısal değilse, modulo (%) operatörü bunu bir sayıya dönüştürmeye çalışır.

Modülleme sonucunun işareti, bölünenin (birinci sayı) işaretiyle eşleşir. Örneğin, -4 % 3 ve -4 % -3 öğelerinin ikisi de -1 olarak değerlendirilir.

trace(12 % 5);    // 2 
trace(4.3 % 2.1); // 0.0999999999999996 
trace(4 % 4);     // 0 

İlgili API Öğeleri

expression1 öğesine expression1 % expression2 değerini atar. Şu iki ifade eşdeğerdir:

x %= y; 
x = x % y; 

var a:Number = 14; 
var b:Number = 5; 
a %= b;
trace(a); // 4 

İlgili API Öğeleri

İki sayısal ifadeyi çarpar. Her iki ifade tam sayı olduğunda, ürün de bir tam sayıdır. İfadelerden biri veya her ikisi kayan nokta sayısı olduğunda, ürün de bir kayan nokta sayısıdır.

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

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

x *= y 
x = x * y 

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

var i:Number = 5; 
var c:Number = 4 - 6; 
var d:Number = i + 2; 
trace(c *= d); // -14 

İlgili API Öğeleri

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

Bir özellik, yöntem, XML özelliği veya XML niteliğinin ad alanını tanımlar.

public class NamespaceExample extends Sprite {
	public namespace French;
	public namespace Hawaiian;
	public function NamespaceExample() {
		trace(Hawaiian::hello()); // aloha
		trace(French::hello()); // bonjour
	}
    Hawaiian function hello():String {
        return "aloha";
    }

    French function hello():String { 
        return "bonjour";
    }
}

var soap:Namespace = new Namespace("http://schemas.xmlsoap.org/wsdl/soap/");
var w:Namespace = new Namespace("http://weather.example.org/forecast");
var myXML:XML = 
	<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"> 
	 <soap:Body>
	  <w:forecast xmlns:w="http://weather.example.org/forecast">
	   <w:city>Quito</w:city>
	   <w:country>Ecuador</w:country>
	   <date>2006-01-14</date>
	  </w:forecast>
	  </soap:Body>
	</soap:Envelope>;
	
trace(myXML.soap::Body.w::forecast.w::city); // Quito

İlgili API Öğeleri

Bir sınıf örneği başlatır. Bir sınıf örneği oluşturmak için, new operatörü bir sınıfla veya Class türünde bir değişkenle kullanılabilir. new operatörü, bir sınıf örneği oluşturmak için yaygın olarak bir sınıf nesnesiyle kullanılır. Örneğin, new Sprite() ifadesi, Sprite sınıfının bir örneğini oluşturur.

new operatörü, bir sınıfı SWF dosyasında derlenmiş görüntü, ses veya font gibi harici bir nesne olan gömülü bir varlıkla ilişkilendirmek için de kullanılabilir. Her gömülü varlık, benzersiz bir gömülü varlık sınıfıyla temsil edilir. Gömülü bir varlığa erişmek için, new operatörünü kullanarak varlığın ilişkilendirilmiş sınıfını başlatmanız gerekir. Daha sonra gömülü varlığı işlemek için gömülü varlık sınıfının uygun yöntem ve özelliklerini çağırabilirsiniz.

Sınıfları class anahtar sözcüğü yerine Function nesneleriyle tanımlamak isterseniz, yapıcı işlevlerini esas alarak nesneler oluşturmak için new operatörünü kullanabilirsiniz. Yapıcı işlevlerini, bir sınıfın yapıcı yöntemleriyle karıştırmayın. Yapıcı işlevi, function anahtar sözcüğüyle tanımlanan bir Function nesnesidir ancak bu sınıf tanımının bir parçası değildir. Nesneler oluşturmak için yapıcı işlevlerini kullanırsanız, sınıf mirası yerine prototip mirasını kullanmanız gerekir.

class Book {
  var bName:String;
  var bPrice:Number;
  
  public function Book(nameParam:String, priceParam:Number){
    bName = nameParam;
    bPrice = priceParam;
  }
}

var book1:Book = new Book("Confederacy of Dunces", 19.95);
var book2:Book = new Book("The Floating Opera", 10.95);
trace(book1); // [object Book]

var golfCourse:Array = new Array(18);

İlgili API Öğeleri

object = {name1 : value1, name2 : value2,... nameN : valueN}

Yeni bir nesne oluşturur ve belirtilen name ve value özellik çiftleri ile nesneyi başlatır. Bu operatörün kullanılması, new Object sözdiziminin kullanılması ve atama operatörü kullanılarak özellik çiftlerinin doldurulmasıyla aynıdır. Yeni oluşturulan nesnenin prototipi genel olarak Object nesnesi olarak adlandırılır.

Bu operatör ayrıca akış denetimi ifadeleriyle (for, while, if, else, switch) ve işlevleriyle ilişkilendirilmiş bitişik kod bloklarını işaretlemek için de kullanılır.

var object:Object = {}; 
var object:Object = new Object(); 

var account:Object = {name:"Adobe Systems, Inc.", address:"601 Townsend Street", city:"San Francisco", state:"California", zip:"94103", balance:"1000"}; 
for (i in account) { 
	trace("account."+i+" = "+account[i]); 
} 

var person:Object = {name:"Gina Vechio", children:["Ruby", "Chickie", "Puppa"]}; 

var person:Object = new Object(); 
person.name = "Gina Vechio"; 
person.children = new Array(); 
person.children[0] = "Ruby"; 
person.children[1] = "Chickie"; 
person.children[2] = "Puppa"; 

İlgili API Öğeleri

(expression1[, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

Bir veya birkaç parametrede gruplama işlemi yapar, ifadeleri sırasıyla değerlendirir veya bir ya da birkaç parametreyi sarar ve bunları parantezin önündeki bir işleve argümanlar olarak iletir.

Kullanım 1: Operatörlerin çalıştırılma sırasını denetler. Parantezler, normal öncelik sırasını geçersiz kılar ve parantezlerin içindeki ifadelerin öncelikli olarak değerlendirilmesini sağlar. Parantezler yuvalandığında, en içteki parantezlerin içerikleri, dıştakilerden önce değerlendirilir..

Kullanım 2: Sırayla virgüllerle ayrılmış bir ifadeler serisini değerlendirir ve son ifadenin sonucunu döndürür.

Kullanım 3: Bir veya birkaç parametreyi sarar ve bunları parantezlerin önündeki işleve iletir.

trace((2 + 3) * (4 + 5)); // 45 
trace(2 + (3 * (4 + 5))); // 29
trace(2 + (3 * 4) + 5);   // 19
trace(2 + (3 * 4) + 5);   // 19

var a:Number = 1; 
var b:Number = 2; 
function foo() { 
  a += b; 
} 
function bar() { 
  b *= 10; 
} 
trace((foo(), bar(), a + b)); // 23 

var today:Date = new Date(); 
trace(today.getFullYear()); // outputs current year 
function traceParameter(param):void { 
  trace(param); 
} 
traceParameter(2 * 2); // 4 

İlgili API Öğeleri

myXML.(expression)

XML (E4X) XML yapısı için ECMAScript'te bir ifadeyi değerlendirir. Örneğin, myXML.(lastName == "Smith") öğesi, lastName adına ve "Smith" değerine sahip XML öğelerini tanımlar. Sonuç bir XMLList nesnesidir.

var myXML:XML = 
	<employees>
		<employee id = "42">
			<firstName>Joe</firstName>
			<lastName>Smith</lastName>
		</employee>
		<employee id = "43">
			<firstName>Susan</firstName>
			<lastName>Jones</lastName>
		</employee>
		<employee id = "44">
			<firstName>Anne</firstName>
			<lastName>Smith</lastName>
		</employee>
	</employees>;
	
trace(myXML.employee.(lastName == "Smith").@id.toXMLString()); 
	// 42
	// 44
                
trace(myXML.employee.(Number(@id) > 42).@id.toXMLString()); 
	// 43
	// 44

İlgili API Öğeleri

/pattern/flags

Karakterlerden önce ve sonra kullanıldığında, karakterlerin değişmez bir değerinin olduğunu belirtir ve bir değişken, dize veya başka bir ActionScript öğesi olarak değil, normal bir ifade (RegExp) olarak değerlendirilir. Ancak, art arda iki eğik çizgi karakterinin (//) bir yorum başlangıcını belirttiğini de unutmayın.

var myRegExp:RegExp = /foo-\d+/i; 
trace(myRegExp.exec("ABC Foo-32 def.")); // Foo-32 

İlgili API Öğeleri

Eşitlik için iki ifadeyi test eder ancak otomatik veri dönüştürmesini gerçekleştirmez. Veri türleri de dahil olmak üzere her iki ifade eşit olursa, sonuç true olur.

Katı eşitlik (===) operatörü, eşitlik (==) operatörüyle üç yönden benzerlik gösterir:

• Sayılar ve Boolean değerleri değere göre karşılaştırılır ve aynı değere sahip olurlarsa bunların eşit olduğu düşünülür.
• Dize ifadeleri, aynı sayıda aynı karakterleri içeriyorsa eşittir.
• 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.

• Katı eşitlik operatörü, yalnızca sayı türleri (Number, int ve unit) için otomatik veri dönüştürme yaparken, eşitlik operatörü bütün ilkel veri türleri için otomatik veri dönüştürme yapar.
• null ve undefined karşılaştırdığında, katı eşitlik operatörü false değerini döndürür.

İlk olarak, aynı değeri içeren ilkel değerler ile ilkel nesneler arasındaki karşılaştırmalar, ActionScript 3.0'da true değerini döndürürken, önceki sürümlerde false değerini döndürür. Önceki sürümlerde, ilkel değerin veri türü Boolean, Number veya String iken, ilkel nesnenin veri türü Boolean, Number veya String değil, her zaman Object'tir. Bu farkın pratikteki etkisine örnek vermek gerekirse, şu kod, işlenenlerin veri türleri eşleşmediği için önceki ActionScript sürümlerinde false sonucunu verir ancak ActionScript 3.0'daki ilk değerler bir nesnede sarılmış olsun ya da olmasın Boolean, Number, int, uint veya String olarak yazıldığından aynı kod true değerini verir.

var num1:Number = 1;
var num2:Number = new Number(1);
trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0
			

var num1:Number = new Number(1);
var num2:Number = new Number(1);
trace(num1 == num2);  // true in ActionScript 3.0, false in ActionScript 2.0
trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0

var string1:String = "5"; 
var string2:String = "5"; 
trace(string1 == string2);  // true 
trace(string1 === string2); // true

// The equality (==) operator converts 5 to "5", but the strict equality operator does not
var string1:String = "5"; 
var num:Number = 5; 
trace(string1 == num);  // true 
trace(string1 === num); // false 

var num:Number = 1;
var bool:Boolean = true;
trace(num == bool);  // true 
trace(num === bool); // false

var num1:Number = 1;
var num2:int = 1;
var num3:uint = 1;
trace(num1 === num2); // true
trace(num1 === num3); // true

trace(null == undefined);  // true 
trace(null === undefined); // false 

İlgili API Öğeleri

Katı eşitlik (===) operatörünün tam tersi için test yapar. Katı eşitsizlik operatörü, int ve uint veri türlerinin dönüştürülmesi dışında eşitsizlik operatörüyle aynı şekilde çalışır.

expression1 ile expression2 eşit olursa ve bunların veri türleri eşitse sonuç false olur.

Katı eşitsizlik (!==) operatörü, eşitsizlik (!=) operatörüyle üç yönden benzerlik gösterir:

• Sayılar ve Boolean değerleri değere göre karşılaştırılır ve aynı değere sahip olurlarsa bunların eşit olduğu düşünülür.
• Dize ifadeleri, aynı sayıda aynı karakterleri içeriyorsa eşittir.
• 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.

• Katı eşitsizlik (!==) operatörü yalnızca number türleri, Number, int ve uint için otomatik veri dönüştürmesi yaparken, eşitsizlik (!=) eşitsizlik (!=) operatörü, tüm ilkel veri türleri için otomatik veri dönüştürmesi yapar.
• null ve undefined karşılaştırdığında, katı eşitlik (!==) operatörü true değerini döndürür.

var s1:String = "5"; 
var s2:String = "5"; 
var s3:String = "Hello"; 
var n:Number = 5; 
var b:Boolean = true; 
trace(s1 == s2);  // true 
trace(s1 == s3);  // false 
trace(s1 == n);   // true 
trace(s1 == b);   // false 
trace(s1 === s2); // true 
trace(s1 === s3); // false 
trace(s1 === n);  // false 
trace(s1 === b);  // false 
trace(s1 !== s2); // false 
trace(s1 !== s3); // true 
trace(s1 !== n);  // true 
trace(s1 !== b);  // true 

İlgili API Öğeleri

 "text" 

Karakterlerden önce veya sonra kullanıldığında, karakterlerin değişmez bir değerinin olduğunu belirtir ve bir değişken, sayısal değer veya başka bir ActionScript öğesi olarak değil, bir dize olarak değerlendirilir.

var yourGuess:String = "Prince Edward Island"; 
submit_btn.onRelease = function() { trace(yourGuess); }; 
// Prince Edward Island

İlgili API Öğeleri

-expression

 expression1 - expression2

Negatif yapma veya çıkarma için kullanılır.

Kullanım 1: Operatör, negatif yapma için kullanıldığında, sayısal bir ifadenin işaretini ters çevirir.

Kullanım 2: Operatör, çıkarma için kullanıldığında, expression1 öğesinden expression 2 öğesini çıkararak iki sayısal ifade üzerinde aritmetik bir çıkarma işlemi gerçekleştirir. Her iki ifade tam sayı olduğunda, fark da bir tam sayıdır. İfadelerden biri veya her ikisi kayan nokta sayısı olduğunda, fark da bir kayan nokta sayısıdır.

trace(-(2 + 3)); // -5 

trace(5 - 2); // 3 

Şu ifade, 3,25 kayan nokta sayısından 1,5 kayan nokta sayısını çıkarır:

trace(3.25 - 1.5); // 1.75 

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

x -= y ;
x = x - y;

Dize ifadelerinin sayıya dönüştürülmesi gerekir; aksi takdirde sonuç NaN (not a number (sayı değil)) olur.

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

var x:String = "5"; 
var y:String = "10"; 
x -= y; 
trace(x); // -5 

İlgili API Öğeleri

[modifiers] var variableName:type

function functionName():type { ... }

function functionName(parameter1:type, ..., parameterN:type) [:type]{ ... } 

Veri türü atanması için kullanılır; bu operatör değişken türünü, işlev döndürme türünü veya işlev parametre türünü belirtir. Bir değişken bildiriminde veya atamasında kullanıldığında bu operatör değişkenin türünü belirtir; bir işlev bildiriminde veya tanımında kullanıldığında bu operatör işlevin döndürme türünü belirtir; işlev tanımındaki bir işlev parametresiyle kullanıldığında bu operatör o parametre için beklenen değişken türünü belirtir.

Tür denetleme her zaman çalışma zamanında gerçekleşir. Ancak derleyici katı moduna ayarlandığında tüm türler de derleme zamanında denetlenir ve uyuşmazlık olması durumunda hatalar oluşturulur. Nokta (.) operatörü kullanılarak yapılan atama işlemleri, işlev çağrıları ve sınıf üyesi başvurusu kaldırma işlemleri sırasında uyuşmazlıklar oluşabilir.

Kullanabileceğiniz türler arasında, tanımladığınız tüm yerel nesne türleri, sınıflar ve arabirimler ile void değeri yer alır. Tanınan yerel türler Boolean, Number, int, uint ve String'dir. Tüm yerleşik sınıflar da yerel türler olarak desteklenir.

Bir veri türü atamazsanız, değişken, işlev döndürme değeri veya işlev parametresi türsüz olarak değerlendirilir, başka bir deyişle değer herhangi bir veri türünde olabilir. Amacınızın türsüz bir değer kullanmak olduğunu açıkça göstermek isterseniz, tür ek açıklaması olarak yıldız (*) karakterini kullanabilirsiniz. Yıldız karakteri, tür ek açıklaması olarak kullanıldığında, bir değişkenin, işlev döndürme türünün veya işlev parametresinin türsüz olarak bırakılmasına eşdeğerdir.

var userName:String = ""; 

function randomInt(integer:int):int { 
	return Math.round(Math.random()*integer); 
} 
trace(randomInt(8)); 

function squareRoot(val:Number):Number { 
	return Math.sqrt(val); 
} 
trace(squareRoot(121)); 

İlgili API Öğeleri

expression öğesini değerlendirir ve ifadenin veri türünü belirten bir dize döndürür. Sonuç altı olası dize değeri ile sınırlıdır: boolean, function, number, object, string ve xml. Bu operatörü kullanıcı tanımlı bir sınıf örneğine uygularsanız, sonuç object dizesi olur. typeof operatörü geriye doğru uyumluluk için dahil edilmiştir. Tür uyumluluğunu kontrol etmek için is operatörünü kullanın.

trace(typeof Array); // object
trace(typeof Date);  // object
trace(typeof 3);     // number

var a:String = "sample";
var b:String = new String("sample");
trace(typeof a); // string
trace(typeof b); // string 

İlgili API Öğeleri

Bir ifadeyi değerlendirir ve sonra ifadenin değerini atarak undefined değerini döndürür. Tanımsız değerleri test etmek için == operatörünü kullanan karşılaştırmalarda genellikle void operatörü kullanılır.

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

Bir XML değişmezindeki XML etiketini tanımlar. Kapanış etiketini tanımlamak için eğik çizgi (/) kullanın.

var x:XML = <item id= "324">cola</item>; 

İlgili API Öğeleri