> For the complete documentation index, see [llms.txt](https://hanuce.gitbook.io/javascript-egitimi/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hanuce.gitbook.io/javascript-egitimi/operatorler/mantiksal-operatorler.md).
# 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.
{% hint style="info" %}
Ö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.
{% endhint %}
## 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.
{% code lineNumbers="true" %}
```javascript
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
```
{% endcode %}
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.
{% hint style="info" %}
**`|`** sembolü "*Alt-Gr + <*" kombinasyonu ile elde edilir. İki sefer yapılırsa **`||`** elde edilir.
{% endhint %}
{% code lineNumbers="true" %}
```javascript
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
```
{% endcode %}
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.
{% code lineNumbers="true" %}
```javascript
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
```
{% endcode %}
Bu operatörün çalışma mantığı şöyledir.
{% code lineNumbers="true" %}
```javascript
alert( !false ); //true
alert( !true ); //false
```
{% endcode %}
## Ö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.
{% code lineNumbers="true" %}
```javascript
alert( !undefined ); //true
alert( !null ); //true
alert( !NaN); //true
```
{% endcode %}
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.
{% code lineNumbers="true" %}
```javascript
alert( 0 || 5 && 3 ); // 3
// ilk 5 && 3 operatörü çalışır: 3
//sonra 0 || 3 operatörü çalışır: 3
```
{% endcode %}
{% code lineNumbers="true" %}
```javascript
alert( '' || 'Kırmızı' && 'Beyaz' ); // 'Beyaz'
// ilk 'Kırmızı' && 'Beyaz' operatörü çalışır: 'Beyaz'
//sonra '' || 'Beyaz' operatörü çalışır: 'Beyaz'
```
{% endcode %}
## 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:
{% code lineNumbers="true" %}
```javascript
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.
```
{% endcode %}
**`&&`** 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.