Mantıksal Operatörler

Mantıksal operatörler, ifade ettiğimiz önermeleri birbirine bağlamak için kullandığımız ve (&&), veya (||), değil (!) sembolleridir. Önermeleri genellikle karşılaştırma operatörleri ile ifade ederiz. Tipten bağımsız olarak kullanılabilir.

Önerme: Mantıksal olarak doğrulanabilir veya yanlışlanabilir ifadelerdir. Örneğin: '15 sayısı 12 sayısından büyüktür.' ifadesi önermedir.

VE Operatörü ( && )

&& sembolü ile kullanılır. İfadeler arasındaki yanlış (false) sonucunu arar. Sondan bir önceki ifadeye kadar false sonucunu arar ve false sonucunu bulduğu ifadeyi döndürür. Eğer sondan bir önceki ifadeye kadar false bulamaz ise sonuncu ifadeyi döndürür. Örnek.

let harf = 'A';
let sayi = '65';
alert(harf === 'A' && sayi === '65'); //true && true : true
alert(harf === 'A' && sayi === 65); //true && false : false
alert(harf === 'A' && sayi == 65); //true && true : true

Bu operatörün çalışma mantığı şöyledir.

//sondan bir önceki ifadeye kadar false yok ise son ifadeyi döndürür.
alert( true && true && true && true ); //true
alert( true && true && true && false ); //false

//sondan bir önceki ifadeyi kadar bulduğu ilk false ifadesini döndürür.
alert( true && true && false && true ); //false: 3.ifade ile kontrolü bıraktı.
alert( false && false && false && false ); //false: 1.ifade kontrolü bıraktı.

Bunu şu şekilde daha güzel örnekleyebiliriz. Daha önce anlattığımız üzere number tipi ele alındığında false 0 true 1 idi. Fakat 0 harici tüm değerler de yine true değeri almaktaydı. Aynı şekilde string olanlar için de hiçbir karakter içermeyen değer ('') false herhangi bir karakter içeren değer ise true idi.

alert( 5 && 4 && 3 && 2 ); // sonuç son ifade yani 2
alert( 5 && 0 && 3 && 2 ); // sonuç 2.ifade yani 0

alert( 'Ahmet' && 'Mehmet' && 'Ayşe' && 'Fatma' ); //sonuç son ifade yani Fatma
alert( 'Ahmet' && '' && 'Ayşe' && 'Fatma' ); //sonuç 2.ifade yani ''

VEYA Operatörü ( || )

|| sembolü ile kullanılır. İfadeler arasındaki doğru (true) sonucunu arar. Sondan bir önceki ifadeye kadar true sonucunun arar ve true sonucunu bulduğu ifadeyi döndürür. Eğer sondan bir önceki ifadeye kadar true bulamaz ise sonuncu ifadeyi döndürür. Örnek.

| sembolü "Alt-Gr + <" kombinasyonu ile elde edilir. İki sefer yapılırsa || elde edilir.

let harf = 'A';
let sayi = '65';
alert (harf === 'B' || sayi === '65'); //false && true : true
alert (harf === 'A' || sayi === 65); //true && false : true
alert (harf === 'B' || sayi === 65); //false && true : false

Bu operatörün çalışma mantığı şöyledir.

//sondan bir önceki ifadeye kadar true yok ise son ifadeyi döndürür.
alert( false || false || false || true ); //true
alert( false || false || false || false ); //false

//sondan bir önceki ifadeye kadar bulduğu ilk true ifadesini döndürür.
alert( false || false || true || false ); //true: 3.önerme ile kontrolü bıraktı.
alert( true || false || false || false ); //true: 1.önermede kontrolü bıraktı.

Daha iyi örnekle.

alert( 5 || 0 || 4 || 3 ); //sonuç ilk ifade yani 5
alert( 0 || 0 || 3 || 2 ); // sonuç sondan bir önceki ifade yani 3

alert( 'Ahmet' || 'Mehmet' || 'Ayşe' || 'Fatma' ); //sonuç ilk ifade yani Ahmet
alert( '' || '' || 'Ayşe' || 'Fatma' ); //sonuç sondan bir önceki ifade yani Ayşe

DEĞİL Operatörü ( ! )

! sembolü ile kullanılır. Bir ifadenin başında kullanıldığında, ifadenin kendi değerini ilk başta boolean tipine çevirir ve bu değerin tersini döndürür. false ise true, true ise false olarak sonuç döndürür.

let harf = 'A';
let bos = '';
let sayi = 12;
let sifir = 0;

alert( !harf ); //harf'in boolean değeri true, değili false
alert( !bos ); //bos'un boolean değeri false, değili true

alert( !sayi ); //sayi'nin boolean değeri true, değili false
alert( !sifir ); //sifir'ın boolean değeri false, değili true

Bu operatörün çalışma mantığı şöyledir.

alert( !false ); //true
alert( !true ); //false

Özel Değerlerin Mantıksal Karşılaştırmaları

Özel değerlerin && operatörü ile kullanımına bakalım. Sondan bir önceki ifadeye kadar undefined, NaN veya null ile karşılaşırsa kontrolü bırakır karşılaştığı değeri döndürür.

alert( true && undefined && false ); //undefined
alert( false && undefined && true ); //false (ilk bulduğu false değerini döndürür)

alert( true && null && false ); //null
alert( false && null && true ); //false (ilk bulduğu false değerini döndürür)

alert( true && NaN && false ); //NaN
alert( false && NaN && true ); //false (ilk bulduğu false değerini döndürür)

alert( null && undefined && NaN ); //null
alert( undefined && NaN && null ); //undefined
alert( NaN && null && undefined ); //NaN

Fakat veya operatörü bu değerleri görmezden gelir.

alert( true || undefined || false ); //true
alert( false || undefined || false ); //false

alert( true || null || false ); //true
alert( false || null || false ); //false

alert( true || NaN || false ); //true
alert( false || NaN || false ); //false

alert( null || undefined || NaN ); //null
alert( undefined || NaN || null ); //undefined
alert( NaN || null || undefined ); //NaN

Değil ! operatörü hepsi için true değeri döndürür.

alert( !undefined ); //true
alert( !null ); //true
alert( !NaN); //true

Bu şu anlama gelmemektedir: undefined, NaN ve null değerleri boolean olarak false değerindedir. Bu önerme yanlıştır.

Operatörlerin Öncelikleri

Karşılaştırma yaparken farklı operatörleri bir arada kullanabilirsiniz. Bu durumda ve ile veya arasında öncelik nasıl olur ? Öncelik ve operatöründedir. ve operatör işlemlerinden sonra veya operatörüne geçilir. Örnek.

alert( 0 || 5 && 3 ); // 3
// ilk 5 && 3 operatörü çalışır: 3
//sonra 0 || 3 operatörü çalışır: 3

alert( '' || 'Kırmızı' && 'Beyaz' ); // 'Beyaz'
// ilk 'Kırmızı' && 'Beyaz' operatörü çalışır: 'Beyaz'
//sonra '' || 'Beyaz' operatörü çalışır: 'Beyaz'

Kısa Devre

Mantıksal operatörlerde kısa devre; operatörlerin çalışma sırasında son ifadeyi döndüreceği durumda sondaki ifadeyi kod için kullanmaktır. Bu durum okunurluğu artıracak bir kapıdır. Şöyle ki:

let kullanici = 'admin';
let sifre = '1234';

kullanici === 'admin' && sifre === '1234' && alert('Giriş Başarılı')
//normalde mantıksal ifadelerim 2 tane idi fakat 3.ye kod ifadesi yazdım.
// 've' operatörü 2 ifadeyi test edip doğru ise son ifadeyi döndüreceği için:
// kod otomatik olarak çalışır.

&& operatörü false değeri arar. Son ifadeye kadar bulamazsa son ifadeyi döndürür. Yukarıdaki örneğe bakarsak ilk iki ifade true olduğu için doğrudan son ifadeyi döndürür. Dolayısıyla değişkenleri manipüle etmek için de kullanılabilir. Başka bir örnekle:

let sistem = 'Android';
let cihaz = null;

cihaz = sistem !== 'Windows' || sistem !== 'Linux' && 'mobil';
alert(cihaz); //mobil

&& operatörü ilk false değeri döndürür. sistem değişkeninin değeri 'Android' olduğu için ilk ifade true sonuç verir dolayısıyla && operatörü son ifadeyi döndürür. Son ifade de 'mobil' olduğu için cihaz değişkeni 'mobil' olarak atanır.

Aynısını ilk true değerini döndüren || operatörü ile yapalım.

let sistem = 'Android';
let cihaz = null;

cihaz = sistem === 'Windows' || sistem === 'Linux' || 'mobil';
alert(cihaz); //mobil

|| operatörü ilk true değeri döndürür. sistem değişkeninin değeri 'Android' olduğu için false sonuçlar verir dolayısıyla || operatörü son ifadeyi döndürür. Son ifade de 'mobil' olduğu için cihaz değişkeni 'mobil' olarak atanır.