# 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.
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://hanuce.gitbook.io/javascript-egitimi/operatorler/mantiksal-operatorler.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.