# 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.

<pre class="language-javascript" data-line-numbers><code class="lang-javascript">//sondan bir önceki ifadeye kadar false yok ise son ifadeyi döndürür.
alert( true &#x26;&#x26; true &#x26;&#x26; true &#x26;&#x26; true ); //true
alert( true &#x26;&#x26; true &#x26;&#x26; true &#x26;&#x26; false ); //false
<strong>
</strong>//sondan bir önceki ifadeyi kadar bulduğu ilk false ifadesini döndürür.
alert( true &#x26;&#x26; true &#x26;&#x26; false &#x26;&#x26; true ); //false: 3.ifade ile kontrolü bıraktı.
alert( false &#x26;&#x26; false &#x26;&#x26; false &#x26;&#x26; false ); //false: 1.ifade kontrolü bıraktı.
</code></pre>

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.

<pre class="language-javascript" data-line-numbers><code class="lang-javascript">alert( 5 &#x26;&#x26; 4 &#x26;&#x26; 3 &#x26;&#x26; 2 ); // sonuç son ifade yani 2
alert( 5 &#x26;&#x26; 0 &#x26;&#x26; 3 &#x26;&#x26; 2 ); // sonuç 2.ifade yani 0
<strong>
</strong>alert( 'Ahmet' &#x26;&#x26; 'Mehmet' &#x26;&#x26; 'Ayşe' &#x26;&#x26; 'Fatma' ); //sonuç son ifade yani Fatma
alert( 'Ahmet' &#x26;&#x26; '' &#x26;&#x26; 'Ayşe' &#x26;&#x26; 'Fatma' ); //sonuç 2.ifade yani ''
</code></pre>

## 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.

<pre class="language-javascript" data-line-numbers><code class="lang-javascript">//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
<strong>
</strong>//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ı.
</code></pre>

Daha iyi örnekle.

<pre class="language-javascript" data-line-numbers><code class="lang-javascript">alert( 5 || 0 || 4 || 3 ); //sonuç ilk ifade yani 5
alert( 0 || 0 || 3 || 2 ); // sonuç sondan bir önceki ifade yani 3
<strong>
</strong>alert( 'Ahmet' || 'Mehmet' || 'Ayşe' || 'Fatma' ); //sonuç ilk ifade yani Ahmet
alert( '' || '' || 'Ayşe' || 'Fatma' ); //sonuç sondan bir önceki ifade yani Ayşe
</code></pre>

## 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.

<pre class="language-javascript" data-line-numbers><code class="lang-javascript">alert( true &#x26;&#x26; undefined &#x26;&#x26; false ); //undefined
alert( false &#x26;&#x26; undefined &#x26;&#x26; true ); //false (ilk bulduğu false değerini döndürür)
<strong>
</strong>alert( true &#x26;&#x26; null &#x26;&#x26; false ); //null
alert( false &#x26;&#x26; null &#x26;&#x26; true ); //false (ilk bulduğu false değerini döndürür)
<strong>
</strong>alert( true &#x26;&#x26; NaN &#x26;&#x26; false ); //NaN
alert( false &#x26;&#x26; NaN &#x26;&#x26; true ); //false (ilk bulduğu false değerini döndürür)
<strong>
</strong>alert( null &#x26;&#x26; undefined &#x26;&#x26; NaN ); //null
alert( undefined &#x26;&#x26; NaN &#x26;&#x26; null ); //undefined
alert( NaN &#x26;&#x26; null &#x26;&#x26; undefined ); //NaN
</code></pre>

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

<pre class="language-javascript" data-line-numbers><code class="lang-javascript">alert( true || undefined || false ); //true
alert( false || undefined || false ); //false
<strong>
</strong>alert( true || null || false ); //true
alert( false || null || false ); //false
<strong>
</strong>alert( true || NaN || false ); //true
alert( false || NaN || false ); //false
<strong>
</strong>alert( null || undefined || NaN ); //null
alert( undefined || NaN || null ); //undefined
alert( NaN || null || undefined ); //NaN
</code></pre>

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:

<pre class="language-javascript" data-line-numbers><code class="lang-javascript">let sistem = 'Android';
let cihaz = null;
<strong>
</strong>cihaz = sistem !== 'Windows' || sistem !== 'Linux' &#x26;&#x26; 'mobil';
alert(cihaz); //mobil
</code></pre>

**`&&`** 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.

<pre class="language-javascript" data-line-numbers><code class="lang-javascript">let sistem = 'Android';
let cihaz = null;
<strong>
</strong>cihaz = sistem === 'Windows' || sistem === 'Linux' || 'mobil';
alert(cihaz); //mobil
</code></pre>

**`||`** 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.
