PHP Operatoren – PHP Lektionen

In dieser Lektion lernen wir etwas über PHP-Operatoren. Wir haben alle Operatoren und deren Einsatzgebiete in PHP ausführlich und anhand von Beispielen erklärt.

Zeichen oder Wörter, die Operationen zwischen einem oder mehreren Werten ausführen, werden Operatoren oder Operatoren genannt. Das englische Wort für Operator ist „operator“ und wird im Türkischen als „operator“ bezeichnet. Einige Quellen erwähnen es jedoch als Operator. Beide haben die gleiche Bedeutung.

PHP-Operatoren

Arithmetische PHP-Operatoren

PHP-Arithmetikoperatoren werden mit numerischen Werten verwendet, um gängige arithmetische Operationen wie Addition, Subtraktion und Multiplikation durchzuführen.

Betreiber	Namen	Beispiel
+	Ergänzung	$a + $b
-	Subtraktion	$a - $b
*	Multiplikation	$a * $b
/	Abteilung	$a / $b
%	Modul (Modul)	$a % $b

Beispiele für arithmetische PHP-Operatoren

Wir addieren 2 Werte mit dem Additionsoperator. In diesem Beispiel haben wir den PHP-Additionsoperator verwendet:

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

Mit dem Subtraktionsoperator subtrahieren wir einen Wert von einem anderen. In diesem Beispiel haben wir den PHP-Subtraktionsoperator verwendet:

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

Mit dem Divisionsoperator dividieren wir einen Wert durch einen anderen Wert. In diesem Beispiel haben wir den PHP-Split-Operator verwendet:

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

Mit dem Multiplikationsoperator multiplizieren wir einen Wert mit einem anderen Wert. In diesem Beispiel haben wir den PHP-Multiplikationsoperator verwendet:

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

Mit dem Moduloperator ermitteln wir den Rest, wenn ein Wert durch einen anderen geteilt wird. In diesem Beispiel haben wir den PHP-Moduloperator verwendet:

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

PHP-Zuweisungsoperatoren

Zur Zuweisung von Werten werden PHP-Zuweisungsoperatoren verwendet.

Betreiber	Namen	Beispiel
=	Aufgabe	$a = $b
+=	Sammeln und entsorgen	$a +=4
-=	Subtrahieren und zuweisen	$a -=4
*=	Teilen und zuweisen	$a /=4
*=	Multiplizieren und zuweisen	$a *=4
%=	Modul und Zuweisung	$a%=4

Beispiele für PHP-Zuweisungsoperatoren

Wir haben den Wert rechts dem linken Operanden mit dem Gleichheitsoperator zugewiesen.

$a = 20;

Wir haben der Variablen die Summe der linken und rechten Variablen mit dem Add-and-Assign-Operator zugewiesen.

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

Mit dem Subtraktions- und Zuweisungsoperator haben wir der Variablen das Ergebnis der Subtraktion des Werts der Variablen rechts vom Wert der Variablen links zugewiesen.

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

Mit dem Divide-and-Assign-Operator weisen wir der Variablen das Ergebnis zu, wie oft der Wert der Variablen links durch den Wert der Variablen rechts geteilt werden kann.

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

Mit dem Multiplikations- und Zuweisungsoperator haben wir der Variablen das Ergebnis der Multiplikation zweier Variablenwerte zugewiesen.

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

Mithilfe der Modul- und Zuweisungsoperatoren haben wir der Variablen den Rest zugewiesen, als der Wert der Variablen links durch den Wert der Variablen rechts dividiert wurde.

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

PHP-Vergleichsoperatoren

PHP-Vergleichsoperatoren werden verwendet, um zwei Werte zu vergleichen.

Betreiber	Namen	Beispiel
==	Gleich	$a == $b
===	Äquivalent	$a === $b
!=	Nicht gleich (nicht gleich)	$a != $b
!==	Nicht identisch	$a !== $b
<>	Nicht gleich (nicht gleich)	$a <> $b
>	Größer als	$a > $b
<	Weniger als	$a < $b
>=	Größer oder gleich	$a >= $b
<=	Kleiner als oder gleich (kleiner als oder gleich)	$a <= $b

Beispiele für PHP-Vergleichsoperatoren

Wir haben die Gleichheit zweier Werte mit dem Gleichheitsoperator überprüft.

$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

Wir haben die Äquivalenz zweier Werte mit dem identischen Operator überprüft.

$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

Wir haben die Ungleichheit zweier Werte mit dem Ungleichheitsoperator überprüft.

$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

Wir haben die Ungleichheit zweier Werte mit dem nicht identischen Operator überprüft.

$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

Wir haben die Ungleichheit zweier Werte mit dem Ungleichheitsoperator überprüft.

$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

Mit dem Größer-als-Operator haben wir überprüft, ob der Wert links größer als der Wert rechts war.

$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

Wir haben mit dem Kleiner-als-Operator überprüft, ob der Wert auf der linken Seite kleiner als der Wert auf der rechten Seite ist.

$a = 2;
$b = 4; 
if ($a &lt $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

Wir haben mit dem Operator „Größer als oder gleich“ überprüft, ob der Wert auf der linken Seite größer oder gleich dem Wert auf der rechten Seite ist.

$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

Wir haben mit dem Kleiner-gleich-Operator überprüft, ob der Wert links kleiner oder gleich dem Wert rechts ist.

$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-Inkrementierungs-/Dekrementierungsoperatoren

PHP-Inkrementoperatoren werden verwendet, um den Wert einer Variablen zu erhöhen. PHP-Dekrementoperatoren werden verwendet, um den Wert einer Variablen zu verringern.

Betreiber	Namen
++$i	Inkrement vor (Vorinkrement)
$i++	Nach dem Inkrementieren (Post-Inkrementieren)
--$i	Vorher verringern (vor der Dekrementierung)
$i--	Nach der Dekrementierung (Post-Dekrementierung)

Beispiele für PHP-Inkrement-Dekrement-Operatoren

Der Vorinkrementoperator erhöht zunächst den Wert der Variablen $i und gibt dann die Variable $i zurück.

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

Dann gibt der Post-Inkrement-Operator die Variable $i zurück und erhöht dann den Wert der Variablen $i.

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

Der Vor-Dekrement-Operator verringert zunächst den Wert der Variablen $i und gibt dann die Variable $i zurück.

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

Dann gibt der Post-Dekrement-Operator die Variable $i zurück und dekrementiert dann den Wert der Variablen $i.

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

Logische PHP-Operatoren

Logische PHP-Operatoren werden verwendet, um bedingte Ausdrücke zu kombinieren.

Betreiber	Namen	Beispiel
Eid	und (und)	$a und $b
oder	oder (oder)	$a oder $b
xor	xor	$a xoder $b
&&	und (und)	$a && $b
\|\|	oder (oder)	$a \|\| $b
!	nicht (Anmerkung)	$a! $b

Beispiele für logische PHP-Operatoren

Und der (und)-Operator gibt true zurück, wenn die Bedingung in $a und $b erfüllt ist.

$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

Der Operator or (oder) gibt true zurück, wenn die Bedingung in $a oder $b erfüllt ist.

$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

Und der (und)-Operator gibt true zurück, wenn die Bedingung in $a und $b erfüllt ist.

$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

Der Operator or (oder) gibt true zurück, wenn die Bedingung in $a oder $b erfüllt ist.

$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

Der xor-Operator gibt nur dann true zurück, wenn die Bedingung in $a oder $b erfüllt ist.

$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

Der Not-Operator gibt true zurück, wenn die Bedingung in $a nicht erfüllt ist.

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

PHP-Textoperatoren (String-Operatoren)

PHP verfügt über zwei Operatoren für Texte:
Verkettungsoperator und Verkettungszuweisungsoperator.

Betreiber	Namen	Beispiel
.	Verkettungsoperator	$a . $b
.=	Verkettungszuweisungsoperator	$a .= $b

Beispiele für PHP-Textoperatoren

Der Verkettungsoperator kombiniert zwei Daten. Im folgenden Beispiel haben wir die Daten der Variablen $a und $b kombiniert und gedruckt.

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

Der Verkettungszuweisungsoperator fügt die zweiten Daten neben den ersten Daten hinzu. Im folgenden Beispiel haben wir die Daten der Variablen $b neben den Daten der Variablen $a hinzugefügt und die Variable $a gedruckt.

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

PHP-Array-Operatoren

Array-Operatoren in PHP werden zum Vergleichen von Arrays verwendet.

Betreiber	Namen	Beispiel
+	Gewerkschaftsbetreiber (Gewerkschaft)	$a + $b
==	Gleichheitsoperator (Gleichheit)	$a == $b
===	Äquivalenzoperator (Identität)	$a === $b
!=	Ungleichheitsoperator (Ungleichung)	$a != $b
<>	Ungleichheitsoperator (Ungleichung)	$a <> $b
!==	Ungleichgewichtsoperator (keine Identität)	$a !== $b

Beispiele für PHP-Array-Operatoren

Der Union-Operator kombiniert Arrays.

$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ı )

Der Gleichheitsoperator (equality) ermöglicht die Gleichheitskontrolle in Arrays. Mit dem Gleichheitsoperator können wir herausfinden, ob die Daten zweier Arrays gleich sind oder nicht.

$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

Der Identitätsoperator bietet Gleichheitskontrolle in Arrays. Mit dem Äquivalenzoperator können wir herausfinden, ob die Daten zweier Arrays äquivalent sind.

$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

Der Ungleichheitsoperator (Inequality) ermöglicht die Ungleichheitskontrolle in Arrays. Mit dem Ungleichheitsoperator können wir lernen, dass die Daten zweier Arrays nicht gleich sind.

$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

Der Ungleichheitsoperator (Inequality) ermöglicht die Ungleichheitskontrolle in Arrays. Mit dem Ungleichheitsoperator können wir lernen, dass die Daten zweier Arrays nicht gleich sind.

$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

Der Nichtidentitätsoperator ermöglicht die Nichtidentitätskontrolle in Arrays. Mit dem Ungleichheitsoperator können wir herausfinden, dass die Daten zweier Arrays nicht äquivalent sind.

$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-Operatoren für bedingte Zuweisungen

Die bedingten Zuweisungsoperatoren von PHP werden verwendet, um einen Wert basierend auf Bedingungen zuzuweisen.

Betreiber	Namen	Beispiel
?:	Ternärer Operator (ternär)	$a = expr1 ? Ausdruck2: Ausdruck3
??	Null-Koaleszenzoperator (Null-Koaleszenz)	$a = expr1 ?? Ausdruck2

Beispiele für PHP-Operatoren für bedingte Zuweisungen

Der ternäre Operator weist bedingte Daten zu. Im folgenden Beispiel haben wir der Variable $status die Daten „nicht angemeldet“ zugewiesen, wenn die Bedingung „leer($user)“ „true“ zurückgibt, und „angemeldet“, wenn sie „false“ zurückgibt.

// Ö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.

Der Nullkoaleszenzoperator weist bedingte Daten zu. Wenn die ersten Daten vorhanden sind und nicht null sind, ist der Wert von $a die ersten Daten. Wenn die ersten Daten nicht vorhanden oder null sind, ist der Wert von $a der zweite Datenwert. Im folgenden Beispiel haben wir der Variable $status die Daten „nicht angemeldet“ zugewiesen, wenn die Bedingung „leer($user)“ „true“ zurückgibt, und „angemeldet“, wenn sie „false“ zurückgibt.

// $_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

Priorität des PHP-Operators

Beispiele für Betreiberprioritäten

Wie in der Mathematik haben Operatoren in PHP einige Prioritätswerte. Lassen Sie uns dies anhand eines Beispiels verstehen.

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

Im obigen Prozess beträgt die Ausgabe 13. Da die Multiplikation Vorrang vor der Addition hat. Daher wurde zuerst die Multiplikation und dann die Addition durchgeführt. Es besteht jedoch die Möglichkeit, in die Bearbeitungspriorität einzugreifen.

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

Im obigen Prozess beträgt die Ausgabe 16. Weil wir dem Additionsprozess Priorität eingeräumt haben, indem wir ihn in Klammern gesetzt haben. Daher wurde zuerst eine Addition und dann eine Multiplikation durchgeführt. So haben wir in die Transaktionspriorität eingegriffen.

Prioritätentabelle der Betreiber

In der folgenden Tabelle sind die Operatoren in der Reihenfolge von der höchsten zur niedrigsten Priorität aufgeführt. Bediener auf derselben Leitung haben die gleiche Priorität und die Reihenfolge, in der sie bearbeitet werden, wird während der Bewertung festgelegt. Wir haben unten die Rangfolgetabelle aller Operatoren in PHP eingefügt.

Zuschreibung	Betreiber
(keine)	`clone` `new`
(keine)	`**`
von rechts	`+` `-` `++` `--` `~` `(int)` `(float)` `(string)` `(array)` `(object)` `(bool)` `@`
von links	`instanceof`
(keine)	`!`
von links	`*` `/` `%`
von links	`+` `-` `.`
von links	`<<` `>>`
von links	`.`
richtungslos	`<` `<=` `>` `>=`
richtungslos	`==` `!=` `===` `!==` `<>` `<=>`
links	`&`
von links	`^`
von links	`\|`
von links	`&&`
von links	`\|\|`
richtig	`??`
richtungslos	`? :`
von rechts	`=` `+=` `-=` `=` `*=` `/=` `.=` `%=` `&=` `\|=` `^=` `<<=` `>>=` `??=`
(keine)	`yield from`
(keine)	`yield`
(keine)	`print`
von links	`and`
von links	`xor`
von links	`or`

Diese Tabelle stammt von php.net. Quelle: https://www.php.net/manual/tr/language.operators.precedence.php

Empfehlen Sie uns auf Google

Wenn dieser Artikel für Sie nützlich war, fügen Sie Onur Özden Web Çözümleri zu Ihren bevorzugten Quellen auf Google hinzu. Unsere neuen Artikel zu SEO, Backlinks und KI-Sichtbarkeit werden häufiger in Ihren Suchergebnissen und KI-Antworten erscheinen; Sie können diese Einstellung jederzeit rückgängig machen.

PHP-Operatoren

PHP-Operatoren

Arithmetische PHP-Operatoren

Beispiele für arithmetische PHP-Operatoren

PHP-Zuweisungsoperatoren

Beispiele für PHP-Zuweisungsoperatoren

PHP-Vergleichsoperatoren

Beispiele für PHP-Vergleichsoperatoren

PHP-Inkrementierungs-/Dekrementierungsoperatoren

Beispiele für PHP-Inkrement-Dekrement-Operatoren

Logische PHP-Operatoren

Beispiele für logische PHP-Operatoren

PHP-Textoperatoren (String-Operatoren)

Beispiele für PHP-Textoperatoren

PHP-Array-Operatoren

Beispiele für PHP-Array-Operatoren

PHP-Operatoren für bedingte Zuweisungen

Beispiele für PHP-Operatoren für bedingte Zuweisungen

Priorität des PHP-Operators

Beispiele für Betreiberprioritäten

Prioritätentabelle der Betreiber

Empfehlen Sie uns auf Google

Kommentare(0)

Hinterlassen Sie einen Kommentar

Verwandte Artikel

Leistung und effektive Nutzung von PHP-Schleifen

Effektiver Einsatz von PHP-Tags

PHP 8.3: Neue Versionsanalyse – Neuerungen und Änderungen

Über 131 verifizierte Google Bewertungen