PHP Karşılaştırma Operatörleri
PHP'de eşitlik ve büyüklük karşılaştırma operatörlerini öğrenin.
PHP'de karşılaştırma operatörleri, iki değeri birbiriyle kıyaslamak ve bu kıyaslamanın sonucunda `true` (doğru) veya `false` (yanlış) boolean değerini döndürmek için kullanılır. Bu operatörler, programınızın mantıksal akışını kontrol etmek (örneğin `if` koşullarında veya döngülerde) için temel yapı taşlarıdır.
İşte PHP'deki başlıca karşılaştırma operatörleri ve örnekleri:
---
### 1. Eşitlik Operatörleri
#### `==` (Eşit mi? - Loose Equality)
* **Açıklama:** Soldaki değerin sağdaki değere eşit olup olmadığını kontrol eder. **Veri tiplerine bakılmaz.** PHP, karşılaştırma yapmadan önce farklı veri tiplerini birbirine dönüştürmeye çalışır (type juggling).
* **Döner:** Değerler eşitse `true`, değilse `false`.
```php
<?php
$a = 10;
$b = "10";
$c = 5;
$d = true;
$e = 1;
$f = 0;
$g = false;
echo "--- == (Eşit mi? - Loose Equality) ---\n";
var_dump($a == $b); // int 10 == string "10" -> true (PHP "10" u int 10'a çevirir)
var_dump($a == $c); // int 10 == int 5 -> false
var_dump($d == $e); // bool true == int 1 -> true (PHP 1'i true'ya çevirir)
var_dump($f == $g); // int 0 == bool false -> true (PHP 0'ı false'a çevirir)
var_dump("hello" == "world"); // string "hello" == string "world" -> false
?>
```
**Çıktı:**
```
--- == (Eşit mi? - Loose Equality) ---
bool(true)
bool(false)
bool(true)
bool(true)
bool(false)
```
#### `===` (Kesinlikle Eşit mi? - Strict Equality)
* **Açıklama:** Soldaki değerin sağdaki değere eşit olup olmadığını ve **veri tiplerinin de aynı olup olmadığını** kontrol eder. PHP burada type juggling yapmaz.
* **Döner:** Hem değerler hem de veri tipleri eşitse `true`, değilse `false`.
* **Not:** Genellikle `==` yerine `===` kullanmak, beklenmedik durumları ve hataları önlemek açısından daha güvenli bir yaklaşımdır.
```php
<?php
$a = 10;
$b = "10";
$c = 10;
$d = true;
$e = 1;
echo "\n--- === (Kesinlikle Eşit mi? - Strict Equality) ---\n";
var_dump($a === $b); // int 10 === string "10" -> false (Değerler aynı ama tipler farklı)
var_dump($a === $c); // int 10 === int 10 -> true (Değerler ve tipler aynı)
var_dump($d === $e); // bool true === int 1 -> false (Değer olarak aynı olsa da tipler farklı)
?>
```
**Çıktı:**
```
--- === (Kesinlikle Eşit mi? - Strict Equality) ---
bool(false)
bool(true)
bool(false)
```
---
### 2. Eşitsizlik Operatörleri
#### `!=` veya `<>` (Eşit Değil mi? - Loose Inequality)
* **Açıklama:** Soldaki değerin sağdaki değere eşit olup olmadığını kontrol eder. `==` operatörünün tam tersidir. **Veri tiplerine bakılmaz.** PHP, type juggling yapar.
* **Döner:** Değerler eşit değilse `true`, eşitse `false`.
```php
<?php
$a = 10;
$b = "10";
$c = 5;
echo "\n--- != veya <> (Eşit Değil mi? - Loose Inequality) ---\n";
var_dump($a != $b); // int 10 != string "10" -> false (Değerler eşit kabul edilir)
var_dump($a != $c); // int 10 != int 5 -> true (Değerler eşit değil)
var_dump("PHP" <> "php"); // string "PHP" <> string "php" -> true (Büyük/küçük harf farkı var)
?>
```
**Çıktı:**
```
--- != veya <> (Eşit Değil mi? - Loose Inequality) ---
bool(false)
bool(true)
bool(true)
```
#### `!==` (Kesinlikle Eşit Değil mi? - Strict Inequality)
* **Açıklama:** Soldaki değerin sağdaki değere eşit olup olmadığını VEYA veri tiplerinin aynı olup olmadığını kontrol eder. `===` operatörünün tam tersidir. **Hem değerler hem de veri tipleri farklıysa `true` döner.**
* **Döner:** Hem değerler hem de veri tipleri aynı DEĞİLSE `true`, aynıysa `false`.
```php
<?php
$a = 10;
$b = "10";
$c = 10;
echo "\n--- !== (Kesinlikle Eşit Değil mi? - Strict Inequality) ---\n";
var_dump($a !== $b); // int 10 !== string "10" -> true (Değerler aynı ama tipler farklı)
var_dump($a !== $c); // int 10 !== int 10 -> false (Değerler ve tipler aynı)
?>
```
**Çıktı:**
```
--- !== (Kesinlikle Eşit Değil mi? - Strict Inequality) ---
bool(true)
bool(false)
```
---
### 3. Büyüklük/Küçüklük Operatörleri
#### `>` (Büyük mü?)
* **Açıklama:** Soldaki değerin sağdaki değerden büyük olup olmadığını kontrol eder.
* **Döner:** Büyükse `true`, değilse `false`.
```php
<?php
$x = 10;
$y = 5;
$z = 10;
echo "\n--- > (Büyük mü?) ---\n";
var_dump($x > $y); // 10 > 5 -> true
var_dump($y > $x); // 5 > 10 -> false
var_dump($x > $z); // 10 > 10 -> false (Eşit, büyük değil)
?>
```
**Çıktı:**
```
--- > (Büyük mü?) ---
bool(true)
bool(false)
bool(false)
```
#### `<` (Küçük mü?)
* **Açıklama:** Soldaki değerin sağdaki değerden küçük olup olmadığını kontrol eder.
* **Döner:** Küçükse `true`, değilse `false`.
```php
<?php
$x = 10;
$y = 5;
$z = 10;
echo "\n--- < (Küçük mü?) ---\n";
var_dump($x < $y); // 10 < 5 -> false
var_dump($y < $x); // 5 < 10 -> true
var_dump($x < $z); // 10 < 10 -> false (Eşit, küçük değil)
?>
```
**Çıktı:**
```
--- < (Küçük mü?) ---
bool(false)
bool(true)
bool(false)
```
#### `>=` (Büyük veya Eşit mi?)
* **Açıklama:** Soldaki değerin sağdaki değerden büyük veya eşit olup olmadığını kontrol eder.
* **Döner:** Büyük veya eşitse `true`, değilse `false`.
```php
<?php
$x = 10;
$y = 5;
$z = 10;
echo "\n--- >= (Büyük veya Eşit mi?) ---\n";
var_dump($x >= $y); // 10 >= 5 -> true
var_dump($y >= $x); // 5 >= 10 -> false
var_dump($x >= $z); // 10 >= 10 -> true
?>
```
**Çıktı:**
```
--- >= (Büyük veya Eşit mi?) ---
bool(true)
bool(false)
bool(true)
```
#### `<=` (Küçük veya Eşit mi?)
* **Açıklama:** Soldaki değerin sağdaki değerden küçük veya eşit olup olmadığını kontrol eder.
* **Döner:** Küçük veya eşitse `true`, değilse `false`.
```php
<?php
$x = 10;
$y = 5;
$z = 10;
echo "\n--- <= (Küçük veya Eşit mi?) ---\n";
var_dump($x <= $y); // 10 <= 5 -> false
var_dump($y <= $x); // 5 <= 10 -> true
var_dump($x <= $z); // 10 <= 10 -> true
?>
```
**Çıktı:**
```
--- <= (Küçük veya Eşit mi?) ---
bool(false)
bool(true)
bool(true)
```
---
### 4. Spaceship Operatörü (`<=>`) - PHP 7+
* **Açıklama:** Üç yönlü karşılaştırma yapar. Soldaki değeri sağdaki değerle karşılaştırır ve üç olası sonuçtan birini döndürür:
* Soldaki değer sağdaki değerden **küçükse** `-1`
* Soldaki değer sağdaki değere **eşitse** `0`
* Soldaki değer sağdaki değerden **büyükse** `1`
* **Kullanım Alanı:** Özellikle sıralama (sorting) algoritmalarında ve üç farklı koşulu tek bir ifadeyle kontrol etmek istendiğinde çok kullanışlıdır.
```php
<?php
$a = 10;
$b = 20;
$c = 10;
echo "\n--- <=> (Spaceship Operatörü - PHP 7+) ---\n";
var_dump($a <=> $b); // 10 < 20 -> -1
var_dump($b <=> $a); // 20 > 10 -> 1
var_dump($a <=> $c); // 10 == 10 -> 0
// Dizileri sıralarken kullanımına örnek:
$sayilar = [3, 1, 4, 1, 5, 9, 2, 6];
usort($sayilar, function($x, $y) {
return $x <=> $y; // Artan sıralama
});
echo "Sıralanmış Sayılar: " . implode(", ", $sayilar) . "\n"; // Çıktı: 1, 1, 2, 3, 4, 5, 6, 9
?>
```
**Çıktı:**
```
--- <=> (Spaceship Operatörü - PHP 7+) ---
int(-1)
int(1)
int(0)
Sıralanmış Sayılar: 1, 1, 2, 3, 4, 5, 6, 9
```
---
### Özet ve Önemli İpuçları:
* **Dönüş Değeri:** Tüm karşılaştırma operatörleri en sonunda `true` veya `false` (Spaceship hariç) döndürür.
* **Gevşek (`==`, `!=`, `<>`) vs. Katı (`===`, `!==`):**
* Gevşek eşitlik/eşitsizlik operatörleri, değerleri karşılaştırırken **veri tiplerini dönüştürmeye çalışır**. Bu, bazen beklenmedik sonuçlara yol açabilir (örneğin `0 == false` veya `10 == "10"`'un `true` dönmesi).
* Katı eşitlik/eşitsizlik operatörleri, hem **değerleri hem de veri tiplerini** kontrol eder. Daha güvenilir ve tahmin edilebilir sonuçlar verir. Mümkün olduğunca katı operatörleri tercih etmelisiniz.
* **Kullanım Alanları:** Genellikle `if`, `else if`, `while` gibi kontrol yapıları ve ternary operatöründe (`? :`) kullanılırlar.
PHP'de doğru karşılaştırma operatörünü seçmek, kodunuzun doğruluğu ve güvenilirliği açısından kritik öneme sahiptir.
Son Paylaşımlar
-
Python Temelleri Genel Tekrar
14:39:24 - 13/12/2025 -
Python Performans İpuçları
14:38:59 - 13/12/2025 -
Python’da Temiz Kod Yazma
14:38:28 - 13/12/2025 -
Python Mini Proje: Sayı Tahmin Oyunu
14:37:58 - 13/12/2025 -
Python Mini Proje: Hesap Makinesi
14:37:31 - 13/12/2025