# PHP Dersleri #9: Karşılaştırma Operatörleri

Kaynak: https://webodasi.com/php-dersleri-9-karsilastirma-operatorleri/
Yazar: Uzmoon
Yayın: 2026-11-17
Güncelleme: 2026-11-17

> Bu derste PHP'de değerleri karşılaştırmak için kullanılan operatörler (==, ===, !=, !==, , =, ) açıklanmış, tür dönüşümüne bağlı davranış farkları örneklerle gösterilmiştir.

## Bu Dersin Amacı

 

PHP'de iki değerin birbiriyle nasıl kıyaslandığını, eşitlik ve büyüklük testlerinin nasıl yapıldığını ve tür duyarlı (strict) ile tür duyarsız (loose) karşılaştırmaların sonuç farklarını kavramaktır.

 

## Karşılaştırma Operatörleri Nedir?

 

Karşılaştırma operatörleri, iki değeri (operandı) birbiriyle kıyaslar ve sonucun  **mantıksal doğru (true)**  ya da  **mantıksal yanlış (false)**  olduğunu belirler. Bu operatörler koşul yapılarında (if, while vb.) karar mekanizmasının temelini oluşturur.

 

## Eşitlik ve Denklik Operatörleri

 

PHP'de eşitlik iki farklı şekilde test edilir:  *geğşek (loose)*  ve  *katı (strict)* .

 

### Gevşek Eşitlik (==)

 

`==` operatörü, değerleri karşılaştırmadan önce gerekirse  **tür dönüşümü**  yapar. Sadece değerler eşleşiyorsa `true` döner.

 

```
<?php

$sayi = 42;
$metin = "42";

var_dump($sayi == $metin); // bool(true) - Tür dönüşümü yapıldı, değerler eşit

$bool = true;
var_dump($sayi == $bool);  // bool(false) - 42 true'ya eşit değildir (1 olsaydı true olurdu)

$sayi2 = 1;
var_dump($sayi2 == $bool); // bool(true) - 1 == true dönüşümü yapılır

?>
```

 

### Katı Denklik (===)

 

`===` operatörü hem  **değer**  hem de  **veri tipi**  kontrol eder. Tür dönüşümü  **yapmaz** . İkisi de aynıysa `true` döner.

 

```
<?php

$sayi = 42;
$metin = "42";

var_dump($sayi === $metin); // bool(false) - Tip farklı (int vs string)

$sayi2 = 42;
var_dump($sayi === $sayi2); // bool(true) - Hem değer hem tip aynı

$bool = true;
var_dump(1 === $bool);      // bool(false) - int !== bool

?>
```

 

## Eşitsizlik Operatörleri

 

Eşitliğin tersine, eşit olmama durumlarını test ederler.

 

### Gevşek Eşitsizlik (!= veya <>)

 

Değerler tür dönüşümünden sonra eşit değilse `true` döner. `<>` eski bir sözdizimidir, `!=` tercih edilmelidir.

 

```
<?php

$x = 10;
$y = "10";

var_dump($x != $y);  // bool(false) - Değerler eşit (tür dönüşümü sonrası)
var_dump($x <> $y);  // bool(false) - Aynı işlem

$z = 5;
var_dump($x != $z);  // bool(true) - Değerler eşit değil

?>
```

 

### Katı Eşitsizlik (!==)

 

Değerler veya tiplerden herhangi biri farklıysa `true` döner. Tür dönüşümü yapmaz.

 

```
<?php

$a = 10;
$b = "10";

var_dump($a !== $b); // bool(true) - Tip farklı (int vs string)

$c = 10;
var_dump($a !== $c); // bool(false) - Hem değer hem tip aynı

?>
```

 

## Büyüklük ve Küçüklük Operatörleri

 

Bu operatörler sayısal veya alfabetik (string) karşılaştırma yapar. Stringlerde ASCII kodlarına göre karakter karakter karşılaştırma yapılır.

 

```
<?php

$sayi1 = 15;
$sayi2 = 20;

var_dump($sayi1 < $sayi2);  // bool(true)
var_dump($sayi1 > $sayi2);  // bool(false)
var_dump($sayi1 <= $sayi2); // bool(true)
var_dump($sayi1 >= $sayi2); // bool(false)

// String karşılaştırması
$isim1 = "Ahmet";
$isim2 = "Mehmet";

var_dump($isim1 < $isim2); // bool(true) - 'A' (65) 'M' (77) den küçüktür

?>
```

 

## Uçucu Karşılaştırma Operatörü (<=>)

 

PHP 7.0 ile gelmiştir.  **Spaceship operatörü**  olarak da bilinir. İki ifadeyi karşılaştırır ve üç olası sonucun birini döndürür:

 

- `0`: İki değer eşit
- `1`: Sol operand sağ operandten büyüktür
- `-1`: Sol operand sağ operandten küçüktür

 

Sıralama (sorting) fonksiyonlarında çok kullanışlıdır.

 

```
<?php

// Sayısal
var_dump(10 <=> 10); // int(0)
var_dump(20 <=> 10); // int(1)
var_dump(5  <=> 10); // int(-1)

// Float
var_dump(1.5 <=> 1.5); // int(0)
var_dump(1.5 <=> 2.5); // int(-1)

// String (ASCII sıralaması)
var_dump("a" <=> "a"); // int(0)
var_dump("b" <=> "a"); // int(1)
var_dump("a" <=> "b"); // int(-1)

// Pratik kullanım: usort ile sıralama
$sayilar = [3, 1, 4, 1, 5];
usort($sayilar, fn($a, $b) => $a <=> $b);
var_dump($sayilar); // [1, 1, 3, 4, 5]

?>
```

 

## Tür Dönüşümü ve Karşılaştırma Tablosu

 

Aşağıdaki tablo, `==` operatörünün farklı tiplerde nasıl davrandığını özetler. `===` operatöründe ise sadece aynı tip ve değer `true` verir.

 

| İfade | Sonuç | Açıklama |
| --- | --- | --- |
| 0 == "0" | true | String sayıya dönüştürülür |
| 0 == "" | true | Boş string 0 sayısına dönüşür |
| 0 == null | true | null 0 sayısına dönüşür |
| "" == null | true | İkisi de boş kabul edilir |
| false == "false" | false | String "false" true'ya dönüşür (boş olmayan string) |
| 0 === "0" | false | Tip farklı (int vs string) |

 

## Sık Yapılan Hatalar

 

- **== yerine === kullanmamak:** Kullanıcı girişleri (string) veritabanı ID'leri (int) ile karşılaştırıldığında beklenmedik `true` sonuçları üretebilir. Örn: `"0" == false` sonucu `true`dur.
- **Stringlerde sayısal karşılaştırma sanmak:** `"10" < "2"` ifadesi `true` döner çünkü karakter karakter (ASCII) karşılaştırma yapılır, '1' rakamı '2' rakamından küçüktür.
- **Float hassasiyet hataları:** `0.1 + 0.2 == 0.3` ifadesi `false` döner. Float karşılaştırmalarında tolerans (epsilon) kullanılmalıdır.
- **<> operatörünü kullanmak:** Bu operatör PHP 8+'de hala çalışsa da `!=` standarttır ve okunabilirliği artırır.
- **Null ve False karışıklığı:** `null == false` true, `null === false` false verir. Veritabanı sorgularında `null` kontrolü için `is_null()` veya `=== null` kullanılmalıdır.

 

## Alıştırma

 

Aşağıdaki değişkenler için hangi karşılaştırma operatörünün hangi sonucu vereceğini tahmin edin ve kodu çalıştırarak kontrol edin.

 

```
<?php

$deg1 = 0;
$deg2 = "0";
$deg3 = false;
$deg4 = null;
$deg5 = [];

// Her bir satır için sonucu yorum olarak yazın
var_dump($deg1 == $deg2);
var_dump($deg1 === $deg2);
var_dump($deg1 == $deg3);
var_dump($deg1 === $deg3);
var_dump($deg3 == $deg4);
var_dump($deg3 === $deg4);
var_dump($deg4 == $deg5);
var_dump($deg4 === $deg5);

?>
```

 

### Çözüm

 

```
<?php

$deg1 = 0;
$deg2 = "0";
$deg3 = false;
$deg4 = null;
$deg5 = [];

// 0 == "0"         -> true   (String int'e dönüşür)
// 0 === "0"        -> false  (Tip farklı: int vs string)
// 0 == false       -> true   (false 0'a dönüşür)
// 0 === false      -> false  (Tip farklı: int vs bool)
// false == null    -> true   (Her ikisi de "boş/falsy" değerlere dönüşür)
// false === null   -> false  (Tip farklı: bool vs null)
// null == []       -> false  (Boş dizi null'e eşit değildir, dizi true'dur)
// null === []      -> false  (Tip farklı)

var_dump($deg1 == $deg2);  // bool(true)
var_dump($deg1 === $deg2); // bool(false)
var_dump($deg1 == $deg3);  // bool(true)
var_dump($deg1 === $deg3); // bool(false)
var_dump($deg3 == $deg4);  // bool(true)
var_dump($deg3 === $deg4); // bool(false)
var_dump($deg4 == $deg5);  // bool(false)
var_dump($deg4 === $deg5); // bool(false)

?>
```

 

## Özet

 

- `==` ve `!=` tür dönüşümü yapar (gevşek), `===` ve `!==` yapmaz (katı).
- Katı karşılaştırma (`===`) beklenmedik hataları önler, varsayılan tercih edilmelidir.
- `<=>` operatörü üçlü sonuç (`-1, 0, 1`) vererek sıralama işlemlerini kolaylaştırır.
- String karşılaştırmaları alfabetik (ASCII) yapılır, sayısal büyüklük için her iki tarafın sayı olması gerekir.
