# JavaScript'de karşılaştırma Operatörleri

Javascript, programlamada sıklıkla karşılaştırma işlemleri yapmak için kullanılan bir dildir. Bu işlemleri gerçekleştirmek için karşılaştırma operatörleri kullanılır. Bu yazıda, Javascript'de kullanılan karşılaştırma operatörlerinin ne olduğunu ve nasıl kullanıldığını anlatacağız.

## **Eşitlik Karşılaştırma Operatörleri**

### `==`

Bu operatör, sol ve sağ tarafındaki değerleri karşılaştırır ve herhangi bir veri türünde eşitlik kontrolü yapar. Örneğin:

```javascript
console.log(2 == 2); // true
console.log('2' == 2); // true
console.log(false == 0); // true
```

Yukarıdaki örnekte, `==` operatörü sol ve sağ taraflarındaki değerleri karşılaştırır ve sonuç olarak `true` veya `false` döndürür.

### `===`

Bu operatör, sol ve sağ tarafındaki değerleri karşılaştırır ve sadece aynı veri türünde eşitlik kontrolü yapar. Örneğin:

```javascript
console.log(2 === 2); // true
console.log('2' === 2); // false
console.log(false === 0); // false
```

Yukarıdaki örnekte, `===` operatörü sol ve sağ taraflarındaki değerleri karşılaştırır ve sonuç olarak `true` veya `false` döndürür. Bu operatör, veri türüne de dikkat eder ve sadece aynı türde olan değerlerin eşitliğini kontrol eder.

### `!=`

Bu operatör, sol ve sağ tarafındaki değerleri karşılaştırır ve herhangi bir veri türünde eşit olmayan durumları kontrol eder. Örneğin:

```javascript
console.log(2 != 3); // true
console.log('2' != 2); // false
console.log(false != 0); // false
```

Yukarıdaki örnekte, `!=` operatörü sol ve sağ taraflarındaki değerleri karşılaştırır ve sonuç olarak `true` veya `false` döndürür.

### `!==`

Bu operatör, sol ve sağ tarafındaki değerleri karşılaştırır ve sadece aynı veri türünde eşit olmayan durumları kontrol eder. Örneğin:

```javascript
console.log(2 !== 3); // true
console.log('2' !== 2); // true
console.log(false !== 0); // true
```

Yukarıdaki örnekte, `!==` operatörü sol ve sağ taraflarındaki değerleri karşılaştırır ve sonuç olarak `true` veya false döner.

## `>=` **ve** `<=` Karşılaştırma Operatörleri

Bu operatörler sayısal değerlerin büyüklük veya küçüklük durumunu kontrol eder. `>=` operatörü, solundaki sayının sağ tarafındaki sayıdan büyük veya eşit olduğu durumları kontrol eder. `<=` operatörü ise solundaki sayının sağ tarafındaki sayıdan küçük veya eşit olduğu durumları kontrol eder.

```javascript
const a = 5;
const b = 10;
const c = 5;

console.log(b >= a); // true
console.log(a >= c); // true
console.log(a <= b); // true
console.log(c <= a); // true
```

## `==` **ve** `!=` Karşılaştırma Operatörleri

`==` ve `!=` operatörleri, değerlerin eşit olup olmadığını kontrol eder. `==` operatörü, solundaki değerin sağ tarafındaki değere eşit olduğu durumları kontrol eder. `!=` operatörü ise solundaki değerin sağ tarafındaki değere eşit olmadığı durumları kontrol eder.

```javascript
const a = 5;
const b = '5';

console.log(a == b); // true
console.log(a != b); // false
```

Yukarıdaki örnekte, `a` değişkeni sayısal bir değer iken, `b` değişkeni string bir değerdir. Ancak `==` operatörü, değerlerin eşit olup olmadığını kontrol ederken, sayısal ve string değerlerin eşitliğini kontrol edebilir. Bu nedenle, `a` ve `b` değişkenleri eşittir. Ancak, `!=` operatörü değişkenlerin farklı olduğunu belirtir.

Bu durumlar da göstermektedir ki, bu operatörler sayısal verilerde kullanıldığında daha doğru sonuçlar verebilmektedir.

## `===` **ve** `!==` Karşılaştırma Operatörleri

`===` ve `!==` operatörleri de `==` ve `!=` operatörlerine benzer şekilde çalışır, ancak daha sıkı bir karşılaştırma yapar. Bu operatörler, değerlerin hem tipini hem de değerlerinin eşit olup olmadığını kontrol eder.

```javascript
const a = 5;
const b = '5';

console.log(a === b); // false
console.log(a !== b); // true
```

Yukarıdaki örnekte, `a` ve `b` değişkenleri farklı tiplerde olmasına rağmen, `===` ve `!==` operatörleri değişkenlerin tipini kontrol ettiğinden sonuçlar farklıdır.

JavaScript'te kullanılan operatörlerden biridir ve bir koşulu kontrol etmek için kullanılır. JavaScript'te, mantıksal operatörler && (ve), || (veya) ve ! (değil) olarak üç farklı şekilde kullanılabilir. Bu operatörlerin doğru kullanımı, JavaScript programlama dilinde oldukça önemlidir. Aşağıda, mantıksal operatörler hakkında daha detaylı bilgi vermek için örneklerle açıklayacağım.

## **&& (ve) Operatörü**

JavaScript'te && operatörü, iki koşulun da doğru olması durumunda true (doğru) sonucunu verir. Eğer bir koşul yanlış ise, sonuç false (yanlış) olacaktır. Aşağıdaki örneklerde && operatörünün kullanımına bir göz atalım:

```javascript
// Örnek 1
let a = 3;
let b = 5;
if (a < 4 && b > 4) {
  console.log("a 4'ten küçük ve b 4'ten büyük.");
} else {
  console.log("Koşullar sağlanmıyor.");
}
// Çıktı: Koşullar sağlanmıyor.

// Örnek 2
let c = "JavaScript";
let d = "React";
if (c === "JavaScript" && d === "React") {
  console.log("İki dil de doğru.");
} else {
  console.log("Koşullar sağlanmıyor.");
}
// Çıktı: İki dil de doğru.
```

Yukarıdaki örneklerde, && operatörü kullanılarak iki koşul bir arada kontrol ediliyor.

## **|| (veya) Operatörü**

JavaScript'te || operatörü, en az bir koşulun doğru olması durumunda true (doğru) sonucunu verir. Eğer tüm koşullar yanlış ise, sonuç false (yanlış) olacaktır. Aşağıdaki örneklerde || operatörünün kullanımına bir göz atalım:

```javascript
javascriptCopy code// Örnek 1
let e = 5;
let f = 10;
if (e > 6 || f < 5) {
  console.log("En az bir koşul doğru.");
} else {
  console.log("Koşullar sağlanmıyor.");
}
// Çıktı: En az bir koşul doğru.

// Örnek 2
let g = "React";
let h = "Angular";
if (g === "React" || h === "Vue") {
  console.log("En az bir dil doğru.");
} else {
  console.log("Koşullar sağlanmıyor.");
}
// Çıktı: En az bir dil doğru.
```

Yukarıdaki örneklerde, || operatörü kullanılarak en az bir koşulun doğru olup olmadığı kontrol ediliyor.

## **! (değil) Operatörü**

! (değil) operatörü, bir ifadenin "doğru" veya "yanlış" olduğunu tersine çevirir. Bu, özellikle koşullu ifadelerin değerlendirildiği durumlarda faydalıdır.

Örneğin, aşağıdaki kodda bir koşullu ifade kullanarak bir sayının pozitif mi yoksa negatif mi olduğunu kontrol ediyoruz:

```javascript
let isLoggedIn = true;

if (!isLoggedIn) {
  console.log("Lütfen oturum açın.");
} else {
  console.log("Hoş geldin!");
}
```

Bu kodda, `!isLoggedIn` ifadesi, `isLoggedIn` değişkeninin `true` olup olmadığını tersine çevirir. Bu nedenle, `isLoggedIn` değişkeninin `true` olduğu doğru bir şekilde belirlenecek ve ekrana "Hoş geldin!" yazdırılacaktır.

### **&& (And) Operatörü**

`&&` operatörü, iki koşulun da doğru olduğu durumlarda `true` değeri döndürür. Eğer en az bir koşul yanlışsa, operatör `false` değerini döndürür.

```javascript
const x = 5;
const y = 10;

if (x < y && x !== 0) {
  console.log("x, y'den küçük ve sıfıra eşit değil.");
}
```

Yukarıdaki örnekte, `x`'in `y`'den küçük olduğu ve aynı zamanda `0`'a eşit olmadığı durumda `console.log()` fonksiyonu çalıştırılacaktır.

### **|| (Or) Operatörü**

`||` operatörü, iki koşuldan en az birinin doğru olduğu durumlarda `true` değeri döndürür. Eğer her iki koşul da yanlışsa, operatör `false` değerini döndürür.

```javascript
const x = 5;
const y = 10;

if (x > y || x === 5) {
  console.log("x, y'den büyük veya x 5'e eşit.");
}
```

Yukarıdaki örnekte, `x`'in `y`'den büyük olduğu veya `x`'in `5`'e eşit olduğu durumda `console.log()` fonksiyonu çalıştırılacaktır.

### **! (Not) Operatörü**

`!` operatörü, bir koşulun tam tersini alır. Eğer koşul doğruysa `false` değerini, yanlışsa `true` değerini döndürür.

```javascript
const x = 5;

if (!(x > 10)) {
  console.log("x, 10'dan büyük değil.");
}
```

Yukarıdaki örnekte, `x`'in `10`'dan büyük olmadığı durumda `console.log()` fonksiyonu çalıştırılacaktır.

### **?: (Ternary) Operatörü**

`?:` operatörü, tek satırda bir if-else ifadesi oluşturmak için kullanılır. Bu operatör, üç operand alır: bir koşul, `?` işareti, `true` durumunda döndürülecek değer, `:` işareti ve `false` durumunda döndürülecek değer.

```javascript
const age = 18;
const message = age >= 18 ? "Yetişkin" : "Çocuk";

console.log(message); // "Yetişkin"
```

Yukarıdaki örnekte, `age` değişkeninin `18` veya daha büyük olduğu durumda `message` değişkeni "Yetişkin" değerini alırken, `age` değişkeni `18`'den küçük olduğu durumda "Çocuk" değerini alır.