Operatörler

ÇoÄŸu operatörü okuldan hatırlarsınız. Toplama +, çarpma *, çıkarma - vs.

Bu bölümde okulda görmediğiniz aritmetiği işleyeceğiz.

Tanımlamalar: “unary”, “binary”, “operand”

Başlamadan önce terminolojiyi öğrenmekte fayda var.

• Operand operatörlerin uygulandığı(+,-,* vs.) deÄŸerlerdir. ÖrneÄŸin çarpma iÅŸlemi için 5*2 örneÄŸinden gidersek. Ä°ki tane operand vardır. Bunlardan solda olan 5 ve saÄŸ operand 2. Bunlara argüman da denebilir.

• EÄŸer tek operanddan oluÅŸursa bu operatör unary olarak adlandırılır. ÖrneÄŸin, "-" sayının iÅŸaretini deÄŸiÅŸtirir:

  let x = 1;
  
  x = -x;
  alert( x ); // -1, unary işlemi gerçekleşti

• EÄŸer operatörün iki tane operand’ı var ise buna binary operand denir. ÖrneÄŸin çıkarma iÅŸlemi aÅŸağıda bu formda bulunur.

  let x = 1, y = 3;
  alert( y - x ); // 2, iki sayının çıkarılması binary operand işlemidir.

  Åžeklen, iki operatörden konuÅŸuyoruz. unary çıkarma ( tek operand iÅŸareti deÄŸiÅŸtirir) ve binary çıkarma ( iki operatör çıkarma )

Karakter dizisi birleÅŸtirme, binary +

JavaScript’te operatörlerin özel durumlarından birisi karakter dizilerinin + iÅŸareti ile birleÅŸtirilebilmesidir.

Böylece + iÅŸaretinin amacının ötesinde bir iÅŸlem yapabildiÄŸinin farkına varmış olmalısınız.

Normalde + iki sayıyı toplamaya yaparken eÄŸer bir taraf karakter dizisi ise bu durumda birleÅŸtirmeye yarar.

let s = "my" + "string";
alert(s); // mystring

Dikkat edin eğer iki operand’dan birisi karakter dizisi ise diğeri ne olursan olsun karakter dizisine çevrilir.

Örneğin:

alert( '1' + 2 ); // "12"
alert( 2 + '1' ); // "21"

Gördüğünüz gibi, ilk operand veya ikinci operandın karakter dizisi olması bir şeyi değiştirmiyor. Kural basit, her iki taraftan birisi karakter dizisi ise diğerini de karakter dizisine çevir ve birleştir.

Yani "+" iÅŸlemi hem birleÅŸtirme hem de tip deÄŸiÅŸtirme yapmaktadır. Bu sadece "+" operatörüne has bir olaydır.

Örneğin çıkarma ve çarpmanın davranışı farklıdır:

alert( 2 - '1' ); // 1
alert( '6' / '2' ); // 3

Sayısal değer dönüştürme, unary +

+ iki formda bulunur. Yukarıda kullandığımız binary form(iki tane operand olma olayı) veya unary form(tek operand olması).

EÄŸer unary + veya tek bir deÄŸerle kullanılan + iÅŸareti sayılar ile bir ÅŸey yapmaz. Fakat eÄŸer bu bir sayı deÄŸilse sayıya çevrilir.

Örneğin:

// Sayılara bir etkisi yoktur
let x = 1;
alert( +x ); // 1

let y = -2;
alert( +y ); // -2

// Sayı olmayan değerleri çevirir
alert( +true ); // 1
alert( +"" );   // 0

Aslında Number(...) iÅŸlemini yapar. Fakat daha kısa biçimyle.

Karakter dizilerini sayılara çevirme gerekliliği sıklıkla önünüze gelir. Örneğin HTML form değerlerini alırken sadece karakter dizisi kullanır. Fakat ya siz bunları toplamak istiyorsanız ?

BildiÄŸiniz gibi iki karakter dizisini + iÅŸareti ile toplarsanız birleÅŸtirme iÅŸlemi yapar:

let elma = "2";
let portakal = "3";

alert( elma + portakal ); // "23",  binary toplama iki karakter dizisini birleÅŸtiriyor

Eğer sayı olarak kullanmak istiyorsanız, önce dönüştürme işlemini yapıp sonra toplayabilirsiniz.

let elma = "2";
let portakal = "3";

// her iki değer de binary toplama işleminden önce sayıya çevrilmişlerdi
alert( +elma + +portakal ); // 5

// Daha uzun bi şekilde bu işlemi yapmak istiyorsanız
// alert( Number(apples) + Number(oranges) ); // 5

// ÅŸeklinde yapabilirsiniz.

Olaya bir matematikçi gözünden bakarsanız + kullanımı garip gelebilir. Fakat bir programcının gözünden özel bir olay yok aslında: operand’ı bir tane olan(unary) toplama iÅŸlemi önce uygulanıyor ve karakter dizisini sayıya çeviriyor. Daha sonra iki tane operand’lı ( binary) toplama iÅŸlemi bunları topluyor.

Neden önce “unary” işlemi gerçekleşiyor da “binary” işlemi gerçekleşmiyor? Buna yüksek öncelik diyebiliriz.

Operatör Öncelikleri

Eğer bir ifade birden fazla operatör içeriyorsa. Bu ifade çalıştırılırken tanımlı önceliklere göre çalıştırılır, bir başka ifade ile öncelik sırasına göre çalıştırılır.

Okuldan hepinizin hatırlayacağı gibi çarpma iÅŸlemi toplamadan önce yapılır 1 + 2 * 2. Aslında öncelik tam olarakta budur. Çarpma iÅŸlemi toplama iÅŸleminden daha yüksek önceliÄŸe sahiptir.

Parantez, bu öncelikleri çiÄŸner ve eÄŸer bu önceliklerden memnun deÄŸilseniz bunları tekrar tanımlamanıza olanak verir. ÖrneÄŸin (1 + 2 ) * 2

JavaScript dilinde birçok operatör vardır. Her operatörün de bir önceliği. Yüksek öncelik sayısına sahip operatör önce çalışır. Eğer öncelik değerleri eşit ise soldan sağa doğru çalışır.

öncelik tablosu ( Ezberlemenize gerek yok sadece unary operatörlerin binary olanlara göre daha üstün olduÄŸunu hatırlayın yeter). Yani +elma + +portakal iÅŸleminde önce unary ile elma’nın deÄŸerini sayı yapar sonra portakal’ın deÄŸerini sayı yapar ve en sonunda toplar.

GörüleceÄŸi üzere “unary toplama” 16 ile normal toplama iÅŸlemi(binary toplama) 13 ün öncesindedir.

Atama

Atama operatörü = dir. Öncelik sırasında en altlarda yer almaktadır. Böylece x = 2 * 2 + 1 ifadesi çalıştığında önce tüm iÅŸlemler yapılır ardından “=” çalıştırılarak sonuç x içerisinde tutulur.

let x = 2 * 2 + 1;

alert( x ); // 5

Zincirleme atama yapmak şu şekilde mümkündür:

let a, b, c;

a = b = c = 2 + 2;

alert( a ); // 4
alert( b ); // 4
alert( c ); // 4

Zincirleme atama saÄŸdan sola doÄŸru olur. Önce en saÄŸdaki deÄŸiÅŸkene deÄŸer atanır. 2+2 deÄŸeri önce c’ye ardından b ve son olarak da a’ya atanır. En sonunda tüm deÄŸiÅŸkenler tek bir deÄŸeri alırlar.

let a = 1;
let b = 2;

let c = 3 - (a = b + 1);

alert( a ); // 3
alert( c ); // 0

Kalan: %

Kalan % operatörü yüzde ile alakası olmayan bir operatördür.

a % b a’nın b’ye bölümünden kalan deÄŸeri verir.

Örneğin:

alert( 5 % 2 ); // 5'in 2 ile bölümünden kalan 1'dir.
alert( 8 % 3 ); // 8'in 3 ile bölümünden kalan 2'dir.
alert( 6 % 3 ); // 6'nın 3 ile bölümünden kalan 0'dır.

Ãœs alma **

Üs alma operatörü JavaScript diline sonradan eklenen bir operatördür.

DoÄŸal sayı olan b deÄŸeri için a ** b a’nın b defa kendisiyle çarpılması demektir.

Örneğin:

alert( 2 ** 2 ); // 4  (2 * 2)
alert( 2 ** 3 ); // 8  (2 * 2 * 2)
alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2)

Integer olmayan değerler için de aynı işlemi yapmak mümkün örneğin:

alert( 4 ** (1/2) ); // 2 ( 1/2 üstü karekökü anlamına da gelir.)
alert( 8 ** (1/3) ); // 2 (1/3 üstü ise küp kök anlamına gelir. )

Artırma/Azaltma

Bir sayıyı artırmak veya azlatmak sayısal operasyonlarda önemli sayılabilecek bir düzeydedir.

Bunun için özel bir operatör yapılmıştır:

• Artırma ++ deÄŸiÅŸkenin deÄŸerini 1 artırır:

  let sayac = 2;
  sayac++;      // sayac =  sayac + 1 ile aynı, fakat daha kısa
  alert( sayac ); // 3

• Azaltma -- deÄŸiÅŸkenin deÄŸerini bir azaltır:

  let sayac = 2;
  sayac--;      //  sayac =  sayac - 1 ile aynı, fakat daha kısa
  alert( sayac ); // 1

++ ve -- operatörleri deÄŸiÅŸkenden önce veya sonra kullanılabilirler.

• Operatör deÄŸiÅŸkenden sonra geliyorsa ona “postfix form” deriz: counter++.
• “prefix form” ise opeatörün deÄŸiÅŸkenden önce geldiÄŸi durumdur: ++counter.

Bu iki durumda da aynı iÅŸlem yapılır: counter deÄŸiÅŸkeni 1 arttırılır.

Peki bir farkları var mı? Evet, fakat bunu ++/-- iÅŸleminden dönen deÄŸerleri kullanırsak görebiliriz.

Şöyle açıklayabiliriz. Bildiğimiz üzere tüm operatörler bir değer döndürür. arttırma/azaltma opeatörleri buna bir istisna değildir. Prefix formu oluşan yeni değeri döndürürken, postfix formu eski değeri(arttırma/azaltma işlemi yapılmadan önceki) döndürür.

Farkı görebilmemiz için örneği inceleyelim:

let counter = 1;
let a = ++counter; // (*)

alert(a); // 2

(*) satırında prefix formundaki ++counter counter deÄŸiÅŸkenini arttırır ve yeni deÄŸer olan 2 yi döndürür. Yani alert bize 2 deÄŸerini gösterecektir.

Şimdi de postfix kullanıma bakalım:

let counter = 1;
let a = counter++; // (*) changed ++counter to counter++

alert(a); // 1

(*) satırında postfix formundaki ++counter de aynı ÅŸekilde counter deÄŸiÅŸkenini arttırır fakat bu sefer deÄŸiÅŸkenin eski deÄŸerini(arttırma iÅŸlemi yapılmadan önceki) deÄŸerini döndürür. Yani alert bize 1 deÄŸerini gösterecektir.

Özetle:

• EÄŸer arttırma/azaltma iÅŸleminin sonucunu kullanmıyorsak hangi formu kullandığımızın bir farkı olmaz:

  let counter = 0;
  counter++;
  ++counter;
  alert( counter ); // 2, iki satır da aynı işlemi yaptı.

• EÄŸer bir deÄŸeri arttıracak ve onu aynı anda(o iÅŸlem sırasında) kullanacaksak, prefix formunu kullanmamız gerekir:

  let counter = 0;
  alert( ++counter ); // 1

• EÄŸer arttırma yapacak fakat arttırma yapmadan yapmadan önceki deÄŸeri kullanacaksak, postfix formunu kullanmamız gerekir:

  let counter = 0;
  alert( counter++ ); // 0

let counter = 1;
alert( 2 * ++counter ); // 4

let counter = 1;
alert( 2 * counter++ ); // 2, çünkü counter++ "eski" değeri döndürecektir

let counter = 1;
alert( 2 * counter );
counter++;

Bitsel(Bitwise) Operatörler

Bitsel operatörler argümanlara 32-bitlik doğal sayı gibi davranır ve ikili gösterimleri düzeyinde çalışır.

Bu operatörler JavaScript’e özgü değildir. Çoğu programlama dilinde bulunurlar.

Operatörlerin listesi:

• AND – VE ( & )
• OR – VEYA ( | )
• XOR – ÖZEL VEYA ( ^ )
• NOT – DEĞİL ( ~ )
• LEFT SHIFT – SOLA KAYDIRMA ( << )
• RIGHT SHIFT – SAÄž KAYDIRMA ( >> )
• ZERO-FILL RIGHT SHIFT – SIFIR DOLDURARAK SAÄž KAYDIRMA ( >>> )

Bu oparatörler çok nadir kullanılır. Onları anlamak için düşük seviyeli sayı temsiline girmemiz gerekiyor ve özellikle de yakın zamanda onlara ihtiyaç duymayacağımızdan şu anda bunu yapmak uygun olmayacaktır. Merak ediyorsanız, MDN ile ilgili Bitwise Operators makalesini okuyabilirsiniz. Gerçekten ihtiyacınız olduğunda bunu yapmak daha doğru olacaktır.

Modify-in-place (Yerinde DeÄŸiÅŸtir)

Bazen bir değişken üzerinde bir operatör işlemi yaparız ve yeni oluşacak değerini aynı değişkende tutmak isteriz.

Örneğin:

let n = 2;
n = n + 5;
n = n * 2;

Bu iÅŸlemler += ve *= kullanılarak kısaltılabilir:

let n = 2;
n += 5; // şu an n = 7 (n = n + 5 ile aynı)
n *= 2; // şu an n = 14 (n = n * 2 ile aynı)

alert( n ); // 14

Kısa olan “modify-and-assign” operatörleri tüm aritmetik ve bitsel operatörler için mevcuttur: /=, -=, vb.

Bu tür operatörler normal bir atama(assignment) ile aynı önceliğe sahiptir, bu yüzden diğer birçok hesaplamalardan sonra çalışırlar.

let n = 2;

n *= 3 + 5;

alert( n ); // 16  (önce sağ kısımda işlem yapıldı, n *= 8 gibi)

Virgül

Virgül operatörü , nadir ve en alışılmadık operatörlerden birisidir. Bazen daha kısa kodlar yazmak için kullanılır. Bu yüzden neler olduÄŸunu anlamak için bu operatörü de bilmemiz gerekiyor.

Virgül operatörü birden fazla ifadeyi virgül , ile ayırarak hesaplamamıza olanak saÄŸlar. Her bir ifade iÅŸleme alınır fakat bu ifadelerden sadece sonuncusu döndürülür.

Örneğin:

let a = (1 + 2, 3 + 4);

alert( a ); // 7 (3 + 4 iÅŸleminin sonucu)

Burada, ilk ifade olan 1 + 2 iÅŸleme giriyor fakat sonucu çöpe atılıyor. Sonrasında gelen 3 + 4 iÅŸleme giriyor ve sonuç olarak geri döndürülüyor.

Peki neden son kısım hariç her şeyi yok sayan bir operatöre ihtiyacımız var?

Bazen bizler; bir satırda birkaç işlem yapılan karmaşık yapılarda bu operatörü kullanırız.

Örneğin:

// Bir satırda 3 farklı işlem
for (a = 1, b = 3, c = a * b; a < 10; a++) {
 ...
}

Bu tarz numaralar birçok JavaScript frameworklerinde kullanılır. Bu yüzden bunlardan bahsettik. Ama genelde bunlar kodun okunabilirliğini azaltıyorlar. Bu yüzden kullanmadan önce iyi düşünmek gerekir.