JavaScript operatörleri konusuna bir önceki yazımızda kaldığımız yerden devam ediyoruz...

Aritmetik Operatörler (Arithmetic Operators)
Aritmetik operatörler işlemcilerle temsil edilen sayısal değerleri alarak(her bir literal veya değişken) matematiksel hesaplamalar gerçekleştirmek ve hesaplama işlemi sonucunda tek bir sayısal değer elde etmek için kullanılır. Standart aritmetik operatörler, toplama(+), çıkarma(-), çarpma(*) ve bölme(/) dir. Bu operatörler diğer bir çok programlama dilindeki aritmetik operatörler gibi çalışır, farklı olarak JavaScript'te bölme işlemi sonucunda elde edilen değer kayan noktalı bir sayıdır; JavaScript, C veya Java dillerinde olduğu gibi noktadan sonraki kısmı görmezden gelmez. Örneğin :

1 / 2 // JavaScript'te 0.5 değeri elde edilir
1 / 2 // Java'da 0 değeri elde edilir

JavaScript'te temel aritmetik operatörlere ek olarak aşağıdaki tabloda yer verilen operatörler de kullanılmaktadır.

Bu tabloda açıklanan arttırma ve azaltma operatörleri size yabancı gelebilir. Örneğimizi inceleyerek bu iki operatörün nasıl kullanıldığını daha iyi anlayabilirsiniz :

var x = 5, y = 10;

  x++;		  // x++ = x + 1
		  // x++ = 5 + 1
		  // x++ = 6
		  // x = 6

  x += y--;	  // x = x + y
		  // x = 6 + 10
		  // x = 16
		  // y = 9 (y--)

  x -= -(++y);	  // x = x - (-(y + 1))
		  // x = x + y + 1
		  // x = 16 + 9 + 1
		  // x = 26
		  // y = 10 (++y)

Arttırma ve azaltma operatörlerini ön ek veya son ek olarak kullanırken iki kullanım şekli arasındaki ayrıma dikkat etmeliyiz. İlkinde değişken değeri aritmetik işleme sokulmadan önce arttırılır veya eksiltilirken; ikincisinde değişken önce işleme sokulur, sonra değeri arttırılır veya eksiltilir.

Bit Düzeyinde İşlem Yapan Operatörler (Bitwise Operators)
Bit düzeyinde işlem yapan operatörler, işlemcilerini ASCII, string veya tam sayı gibi sembolik karşılıklarıyla değil de 32 bitlik düzende, sıfırlar ve birler olarak ele alır. Bütün string ve sayısal değerler bit düzeyinde binary karşılıklar bulmaktadır. Örneğin on tabanındaki 9 tam sayısı bit düzeyinde binary(ikili) 1001 olarak ifade edilir. JavaScript bit düzeyindeki operatörleri ile veri üzerinde işlem yaptıktan sonra elde edilen değerin standart sayısal karşılığını verir.

Aşağıdaki tabloda özet açıklamalarıyla beraber JavaScript'in bit düzeyinde işlem yapan operatörlerinin bir listesini bulacaksınız.

Bit Düzeyinde Mantıksal Operatörler
Kavramsal olarak bit düzeyinde mantıksal(logical) işlem yapan operatörler aşağıda belirtildiği gibi çalışır :

• İşlemciler 32-bitlik tamsayıya çevrilir ve bit serisi(sıfırlar ve birler) olarak ifade edilir.
  
  
• İki işlemcinin karşılıklı bitleri birbiriyle eşleştirilir; örneğin, birinci bitle birinci bit, ikinci bitle ikinci bit...
  
  
• Operatör, bit çiftlerinin herbirine uygulanarak sonuç bit düzeyinde yapılandırılır.

Şimdi bu çalışma prensibini bir kaç örnek üzerinde inceleyelim :

15 = 1111, 9 = 1001

İlk örneğimizde iki işlemciye(15 ve 9) bit düzeyinde VE işlemi uygulanmış; karşılıklı bitlerin her ikisinin de 1 olduğu durumlarda 1, herhangi birisinin 0 olduğu durumlarda 0 üretilmiştir. İşlem bütün bitlere sırasıyla uygulandıktan sonra elde edilen değer "1001", yani 9 sayısıdır.

İkinci örneğimizde iki işlemciye(15 ve 9) bit düzeyinde VEYA işlemi uygulanmış; karşılıklı bitlerden herhangi birinin 1 olduğu durumlarda 1 üretilmiştir (karşılıklı bitlerin her ikisi de 0 olsaydı 0 üretilecekti). İşlem bütün bitlere sırasıyla uygulandıktan sonra elde edilen değer "1111", yani 15 sayısıdır.

Üçüncü örneğimizde iki işlemciye(15 ve 9) bit düzeyinde özel VEYA işlemi uygulanmış; karşılıklı bitlerin aynı olmadığı durumlarda 1, karşılıklı bitlerin aynı olduğu durumlarda 0 üretilmiştir. İşlem bütün bitlere sırasıyla uygulandıktan sonra elde edilen değer "0110", yani 6 sayısıdır.

Son örneğimizde ise işlemciye(9) bit düzeyinde DEĞİL(bire tümleme) işlemi uygulanmış ve her bir bitinin tersi alınarak "0110", yani 6 sayısı üretilmiştir.

Bit Düzeyinde Öteleme Operatörleri
Bit düzeyinde öteleme yapan operatörler iki işlemciye ihtiyaç duyar; ilk işlemci bitleri kaydırılacak olan değerdir, ikincisi ise her bir bitin belirtilen yöne ne kadar kaydırılacağını belirtir. Kaydırma işleminin yönü kullanılan operatör ile kontrol edilmektedir.

Öteleme operatörleri, işlemcilerini 32-bitlik tam sayı tipine dönüştürür ve aynı tipte değer üretir. JavaScript'te kullanılan öteleme operatörleri, örneklerle beraber aşağıdaki tabloda açıklanmıştır.

Öteleme operatörlerini kullanırken işleme soktuğumuz değerlerin 32-bitlik tam sayılara çevrildiğini unutmamalıyız. Buna göre 9 sayısının bit karşılığı 1001 olsa da bu sayı için bellekte 32 bitlik bir alan ayrılmaktadır; yani 1001 ifadesinin solunda 28 tane sıfır biti olduğu varsayılır (4 + 28 = 32). Bit düzeyinde öteleme işlemi bir string karaktere uygulanacaksa, öncelikle karakterin sayısal karşılığı bilinmelidir. Örneğin A harfinin karakter kodu 65 tam sayısıdır.

JavaScript'te bir karakterin sayısal kod karşılığı "charCodeAt" metoduyla elde edilir. Metod kavramına yabancılık çekiyor olabilirsiniz ama telaşlanmanıza gerek yok; metodları ilerleyen bölümlerde ayrıntılı olarak ele alacağız.

Aşağıdaki örneği inceleyerek öteleme operatörleri konusuna şimdilik nokta koyalım.

  var bitleriOtelenen           = 65; // 1000001
  var otelemeMiktari            = 4;

  var solaOtelemeSonucu         = bitleriOtelenen << otelemeMiktari;
  //                            = 65 << 4
  //                            = 1040
  //                            = 10000010000
  //                            = 0000 0100 0001 0000

  var sagaOtelemeSonucu         = bitleriOtelenen >> otelemeMiktari;
  //                            = 65 >> 4
  //                            = 4
  //                            = 100 (1000001, 0001 atılır)
  //                            = 0000 0000 0000 0100

  var isaretliSagaOtelemeSonucu = -bitleriOtelenen >> otelemeMiktari;
  //                            = -65 >> 4
  //                            = -5

  //                        -65 = 1111 1111 1011 1111
  //                         -5 = 1111 1111 1111 1011 (işaret dikkate alınır)

  var isaretliSagaOtelemeSonucu = -bitleriOtelenen >>> otelemeMiktari;
  //                            = -65 >>> 4
  //                            = 268435451

  //                        -65 = 1111 1111 1011 1111 (işaret dikkate alınır)
  //                  268435451 = 1111 1111 1111 1011 (işaret biti yok)

Bir sayının bitlerini sola ötelemek, her seferinde elde edilen sayının iki katını almak demektir. Örneğimizde 65 sayısının bitleri 4 kez sola kaydırılmış ve 1040 sayısı elde edilmiştir. Yani;

65       = 0000 0000 0100 0001 (1000001)

65 << 1  = 65 * 2
         = 130
         = 0000 0000 1000 0010 (10000010)

130 << 1 = 130 * 2
         = 260
         = 0000 0001 0000 0100 (100000100)

260 << 1 = 260 * 2
         = 520
         = 0000 0010 0000 1000 (1000001000)

520 << 1 = 520 * 2
         = 1040
         = 0000 0100 0001 0000 (10000010000)

Bir sayının bitlerini sağa ötelemek ise sayının yarısını almak demektir. Örneğimizde bu işlem 65 sayısına 65 >> 4 şeklinde uygulanmış ve her seferinde elde edilen sayılar ikiyle bölünerek 4 sayısına ulaşılmıştır (65 / 2 = 32; 32 / 2 = 16; 16 / 2 = 8; 8 / 2 = 4). Ancak işaretli öteleme işlemlerinde bu kural değişir. Negatif bir sayının bit düzeyindeki karşılığını bulmak için aşağıdaki gibi bir yola başvurulabilir :

Bit karşılığı bulunacak sayı            = -65

65 sayısına en yakın 2n şeklindeki sayı = 128 (27)
128 ile 65 sayıları arasındaki fark     = 63 (128 - 65)

128 sayısının bit gösterimi             = 1000 0000
63 sayısının bit gösterimi              = 0011 1111
128 ile 63 sayılarının toplamı          = 1011 1111
                                        = -65 (İşaret biti yoksa, 191)

İşlem sonucunda elde edilen bit kodunun geri kalan 24 biti, işaretsiz sayılarda olduğu gibi 0 değil 1'dir. Örneğimizde -65 sayısının bitleri(1111 1111 1011 1111) dört kez sağa kaydırılarak -5 sayısı(1111 1111 1111 1011) elde edilmiştir. -65 sayısına aynı işlem sıfır-doldurmalı sağa kaydırma operatörüyle uygulandığında, elde edilen bit kodu bu sefer işaretsiz tam sayı kabul edilerek 268435451 sayısı üretilir.

Not : İkili sayı sistemi hakkında daha fazla bilgi için Google arama motorunda (http://www.google.com) "Binary Number System" anahtar sözcüklerini kullanarak ilgili kaynaklara ulaşabilirsiniz.

Mantıksal Operatörler (Logical Operators)
Mantıksal operatörler boolean değerlerle birlikte kullanılmaktadır. Elde edilen değerler de mantıksal olmakla beraber, && ve || operatörleri boolean olmayan değerlerle kullanıldığında, yine boolean olmayan değerler üretilebilir. Mantıksal operatörler aşağıdaki tabloda tanımlanmıştır.

Aşağıdaki örnekler && operatörünün nasıl kullanıldığını gösterir.

deger1 = true && true      // deger1 = true olur
deger2 = true && false     // deger2 = false olur
deger3 = false && true     // deger3 = false olur
deger4 = false && (3 == 4) // deger4 = false olur
deger5 = "Kedi" && "Köpek" // deger5 = "Köpek" olur;
                           // ilk ifade yanlış olmadığı için
                           // ikinci ifade alınmaktadır
deger6 = false && "Kedi"   // deger6 = false olur

Aşağıdaki örnekler || operatörünün nasıl kullanıldığını gösterir.

deger1 = true || true      // deger1 = true olur
deger2 = true || false     // deger2 = true olur
deger3 = false || true     // deger3 = true olur
deger4 = false || (3 == 4) // deger4 = false olur
deger5 = "Kedi" || "Köpek" // deger5 = "Kedi" olur
                           // ilk ifade yanlış olmadığı için
                           // ilk ifade alınmaktadır
deger6 = false || "Kedi"   // deger6 = "Kedi" olur

Aşağıdaki örnekler ! operatörünün nasıl kullanıldığını gösterir.

deger1 = !true             // deger1 = false olur
deger2 = !false            // deger2 = true olur
deger3 = !"Kedi"           // deger3 = false olur
deger4 = !(3 == 4)         // deger4 = true olur

Not : Mantıksal operatörlerle birlikte kullanılan ifadeler null, 0, boş string("") veya tanımsız(undefined) değer üretiyorsa, bu değerler yanlışa(false) dönüştürülmektedir.

FixMan