PHP Mantıksal Operatörler

and, or, ! operatörleriyle birden fazla koşulu kontrol etmeyi öğrenin.

PHP'de `and`, `or` ve `not` operatörleri, koşulları birleştirmek veya tersine çevirmek için kullanılan mantıksal operatörlerdir. Bu operatörler, genellikle `if`, `while` gibi kontrol yapıları içinde veya boolean değerler döndüren ifadelerde kullanılırlar. PHP'de bu mantıksal işlemleri gerçekleştirmek için iki set operatör bulunur: 1. **Metinsel operatörler:** `and`, `or`, `not` 2. **Sembolik operatörler:** `&&` (and için), `||` (or için), `!` (not için) Bu iki set arasındaki en önemli fark **işlem önceliğidir**. Metinsel operatörler (`and`, `or`, `not`), sembolik karşılıklarından (`&&`, `||`, `!`) daha düşük işlem önceliğine sahiptir. Bu fark, özellikle atama (`=`) operatörüyle birlikte kullanıldığında beklenmedik sonuçlara yol açabilir. Şimdi her birine ayrıntılı olarak bakalım: --- ### 1. `and` Operatörü (ve) `and` operatörü, her iki koşul da `true` ise `true` döner, aksi takdirde `false` döner. **Karşılığı:** `&&` (çift ampersant) **Davranış:** * `true and true` -> `true` * `true and false` -> `false` * `false and true` -> `false` * `false and false` -> `false` **Önemli Fark (İşlem Önceliği):** `and` operatörü, `&&` operatörüne göre daha düşük bir işlem önceliğine sahiptir. Bu, özellikle bir atama operatörüyle (`=`) birlikte kullanıldığında önemlidir. `&&` atanmadan önce tüm mantıksal ifadeyi değerlendirirken, `and` atanmadan sonra değerlendirilebilir, bu da kafa karıştırıcı sonuçlara yol açabilir. **Örnek:** ```php <?php $a = true; $b = false; // 1. && ile kullanım (yüksek öncelik) $sonuc1 = $a && $b; // Önce ($a && $b) değerlendirilir (sonuç false), sonra $sonuc1'e atanır. var_dump($sonuc1); // bool(false) // 2. and ile kullanım (düşük öncelik) $sonuc2 = $a and $b; // Önce ($sonuc2 = $a) işlemi yapılır ($sonuc2 true olur), // sonra (true and $b) ifadesi değerlendirilir, ancak bu sonucun hiçbir yere atanmadığına dikkat edin. var_dump($sonuc2); // bool(true) - Çünkü $sonuc2'ye sadece $a'nın değeri atanmıştır. ?> ``` Yukarıdaki örnekte `and` operatörünün düşük önceliği nedeniyle `$sonuc2`'ye sadece `$a`'nın değeri atanmıştır. Bu nedenle mantıksal işlemlerde genellikle `&&` kullanmak daha güvenli ve beklendik sonuçlar verir. **Kısa Devre (Short-circuiting):** `and` (ve `&&`) operatörleri "kısa devre" özelliğine sahiptir. Eğer ilk koşul `false` ise, ikinci koşul hiç değerlendirilmez çünkü sonuç zaten `false` olacaktır. Bu, performans avantajı sağlayabilir ve yan etkileri olan fonksiyon çağrılarında önemlidir. **Genel Kullanım:** ```php <?php $yas = 25; $ehliyetVar = true; $krediSkoruYuksek = true; if ($yas >= 18 and $ehliyetVar and $krediSkoruYuksek) { echo "Araba kiralayabilir."; } else { echo "Araba kiralayamaz."; } // Çıktı: Araba kiralayabilir. (Çünkü tüm koşullar true) ?> ``` --- ### 2. `or` Operatörü (veya) `or` operatörü, koşullardan en az biri `true` ise `true` döner; her ikisi de `false` ise `false` döner. **Karşılığı:** `||` (çift dikey çizgi) **Davranış:** * `true or true` -> `true` * `true or false` -> `true` * `false or true` -> `true` * `false or false` -> `false` **Önemli Fark (İşlem Önceliği):** `or` operatörü de `||` operatörüne göre daha düşük bir işlem önceliğine sahiptir. `and`'deki benzer durum `or` için de geçerlidir. **Örnek:** ```php <?php $isAdmin = false; $isEditor = true; // 1. || ile kullanım (yüksek öncelik) $yetkiVar1 = $isAdmin || $isEditor; // Önce ($isAdmin || $isEditor) değerlendirilir (sonuç true), sonra $yetkiVar1'e atanır. var_dump($yetkiVar1); // bool(true) // 2. or ile kullanım (düşük öncelik) $yetkiVar2 = $isAdmin or $isEditor; // Önce ($yetkiVar2 = $isAdmin) işlemi yapılır ($yetkiVar2 false olur), // sonra (false or $isEditor) ifadesi değerlendirilir, ancak bu sonucun hiçbir yere atanmadığına dikkat edin. var_dump($yetkiVar2); // bool(false) - Çünkü $yetkiVar2'ye sadece $isAdmin'in değeri atanmıştır. ?> ``` Bu durumda da `or` operatörünün düşük önceliği, beklenen sonucun alınamamasına neden olmuştur. Mantıksal `OR` işlemleri için `||` kullanmak genellikle daha doğrudur. **Kısa Devre (Short-circuiting):** `or` (ve `||`) operatörleri de "kısa devre" özelliğine sahiptir. Eğer ilk koşul `true` ise, ikinci koşul hiç değerlendirilmez çünkü sonuç zaten `true` olacaktır. **Genel Kullanım:** ```php <?php $isGuest = true; $isLoggedIn = false; if ($isGuest or $isLoggedIn) { echo "Ziyaretçi veya kayıtlı kullanıcı. Hoş geldiniz!"; } else { echo "Giriş yapmanız gerekiyor."; } // Çıktı: Ziyaretçi veya kayıtlı kullanıcı. Hoş geldiniz! (Çünkü $isGuest true) ?> ``` --- ### 3. `not` Operatörü (değil) `not` operatörü, bir koşulun boolean değerini tersine çevirir. `true` ise `false`, `false` ise `true` yapar. **Karşılığı:** `!` (ünlem işareti) **Davranış:** * `not true` -> `false` * `not false` -> `true` **Önemli Fark (İşlem Önceliği):** `not` operatörü, `!` operatörüne göre daha düşük bir işlem önceliğine sahiptir. Ancak `not` genellikle bir ifadeyle birlikte kullanıldığı için bu durum `and` ve `or` kadar dramatik bir "atama sürprizi" yaratmaz. Yine de karışıklığı önlemek için `!` kullanılması tercih edilir. **Örnek:** ```php <?php $isActive = true; $isEmpty = false; // 1. ! ile kullanım (yüksek öncelik) var_dump(!$isActive); // bool(false) var_dump(!$isEmpty); // bool(true) // 2. not ile kullanım (düşük öncelik) // Genellikle parantez içinde kullanılır veya bir ifadenin parçasıdır. var_dump(not $isActive); // bool(false) var_dump(not $isEmpty); // bool(true) // Karmaşık ifadede öncelik $a = true; $b = false; var_dump(not $a or $b); // bool(false) // Önce `(not $a)` değerlendirilir (false), sonra `false or $b` (false or false) değerlendirilir. // Aynı şey `(! $a || $b)` için de geçerlidir. ?> ``` `not` operatörü, tek başına bir değişkenin değerini tersine çevirirken doğrudan bir atama sürprizi yaratmasa da, karmaşık mantıksal ifadelerde öncelik kurallarının karışmasına yol açabilir. Bu nedenle `!` operatörünü kullanmak daha net ve güvenlidir. **Genel Kullanım:** ```php <?php $isLoggedIn = false; if (not $isLoggedIn) { // Genellikle `if (!$isLoggedIn)` şeklinde yazılır. echo "Lütfen giriş yapınız."; } else { echo "Hoş geldiniz, kullanıcı!"; } // Çıktı: Lütfen giriş yapınız. ?> ``` --- ### Doğruluk Tabloları (Özet) | A | B | A `and` B / A `&&` B | A `or` B / A `||` B | `not` A / `!` A | | :---- | :---- | :------------------- | :------------------ | :-------------- | | `true` | `true` | `true` | `true` | `false` | | `true` | `false` | `false` | `true` | `false` | | `false` | `true` | `false` | `true` | `true` | | `false` | `false` | `false` | `false` | `true` | --- ### Özet ve En İyi Uygulamalar * **En Önemli Fark:** `and`, `or`, `not` operatörleri, `&&`, `||`, `!` operatörlerine göre daha **düşük işlem önceliğine** sahiptir. * **Güvenlik ve Okunabilirlik:** PHP geliştiricileri arasında, özellikle atama operatörleriyle birleştirildiğinde beklenmedik sonuçlardan kaçınmak için genellikle `&&`, `||` ve `!` sembollerinin kullanılması önerilir. Bu semboller C benzeri dillerden gelen geliştiricilere de daha tanıdık gelir. * **Parantez Kullanımı:** İşlem önceliği konusunda emin olmadığınız durumlarda veya ifadelerinizin okunabilirliğini artırmak için **parantez `()` kullanmaktan çekinmeyin**. Parantezler, operatörlerin değerlendirilme sırasını açıkça belirtmenizi sağlar. * **Kısa Devre:** Her iki set de kısa devre özelliğine sahiptir. Bu, koşullu ifadelerdeki performans ve yan etki yönetimi için önemlidir. Genel olarak, kodunuzda tutarlılık ve güvenilirlik sağlamak adına mantıksal operatörler için `&&`, `||` ve `!` sembollerini tercih etmeniz şiddetle tavsiye edilir.
Son Paylaşımlar
Kategoriler
Etiketler
#php mantıksal # php and or # php boolean