PHP/Operatörler
Bir veya birden fazla değer arasında gerçekleştirilecek işlemleri temsil eden simge ya da sözcüklere operatör veya işleç denir. Örneğin matematikte kullandığımız + (artı), - (eksi), * (çarpı), / (bölü) gibi semboller PHP'de birer operatördür. Aynı şekilde mantıksal (bkz: Sembolik mantık) işlemlerde kullanılan && ile and ve || ile veya sembol ve sözcükleri de birer operatördür. Bunların dışında, başka görevler üstlenen operatörler de vardır. Operatörlerle işleme sokulan ifadelere operand denir.
Matematikte olduğu gibi operatörlerin de farklı öncelik değerleri vardır.
<?php
echo 2 + 4 * 5; // 22
?>
Yukarıdaki işlem sonucu echo ile çıktılanacak değer 22 olacaktır. Çünkü çarpma işlemi, toplamaya göre yüksek önceliklidir. Yani önce çarpma işlemi, sonra toplama işlemi yapılır. Ancak işlem önceliğine müdahale etmek de mümkündür.
<?php
echo (2 + 4) * 5; // 30
?>
Bu durumda echo ile çıktılanacak değer 30 olacaktır çünkü toplama işlemi parantezler ile önceliğe alınmıştır. Burada olduğu gibi parantezler işlem önceliğini düzenlemek adına kullanılabilir.
Matematikte olduğu gibi PHP operatörlerinin de kendi aralarında işlem öncelikleri vardır. Aşağıdaki tablo, operatörlerin işlem öncelikleri hakkında bilgi veriyor. Bu tablo, mevcut bilgilerimizle şu an için bir şey ifade etmiyor olabilir ancak tüm operatörlerin açıklamaları okunduktan sonra dönüp bakıldığında daha iyi anlaşılacaktır.
İşlem önceliği
[değiştir]Operatörler, en yüksek öncelikliden en düşük öncelikliye doğru işlem yönleriyle sıralanmıştır.
| Operatör | İşlem yönü | Şuna ilişkin |
|---|---|---|
| clone new | yönsüz | clone ve new |
| [ | soldan | array |
| ++ -- | yönsüz | artırma ve eksiltme |
| ~ - (int) (float) (string) (array) (object) (bool) @ | sağdan | veri türleri |
| instanceof | yönsüz | veri türleri |
| ! | sağdan | mantıksal |
| * / % | soldan | aritmetik |
| + - . | soldan | aritmetik ve string |
| << >> | soldan | bitsel |
| < <= > >= <> | yönsüz | karşılaştırma |
| == != === !== | yönsüz | karşılaştırma |
| & | soldan | bitsel ve gönderim |
| ^ | soldan | bitsel |
| | | soldan | bitsel |
| && | soldan | mantıksal |
| || | soldan | mantıksal |
| ? : | soldan | üç terimli |
| = += -= *= /= .= %= &= |= ^= <<= >>= => | sağdan | atama |
| and | soldan | mantıksal |
| xor | soldan | mantıksal |
| or | soldan | mantıksal |
| , | soldan | çeşitli |
Aritmetik operatörler
[değiştir]| İşlem | İsim | Sonuç |
|---|---|---|
| $a + $b | toplama | $a ile $b'nin toplamı |
| $a - $b | çıkarma | $a'nın $b'den farkı |
| $a * $b | çarpma | $a ile $b'nin çarpımı |
| $a / $b | bölme | $a'nın $b'ye bölümü |
| $a % $b | mod | $a'nın $b'ye bölümünden kalan |
| -$a | olumsuzlama | $a'nın toplamaya göre tersi |
<?php
echo 3 * 8; // 24
echo 3 + 2 * 4; // 11
echo (3 + 2) * 4; // 20
echo ((5 * 6) / 2) * (45 / 9) % 5; // 0
?>
Bölme işleminden dönen değer, operandlar tam bölünüyorsa integer; aksi durumda daima float türündedir. Integer değer elde etmek için dönen değerde tür çarpıtma veya yuvarlama uygulanmalıdır.
Kalan bulma ( % ) işleminde her iki operand float türünde olsa bile dönen değer integer olur.
<?php
echo 34.4 % 12.8; // 10
echo 34 % 12; // 10
?>
Kalan bulma ( % ) işleminde bölünen görevindeki operand negatif ise kalan da negatif olur.
<?php
echo -34 % 12; // -10
echo 34 % -12 // 10 bölenin negatif olması bir şeyi değiştirmez
?>
Atama operatörleri
[değiştir]Atama operatörü = (eşittir) işaretidir. Temel görevi sağdaki değeri soldakine atamaktır.
<?php
$a = 5; // $a değişkenine 5 değeri atandı
$b = 15;
$c = $b; // $c değişkenine $b değişkeninin değeri olan 15 değeri atandı
$c =& $b // gönderimli atama yapıldı
$d = 4 + 5; // $d değişkenine 9 değeri atandı
$e = 7 % 2; // $e değişkenine 7'nin 2'ye bölümünden kalan 1 değeri atandı
?>
<?php
$a = 1;
$b = 14;
$a = $a + 3; // $a'nın kendi değerine 3 eklenip sonuç yine $a'ya atandı
$b = $b / 5; // $b'nin kendi değeri 5'e bölünüp sonuç yine $b'ye atandı
?>
Bu tip atamalar kısaltılarak da yazılabilir. Örneğin:
<?php
$a = 25;
$a += 8; // $a = $a + 8
$a -= 4; // $a = $a - 4
$a *= 5; // $a = $a * 5
$a /= 6; // $a = $a / 6
$a %= 7; // $a = $a % 7
?>
String veri türünden bildiğimiz nokta operatörü de atama operatörüyle kullanılabilir.
<?php
$mekan = "Viki";
$mekan = $mekan . "kitap"; // $mekan şimdi "Vikikitap" oldu
// $mekan .= "kitap"; biçiminde kısaltılarak da yazılabilirdi
$dil = "PHP";
$sonuc = $mekan . " " . $dil . " Programlama Dili";
echo $sonuc; // Vikikitap PHP Programlama Dili
?>
Mantıksal operatörler
[değiştir]| İşlem | İsim | Sonuç |
|---|---|---|
| $a && $b | ve | $a ve $b doğruysa sonuç doğrudur |
| $a || $b | veya | $a veya $b doğruysa sonuç doğrudur |
| !$a | değilleme | $a yanlışsa sonuç doğrudur |
| $a and $b | ve | $a ve $b doğruysa sonuç doğrudur |
| $a or $b | veya | $a veya $b doğruysa sonuç doğrudur |
| $a xor $b | ayrıcalıklı veya | $a veya $b doğruysa sonuç doğrudur. ikisi de doğruysa sonuç yanlıştır |
Aşağıda && operatörüyle ilgili örnekler verilmiştir.
<?php
$a = true && true; // true
$a = true && false; // false
$a = false && true; // false
$a = false && false; // false
?>
Aşağıda || operatörüyle ilgili örnekler verilmiştir.
<?php
$a = true || true; // true
$a = true || false; // true
$a = false || true; // true
$a = false || false; // false
?>
and ile && operatörleri aynı karşılaştırmayı yapar ancak öncelikleri farklıdır. Aynı durum or ile || operatörleri için de geçerlidir.
<?php
$a = (true && false); // false
$a = (true and false); // false
// şimdi parantezleri kaldırıp deneyelim
$a = true && false; // false
$a = true and false; // true
?>
Son satırda true dönmesinin nedeni işlem önceliğidir. Çünkü = (atama operatörü), and operatöründen daha önceliklidir. Bir de or ve || operatörleri için bakalım:
<?php
$a = (false || true); // true
$a = (false or true); // true
// şimdi parantezleri kaldırıp deneyelim
$a = false || true; // true
$a = false or true; // false
?>
Son satırda false dönmesinin nedeni de işlem önceliğidir. İşlem önceliği tablosuna bakılırsa = (atama) operatörünün or operatöründen daha öncelikli olduğu görülür.
Son olarak xor operatörüyle ilgili örnekler:
<?php
$a = (true xor true); // false
$a = (false xor false); // false
$a = (true xor false); // true
$a = (false xor true); // true
$a = false xor true; // false
?>
xor operatörü = (atama) operatöründen düşük öncelikli olduğu için son satırda sonuç false olmuştur.
Artırma ve eksiltme operatörleri
[değiştir]| İşlem | İsim | Sonuç |
|---|---|---|
| ++$a | önceden artırma | $a'nın değeri 1 artırılır, sonra $a işleme konur |
| $a++ | sonradan artırma | $a önce işleme konur, sonra değeri 1 artırılır |
| --$a | önceden eksiltme | $a'nın değeri 1 eksiltilir, sonra $a işleme konur |
| $a-- | sonradan eksiltme | $a önce işleme konur, sonra değeri 1 eksiltilir |
<?php
$a = 4;
$a++; // $a şimdi 5 oldu
echo $a; // 5 çıktılar
$a--; // $a tekrar 4 oldu
echo $a; // 4 çıktılar
?>
Önceden eksiltme ve artırma ile ilgili örnekler:
<?php
$a = 8;
$b = 3 + --$a; // $b 10 olmuştur. çünkü toplama işleminden önce $a 1 eksildi
echo $a; // 7 çıktılar
$c = 12;
$d = 3 + ++$c; // $d 16 olur. çünkü toplama işleminden önce $c 1 artırıldı
$e = ++$d; // $e 17 olur. çünkü atama işleminden önce $d 1 artırıldı
?>
Sonradan eksiltme ve artırma ile ilgili örnekler:
<?php
$a = 8;
$b = 3 + $a--; // $b 11 değeri alır. çünkü önce toplama yapılır daha sonra $a 1 eksiltilir
echo $a; // 7 çıktılar. çünkü bir önceki satırda $a 1 eksiltildi
$c = 12;
$d = 3 + $c++; // $d 15 olmuştur. önce toplama yapılır daha sonra $c 1 artırılır
echo $c; // 13 çıktılar. bir önceki satırda $c 1 artırıldı
$e = $c++; // $e 13 olmuştur. çünkü önce atama yapılır daha sonra $c 1 artırılır
echo $e; // 13 çıktılar
echo $c; // 14 çıktılar
?>
Karşılaştırma operatörleri
[değiştir]| İşlem | İsim | Sonuç |
|---|---|---|
| $a == $b | eşittir | $a ve $b aynı değere sahipse sonuç doğrudur |
| $a != $b | eşit değildir | $a ve $b farklı değere sahipse sonuç doğrudur |
| $a <> $b | eşit değildir | $a ve $b farklı değere sahipse sonuç doğrudur |
| $a === $b | aynıdır | $a ve $b aynı değere sahipse ve türleri de aynıysa sonuç doğrudur |
| $a !== $b | farklıdır | $a ve $b farklı değere sahipse veya türleri farklıysa sonuç doğrudur |
| $a < $b | küçüktür | $a'nın değeri $b'nin değerinden küçükse sonuç doğrudur |
| $a <= $b | küçük ya da eşittir | $a'nın değeri $b'nin değerinden küçükse veya eşitse sonuç doğrudur |
| $a > $b | büyüktür | $a'nın değeri $b'nin değerinden büyükse sonuç doğrudur |
| $a >= $b | büyük ya da eşittir | $a'nın değeri $b'nin değerinden büyükse veya eşitse sonuç doğrudur |
Karşılaştırma işlemlerinde sayıl değer ile karakter dizisi karşılaştırılıyorsa karakter dizisi sayıya dönüştürülür ve karşılaştırma buna göre yapılır. Aynı şekilde, sayıl değere sahip karakter dizileri karşılaştırılıyorsa karakter dizileri yine sayıya dönüştürülür ve karşılaştırma buna göre yapılır. === (aynıdır) ve !== (farklıdır) karşılaştırmalarında, operandların türleri de karşılaştırılacağından tür dönüştürme yapılmaz.
<?php
$a = 0;
$b = "string";
var_dump($a == $b); // bool(true) çıktılar
?>
Burada karşılaştırma sonucunun true (doğru) çıkmasının nedeni $b değişkeninin karşılaştırma esnasında sayıya dönüştürülmesidir.
<?php
$a = 10;
$b = "10";
var_dump($a == $b); // bool(true) çıktılar
?>
Burada "10" değerine sahip $b stringi, 10 olarak integer türüne dönüşmüştür ve sonuç doğru olmuştur. Ek bilgi için bkz: String ifadelerin sayıya dönüşümü
<?php
$a = 10;
$b = "10";
var_dump($a === $b); // bool(false) çıktılar
?>
Burada ise aynılık karşılaştırması yapılıyor. $a integer, $b string türüne sahip olduğu için sonuç false (yanlış) olmuştur.
<?php
$a = 10;
$b = 45;
var_dump($a < $b); // bool(true) çıktılar
$c = 45;
var_dump($b <= $c); // bool(true) çıktılar
var_dump($a > $c); // bool(false) çıktılar
?>
Hata operatörü
[değiştir]@ (kuyruklu a) operatörü, hata denetimi yapar. Bu operatör, bir deyimin önünde kullanıldığında, oluşabilecek hatalar görmezden gelinir. Bu hatalar, $php_errormsg değişkeninde saklanır. @ operatörü, sonucunda bir değer elde edilen deyimlerle kullanılabilir.
<?php
echo $a; // tanımsız değişken çıktılanmaya çalışılıyor
echo $php_errormsg; // Undefined variable: a çıktılar
?>