ActionScript 3.0 Operatörler III:

4)Eşitlik Operatörleri:

Eşitlik operatörleri, farklı veri değerlerini birbiri ile karşılaştırıp eşit olup olmadıklarını kontrol eder ve sonucu Boolean veri tipinde "true" veya "false" olarak döndürür. Eşitlik operatörleri, program akışı içinde genellikle "if" deyimleri ile birlikte ifadeleri karşılaştırmada kullanılır.

a)( == "Eşitlik") Operatörü:

"==" operatörü iki operand değerinin eşitliğini kontrol eder, eğer karşılaştırılan değerler kendi veri tiplerinde eşitse, sonuç "true" olarak döner, aksi halde karşılaştırma sonucu "false" olur. İki ifadenin değerleri karşılaştırılırken, bunların veri tiplerinin de birbiriyle uyumlu olması gerekir. var a:String = "Ali" var b:String = "Ali"; if (a == b) { trace("a ve b değerleri birbirine eşittir."); } else { trace("a ve b değerleri birbirine eşit değildir."); }

if (a == b) ile iki String ifade "a" ve "b" nin değerleri karşılaştırılıyor ve karşılaştırma doğru olduğu için "true" değeri döndürülerek
trace("a ve b değerleri birbirine eşittir.") komut satırı çalıştırılıyor ve çıkış olarak
"a ve b değerleri birbirine eşittir" ifadesi alınıyor.

String ifadeler karşılaştırılırken iki ifadenin de karakter sayısının ve karakter özelliklerinin aynı olup olmadığı kontrol edilir.

var sayi1:int = 12 var sayi2:int = 25 if (sayi1 == sayi2) { trace("sayi1 ve sayi2 değerleri birbirine eşittir."); } else { trace("sayi1 ve sayi2 değerleri birbirine eşit değildir."); } //sayi1 ve sayi2 değerleri birbirine eşit değildir.

"sayi1" ve "sayi2" int değişkenlerinin değerleri, if (sayi1 == sayi2) komut satırı ile karşılaştırılıyor ve karşılaştırma sonucu "false" olduğu için "else" komut satırı çalıştırılıyor ve "sayi1 ve sayi2 değerleri birbirine eşit değildir." ifadesi sonuç olarak alınıyor.

var a:int = 1; var b:Boolean = true; trace(a == b); // true var c:int = 0; var d:Boolean = false; trace(c == d); // true

Yukarıdaki örnekte ise, "a" int değeri ile "b" Boolean değerinin eşit olup olmadığı kontrol edilirken, "int" değer program sırasında otomatik olarak "Boolean" veri tipine dönüştürülerek karşılaştırılıyor. 1 "int" değerinin "Boolean" veri tipindeki karşılığı "true" olduğu için karşılaştırma sonucu "true" olarak dönüyor.

Yine "c" int değeri, "d" Boolean değeri ile karşılaştırılıyor ve önce 0 olan "c" int değeri, "Boolean" veri tipine "false" olarak otomatik olarak çevriliyor ve sonra "false" olan "d" Boolean değeri ile aynı değere sahip olduğu için karşılaştırma doğrulanarak sonuç "true" olarak alınıyor.

var a:String = "true"; var b:Boolean = true; trace(a == b); // false Yalnız burada "a" String ifade, Boolean veri tipine otomatik olarak çevrilemediğinden, "a" String ve "b" Boolean değerlerin karşılaştırmaları doğru olarak sağlanamadığı için sonuç "false" olarak alınıyor.

var dizi1:Array = new Array("pazar", "sali", "cuma"); var dizi2:Array = new Array("pazar", "sali", "cuma"); trace(dizi1 == dizi2); // false

var dizi3:Array = dizi1; trace(dizi1 == dizi3); // true

Object, array ve fonksiyonların eşitliği kontrol edilirken bunların değerleri değilde referansları bakımından eşitliği kontrol edilir. Diyelim ki iki farklı "Array" veri tipindeki değişken, aynı sayıda aynı değerlere sahipler. Bu iki değişkene eşit diyemeyiz. Yukarıdaki örnekte her ne kadar dizi1 ve dizi2 Array değişkenleri aynı sayıda aynı değerlere sahip olsalar bile, "==" eşitlik operatörü ile bu iki değişkeni eşitleyemeyiz. Dolayısı ile trace(dizi1 == dizi2) komut satırı sonucu "false" olarak döndürülür. Ancak; var dizi3:Array = dizi1; komut satırında "dizi3" Array değişkeni, referans değer olarak "dizi1" değişkeninin değerini alıyor. trace(dizi1 == dizi3); komut satırında "dizi1" ile "dizi3" değişkenlerinin eşitliğinin doğruluğu test ediliyor ve sonuç "true" olarak döndürülüyor.

var a=null; var b=undefined; trace(a==b); //true; Ayrıca "null" ve "undefined" değerlere sahip iki ifade karşılaştırılırken, karşılaştırma sonucu "true" değer döndürür.

b)( != "Eşit Değil") Operatörü:

"!=" operatörü iki operand değerlerinin eşitsizliğini kontrol eder, eğer karşılaştırılan değerler kendi veri tiplerinde eşit değilse, sonuç "true" olarak döner, aksi halde karşılaştırma sonucu "false" olur.

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

trace(5 != 8); komut satırında 5 ve 8 eşit değil deniliyor ve ifade doğru olduğu için sonuç "true" olarak döndürülür.

var a:String = "Ahmet"; var b:String = "Ayşe"; if (a != b) { trace("a ve b değişkenleri eşit değil!"); } else { trace("a ve b değişkenleri eşit!"); }

// a ve b değişkenleri eşit değil!

Yine yukarıdaki örnekte de "a" ve "b" String ifadeler eşit değil deniliyor ve ifade doğru olduğu için sonuç "true" olarak dönüyor.
trace("a ve b değişkenleri eşit değil!"); komut satırı işletilerek "a ve b değişkenleri eşit değil!" sonucu alınıyor.

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" ve "b" Array değişkenleri, aynı değer ve eleman sayısına sahip olmalarına rağmen eşit olarak kabul edilmeği için, trace(a != b); komut satırı ile "a" ve "b" eşit değildir denilerek sonuç "true" olarak döndürülüyor.

c)( === "Kesin Eşitlik") Operatörü:

"===" operatörü, karşılaştırılan iki ifadenin de, değer ve veri tipi açısından eşitliğini kontrol eder. Karşılaştırılan ifadelerin birebir aynı olup olmadığı test edilir.

var a:String = "1"; var b:Boolean = true; trace(a == b); // true trace(a === b); // false

trace(a == b) komut satırında, "a" String ifade ile "b" Boolean ifadenin eşitliğinin "true" olarak dönmesinin sebebi; "==" operatörü, ifadelerin eşitliğini kontrol ederken, "a" String 1 değerini Boolean veri tipine "true" olarak otomatikman dönüştürüp "b" Boolean veri tipi ile eşitler. trace(a === b) komut satırında ise; "a" ve "b" değişkenlerinin hem veri tipinin hem de veri değerinin aynı olup olmadığı kontrol ediliyor. "a" String ifade, "b" Boolean veri tipinden farklı olduğu için, "===" operatörü kesin eşitleme sonucunu "false" olarak döndürür.

"===" operatörü hem veri değerinin hem de veri tipinin eşitliğini kontrol ederken, "==" operatörü sadece veri değerinin eşitliğini kontrol eder.

d)( !== "Kesin Eşitlik Değil") Operatörü:

"!==" operatörü, karşılaştırılan iki ifadenin de, veri değeri ve veri tipi açısından eşitsizliğini kontrol eder.

var a:Number =1; var b:int = 1; var c:Boolean= true; trace(a !== b); //false; trace(a !== c); //true;

trace(a !== b) komut satırında "a" Number veri tipi ile " b" int veri tipinin eşitsizliği kontrol ediliyor. Ancak iki veri tipi de, sayısal veri olduğu ve değerleri aynı olduğu için "!==" kesin eşit değil operatörü, sonucu "false" olarak döndürür. trace(a !== c); komut satırınsa ise, "a" Number veri tipi ile "c" Boolean veri tipinin eşitsizliği kontrol edilirken iki veri tipi de farklı olduğu için "!==" operatörü, sonucu "true" olarak döndürür.

Bu dersin devamını ActionScript 3.0 Operatörler IV’de görebilirsiniz.