Bu dersimizde PHP operatörler konusunu öğreneceğiz. PHP’deki tüm operatörleri ve kullanım alanlarını eksiksiz ve detaylı olarak, örneklerle anlattık.

Bir veya birden fazla değer arasındaki işlemleri gerçekleştiren karakter veya sözcüklere operatör veya işleç denir. Operatör’ün ingilizcesi operator’dur ve Türkçe’de operatör olarak bilinir. Ancak bazı kaynaklar işleç olarak bahseder. Her ikisi de aynı anlamı taşır.

İçerik gizle

1 PHP Operatörler
2 PHP Operatör Önceliği
- 2.1 Operatör Önceliği Örnekleri
- 2.2 Operatörlerin Öncelik Tablosu

PHP Operatörler

PHP Aritmetik Operatörler (Arithmetic Operators)

PHP aritmetik operatörleri, toplama, çıkarma, çarpma gibi genel aritmetik işlemleri gerçekleştirmek için sayısal değerlerle kullanılır.

Operatör	İsim	Örnek
+	Toplama (addition)	$a + $b
–	Çıkarma (subtraction)	$a – $b
*	Çarpma (multiplication)	$a * $b
/	Bölme (division)	$a / $b
%	Modül (modulus)	$a % $b

PHP Aritmetik Operatör Örnekleri

Toplama operatörüyle (addition operator) 2 değeri toplarız. Bu örnekte php toplama operatörünü kullandık:

				
					echo 2+4; // Çıktı: 6

Çıkarma operatörüyle (subtraction operator) bir değerden diğer değeri çıkarırız. Bu örnekte php çıkarma operatörünü kullandık:

				
					echo 5-2; // Çıktı: 3

Bölme operatörüyle (division operator) bir değeri diğer değere böleriz. Bu örnekte php bölme operatörünü kullandık:

				
					echo 6/2; // Çıktı: 3

Çarpma operatörüyle (multiplication operator) bir değeri diğer değerle çarparız. Bu örnekte php çarpma operatörünü kullandık:

				
					echo 5*2; // Çıktı: 10

Modül operatörüyle (modulus operator) bir değer diğer değere bölündüğünde kalan sayıyı buluruz. Bu örnekte php modül operatörünü kullandık:

				
					echo 7%2; // Çıktı: 1

PHP Atama Operatörleri (Assignment Operators)

PHP atama operatörleri (assignment operators) değer atamak için kullanılır.

Operatör	İsim	Örnek
=	Atama	$a = $b
+=	Topla ve Ata	$a +=4
-=	Çıkar ve Ata	$a -=4
*=	Böl ve Ata	$a /=4
*=	Çarp ve Ata	$a *=4
%=	Modül ve Ata	$a %=4

PHP Atama Operatörü Örnekleri

Eşittir operatörüyle soldaki operanda sağdaki değeri atadık.

				
					$a = 20;

Topla ve ata operatörüyle değişkene soldaki ile sağdaki değişkenin toplamını atadık.

				
					$a = 10;
$b = 15; 
$a += $b; // $a değişkeninin değeri 25
// Üst satırdaki ifade ile $a = $a + $b ifadesi aynı.

Çıkar ve ata operatörüyle değişkene sağdaki değişken değerinin soldaki değişken değerinden çıkarıldığında kalan sonucu atadık.

				
					$a = 20;
$b = 10; 
$a -= $b; // $a değişkeninin değeri 10
// Üst satırdaki ifade ile $a = $a - $b ifadesi aynı.

Böl ve ata operatörüyle değişkene soldaki değişken değerinin sağdaki değişken değerine kaç kez bölünebildiği sonucunu atadık.

				
					$a = 12;
$b = 4; 
$a /= $b; // $a değişkeninin değeri 3
// Üst satırdaki ifade ile $a = $a / $b ifadesi aynı.

Çarp ve ata operatörüyle değişkene iki değişken değerinin birbiriyle çarpıldığında çıkan sonucu atadık.

				
					$a = 2;
$b = 2; 
$a *= $b; // $a değişkeninin değeri 4
// Üst satırdaki ifade ile $a = $a * $b ifadesi aynı.

Modül ve ata operatörüyle değişkene soldaki değişken değerinin sağdaki değişken değerine bölündüğünde kalan sayıyı atadık.

				
					$a = 8;
$b = 3; 
$a %= $b; // $a değişkeninin değeri 2
// Üst satırdaki ifade ile $a = $a % $b ifadesi aynı.

PHP Karşılaştırma Operatörleri (Comparison Operators)

PHP karşılaştırma operatörleri (comparison operators) iki değeri karşılaştırmak için kullanılır.

Operatör	İsim	Örnek
==	Eşit (equal)	$a == $b
===	Denk (identical)	$a === $b
!=	Eşit Değil (not equal)	$a != $b
!==	Denk Değil (not identical)	$a !== $b
<>	Eşit Değil (not equal)	$a <> $b
>	Daha Büyük (greater than)	$a > $b
<	Daha Küçük (less than)	$a < $b
>=	Daha Büyük veya Eşit (greater than or equal to)	$a >= $b
<=	Daha Küçük veya Eşit (less than or equal to)	$a <= $b

PHP Karşılaştırma Operatörü Örnekleri

Eşit (equal) operatörüyle iki değerin eşitliğini kontrol ettik.

				
					$a = 4;
$b = 2; 

if ($a == $b) {
    echo "A, B\'ye eşittir";
} else {
    echo "A, B'ye eşit değildir";
}
// Çıktı: A, B'ye eşit değildir

Denk (identical) operatörüyle iki değerin denkliğini kontrol ettik.

				
					$a = 4;
$b = '4'; 

if ($a === $b) {
    echo "A, B'ye denktir";
} else {
    echo "A, B'ye denk değildir";
}
// Çıktı: A, B'ye denk değildir

Eşit değil (not equal) operatörüyle iki değerin eşitsizliğini kontrol ettik.

				
					$a = 4;
$b = 3; 

if ($a != $b) {
    echo "A, B'ye eşit değildir";
} else {
    echo "A, B'ye eşittir";
}
// Çıktı: A, B'ye eşit değildir

Denk değil (not identical) operatörüyle iki değerin eşitsizliğini kontrol ettik.

				
					$a = 4;
$b = '4'; 

if ($a !== $b) {
    echo "A, B'ye denk değildir";
} else {
    echo "A, B'ye denktir";
}
// Çıktı: A, B'ye denk değildir

Eşit değil (not equal) operatörüyle iki değerin eşitsizliğini kontrol ettik.

				
					$a = 4;
$b = 2; 

if ($a <> $b) {
    echo "A, B'ye eşit değildir";
} else {
    echo "A, B'ye eşittir";
}
// Çıktı: A, B'ye eşit değildir

Daha büyük (greater than) operatörüyle soldaki değerin sağdakinden daha büyük olup olmadığını kontrol ettik.

				
					$a = 4;
$b = 2; 

if ($a > $b) {
    echo "A, B'den daha büyüktür";
} else {
        echo "A, B'den daha büyük değildir";
}
// Çıktı: A, B'den daha büyüktür

Daha küçük (less than) operatörüyle soldaki değerin sağdakinden daha küçük olup olmadığını kontrol ettik.

				
					$a = 2;
$b = 4; 

if ($a < $b) {
    echo "A, B'den daha küçüktür";
} else {
        echo "A, B'den daha küçük değildir";
}
// Çıktı: A, B'den daha küçüktür

Daha büyük veya eşit (greater than or equal to) operatörüyle soldaki değerin sağdakinden daha büyük veya eşit olup olmadığını kontrol ettik.

				
					$a = 4;
$b = 2; 

if ($a >= $b) {
    echo "A, B'den daha büyüktür veya eşittir";
} else {
        echo "A, B'den daha büyük veya eşit değildir";
}
// Çıktı: A, B'den daha büyüktür veya eşittir

Daha küçük veya eşit (less than or equal to) operatörüyle soldaki değerin sağdakinden daha küçük veya eşit olup olmadığını kontrol ettik.

				
					$a = 2;
$b = 4; 

if ($a <= $b) {
    echo "A, B'den daha küçüktür veya eşittir";
} else {
        echo "A, B'den daha küçük veya eşit değildir";
}
// Çıktı: A, B'den daha küçüktür veya eşittir

PHP Arttırma Azaltma Operatörleri (Increment/Decrement Operators)

PHP artış operatörleri (increment operators) bir değişkenin değerini arttırmak için kullanılır. PHP azalma operatörleri (decrement operators) bir değişkenin değerini azaltmak için kullanılır.

Operatör	İsim
++$i	Önce Artış (pre-increment)
$i++	Sonra Artış (post-increment)
–$i	Önce Azalma (pre-decrement)
$i–	Sonra Azalma (post-decrement)

PHP Arttırma Azaltma Operatörü Örnekleri

Önce artış (pre-increment) operatörü $i değişkeninin değerini önce arttırır, ardından $i değişkenini döndürür.

				
					$i = 10;  
echo ++$i; // Çıktı: 11

Sonra artış (post-increment) operatörü $i değişkenini döndürür, ardından $i değişkeninin değerini arttırır.

				
					$i = 10;  
echo $i++; // Çıktı: 10

Önce azalma (pre-decrement) operatörü $i değişkeninin değerini önce azaltır, ardından $i değişkenini döndürür.

				
					$i = 10;  
echo --$i; // Çıktı: 9

Sonra azalma (post-decrement) operatörü $i değişkenini döndürür, ardından $i değişkeninin değerini azaltır.

				
					$i = 10;  
echo ++$i; // Çıktı: 10

PHP Mantıksal Operatörler (Logical Operators)

PHP mantıksal operatörler, koşullu ifadeleri birleştirmek için kullanılır.

Operatör	İsim	Örnek
and	ve (and)	$a and $b
or	ya da (or)	$a or $b
xor	xor	$a xor $b
&&	ve (and)	$a && $b
\|\|	ya da (or)	$a \|\| $b
!	değil (not)	$a ! $b

PHP Mantıksal Operatör Örnekleri

Ve (and) operatörü $a ve $b’deki koşul sağlandıysa true döndürür.

				
					$a = 100;
$b = 50;
if ($a === 100 and $b === 50) {
    echo "A, 100'e denktir ve B, 50'e denktir";
}
// Çıktı: A, 100'e denktir ve B, 50'e denktir

Veya (or) operatörü $a veya $b’deki koşul sağlandıysa true döndürür.

				
					$a = 100;
$b = 50;
if ($a === 100 or $b === 75) {
    echo "A, 100'e denktir veya B, 75'e denktir";
}
// Çıktı: A, 100'e denktir veya B, 75'e denktir

Ve (and) operatörü $a ve $b’deki koşul sağlandıysa true döndürür.

				
					$a = 100;
$b = 50;
if ($a === 100 && $b === 50) {
    echo "A, 100'e denktir ve B, 50'e denktir";
}
// Çıktı: A, 100'e denktir ve B, 50'e denktir

Veya (or) operatörü $a veya $b’deki koşul sağlandıysa true döndürür.

				
					$a = 100;
$b = 50;
if ($a === 100 || $b === 75) {
    echo "A, 100'e denktir veya B, 75'e denktir";
}
// Çıktı: A, 100'e denktir veya B, 75'e denktir

Xor operatörü sadece $a veya $b’deki koşul sağlandıysa true döndürür.

				
					$a = 100;
$b = 50;
if ($a === 100 xor $b === 75) {
    echo "A, 100'e denktir veya B, 75'e denktir";
}
// Çıktı: A, 100'e denktir veya B, 75'e denktir

Değil (not) operatörü $a’daki koşul sağlanmadıysa true döndürür.

				
					$x = 50;
if ($x !== 75) {
    echo "X, 75'e denk değildir";
}
// Çıktı: X, 75'e denk değildir

PHP Metin Operatörleri (String Operators)

PHP metinler için tasarlanmış 2 operatöre sahiptir:
Birleştirme operatörü (concatenation operator) ve birleştirme ataması operatörü (concatenation assignment operator).

Operatör	İsim	Örnek
.	Birleştirme Operatörü (concatenation operator)	$a . $b
.=	Birleştirme Ataması Operatörü (concatenation assignment operator)	$a .= $b

PHP Metin Operatörü Örnekleri

Birleştirme operatörü (concatenation operator) iki veriyi birleştirir. Aşağıdaki örnekte $a ve $b değişkenin verisini birleştirerek yazdırdık.

				
					$a = "Hello ";
$b = " World!";
echo $a . $b;
// Çıktı: Hello World!

Birleştirme ataması operatörü (concatenation assignment operator) birinci verinin yanına ikinci veriyi ekler. Aşağıdaki örnekte $a değişkeninin verisinin yanına $b değişkeninin verisini ekledik ve $a değişkenini yazdırdık.

				
					$a = "Hello ";
$b = " World!";
$a .= $b;
echo $a;
// Çıktı: Hello World!

PHP Dizi Operatörleri (Array Operators)

PHP’deki dizi operatörleri (array operators) dizileri karşılaştırmak için kullanılır.

Operatör	İsim	Örnek
+	Birleştirme Operatörü (union)	$a + $b
==	Eşitlik Operatörü (equality)	$a == $b
===	Denklik Operatörü (identity)	$a === $b
!=	Eşitsizlik Operatörü (inequality)	$a != $b
<>	Eşitsizlik Operatörü (inequality)	$a <> $b
!==	Denksizlik Operatörü (non-identity)	$a !== $b

PHP Dizi Operatörü Örnekleri

Birleştirme operatörü (union) dizileri birleştirir.

				
					$a = array('a' => 'kırmızı', 'b' => 'mavi');  
$b = array('c' => 'yeşil', 'd' => 'sarı');  
print_r($a + $b);
// Çıktı: Array ( [a] => kırmızı [b] => mavi [c] => yeşil [d] => sarı )

Eşitlik operatörü (equality) dizilerde eşitlik kontrolü sağlar. İki dizinin verilerinin eşit olup olmadığını eşitlik operatörüyle öğrenebiliriz.

				
					$a = array('a' => 'kırmızı', 'b' => 'mavi');  
$b = array('c' => 'yeşil', 'd' => 'sarı');  

if ($a == $b) {
	echo "A, B'ye eşittir";
} else {
	echo "A, B'ye eşit değildir";
}
// Çıktı: A, B'ye eşit değildir

Denklik operatörü (identity) dizilerde eşitlik kontrolü sağlar. İki dizinin verilerinin denk olup olmadığını denklik operatörüyle öğrenebiliriz.

				
					$a = array('a' => 'kırmızı', 'b' => 'mavi');  
$b = array('c' => 'yeşil', 'd' => 'sarı');  

if ($a === $b) {
	echo "A, B'ye denktir";
} else {
	echo "A, B'ye denk değildir";
}
// Çıktı: A, B'ye denk değildir

Eşitsizlik operatörü (inequality) dizilerde eşitsizlik kontrolü sağlar. İki dizinin verilerinin eşit olmadığını eşitsizlik operatörüyle öğrenebiliriz.

				
					$a = array('a' => 'kırmızı', 'b' => 'mavi');  
$b = array('c' => 'yeşil', 'd' => 'sarı');  

if ($a != $b) {
	echo "A, B'ye eşit değildir";
} else {
	echo "A, B'ye eşittir";
}
// Çıktı: A, B'ye eşit değildir

Eşitsizlik operatörü (inequality) dizilerde eşitsizlik kontrolü sağlar. İki dizinin verilerinin eşit olmadığını eşitsizlik operatörüyle öğrenebiliriz.

				
					$a = array('a' => 'kırmızı', 'b' => 'mavi');  
$b = array('c' => 'yeşil', 'd' => 'sarı');  

if ($a  $b) {
	echo "A, B'ye eşit değildir";
} else {
	echo "A, B'ye eşittir";
}
// Çıktı: A, B'ye eşit değildir

Denksizlik operatörü (non-identity) dizilerde denksizlik kontrolü sağlar. İki dizinin verilerinin denk olmadığını eşitsizlik operatörüyle öğrenebiliriz.

				
					$a = array('a' => 'kırmızı', 'b' => 'mavi');  
$b = array('c' => 'yeşil', 'd' => 'sarı');  

if ($a !== $b) {
	echo "A, B'ye denk değildir";
} else {
	echo "A, B'ye denktir";
}
// Çıktı: A, B'ye denk değildir

PHP Koşullu Atama Operatörleri (Conditional Assignment Operators)

PHP’ koşullu atama operatörleri koşullara bağlı olarak bir değer atamak için kullanılır.

Operatör	İsim	Örnek
?:	Üçlü Operatör (ternary)	$a = expr1 ? expr2 : expr3
??	Null Birleştirme Operatörü (null coalescing)	$a = expr1 ?? expr2

PHP Koşullu Atama Operatörü Örnekleri

Üçlü operatör (ternary) koşula bağlı veri atar. Aşağıdaki örnekte $status değişkenine empty($user) koşulu true döndürürse “giriş yapılmadı”, false döndürürse “giriş yapıldı” verisini atadık.

				
					// Örnek 1:
$user = "Onur Özden";
echo $status = (empty($user)) ? "giriş yapılmadı" : "giriş yapıldı";
// empty($user) koşulu false ise, $status değişkenine "giriş yapıldı" değerini ata, true ise $status değişkenine "giriş yapılmadı" değerini ata.

// Örnek 2:
$user = "Onur Özden";
echo $status = (empty($user)) ? 0 : 1;
// empty($user) = false ise, $status değişkenine 0 değerini ata, true ise $status değişkenine 1 değerini ata.

Null birleştirme operatörü (null coalescing) koşula bağlı veri atar. Birinci veri varsa ve null değilse $a’ın değeri birinci veridir. Birinci veri yoksa veya null ise, $a’ın değeri ikinci veridir. Aşağıdaki örnekte $status değişkenine empty($user) koşulu true döndürürse “giriş yapılmadı”, false döndürürse “giriş yapıldı” verisini atadık.

				
					// $_GET['user'] varsa ve null değilse $user değişkenine değer olarak atanır, $_GET['user'] yoksa veya null ise $user değişkenine "giriş yapılmadı" metni değer olarak tanır. 
echo $user = $_GET['user'] ?? 'giriş yapılmadı';
// Çıktı: giriş yapılmadı
  
// $car değişkeni varsa ve null değilse $car değişkenine $car değişkeninin değeri atanır, $car değişkeni yoksa veya null ise $car değişkenine 'BMW' değeri atanır. 
echo $color = $color ?? 'BMW';
// Çıktı: BMW

PHP Operatör Önceliği

Operatör Önceliği Örnekleri

Matematikte olduğu gibi PHP’de de operatörlerin bazı öncelik değerleri vardır. Bir örnekle bunu anlayalım.

				
					echo 3 + 5 * 2; // Çıktı: 13

Yukarıdaki işlemde çıktı 13 olacaktır. Çünkü çarpma işlemi toplamaya göre önceliklidir. Bu nedenle önce çarpma işlemi, sonra toplama işlemi yapıldı. Fakat işlem önceliğine müdahale etmek mümkündür.

				
					echo (3 + 5) * 2; // Çıktı: 16

Yukarıdaki işlemde çıktı 16 olacaktır. Çünkü toplama işlemini parantez içerisine alınarak toplama işlemini önceliklendirdik. Bu nedenle önce toplama işlemi, sonra çarpma işlemi yapıldı. İşlem önceliğine bu şekilde müdahale ettik.

Operatörlerin Öncelik Tablosu

Aşağıdaki tabloda operatörler en yüksek öncelikliden başlayıp en düşük öncelikliye doğru sıralanmışlardır. Aynı satırda yer alan operatörler ise eş öncelikli olup hangi sırada ele alınacaklarına değerlendirme sırasında karar verilir. PHP’deki tüm operatörlerin öncelik tablosunu aşağıya ekledik.

İlişkilendirme	Operatörler
(yok)	`clone` `new`
(yok)	`**`
sağdan	`+` `-` `++` `--` `~` `(int)` `(float)` `(string)` `(array)` `(object)` `(bool)` `@`
soldan	`instanceof`
(yok)	`!`
soldan	`*` `/` `%`
soldan	`+` `-` `.`
soldan	`<<` `>>`
soldan	`.`
yönsüz	`<` `<=` `>` `>=`
yönsüz	`==` `!=` `===` `!==` `<>` `<=>`
left	`&`
soldan	`^`
soldan	`\|`
soldan	`&&`
soldan	`\|\|`
right	`??`
yönsüz	`? :`
sağdan	`=` `+=` `-=` `=` `*=` `/=` `.=` `%=` `&=` `\|=` `^=` `<<=` `>>=` `??=`
(yok)	`yield from`
(yok)	`yield`
(yok)	`print`
soldan	`and`
soldan	`xor`
soldan	`or`