PHP-Operatoren

Ein Operator nimmt einen oder mehrere Werte (sogenannte Operanden) und erzeugt daraus einen neuen Wert. Operatoren sind die Grundbausteine jedes Ausdrucks in PHP — sie ermöglichen arithmetische Berechnungen, den Vergleich von Werten, die Verknüpfung boolescher Bedingungen, die Zuweisung von Ergebnissen an Variablen und das Verbinden von Zeichenketten.

Dieses Kapitel behandelt jede Kategorie von PHP-Operatoren mit ausführbaren Beispielen: Arithmetik, Zuweisung, Vergleich, Logik, Inkrement/Dekrement, String, Array, den Raumschiff-Operator, den Null-Koaleszenz-Operator und wie die Rangfolge der Operatoren die Auswertungsreihenfolge bestimmt.

Arithmetische Operatoren

Arithmetische Operatoren führen die bekannten mathematischen Operationen auf Zahlen durch.

<?php
$x = 10;
$y = 3;

echo $x + $y;   // 13
echo $x - $y;   // 7
echo $x * $y;   // 30
echo $x / $y;   // 3.3333333333333
echo $x % $y;   // 1   (remainder of 10 / 3)
echo $x ** $y;  // 1000 (10 to the power of 3)

Hinweis: Anders als in vielen Programmiersprachen kürzt PHP's / nicht ab. 10 / 4 ergibt 2.5, nicht 2. Verwende intdiv() für die ganzzahlige Division. Der %-Operator arbeitet mit ganzen Zahlen; für Fließkomma-Reste verwende fmod().

Zuweisungsoperatoren

Der grundlegende Zuweisungsoperator ist = — er speichert den Wert auf der rechten Seite in der Variable auf der linken Seite. Jeder arithmetische Operator hat auch eine kombinierte (zusammengesetzte) Form, die eine Variable direkt aktualisiert.

<?php
$total = 100;
$total += 20;  // 120
$total -= 50;  // 70
$total *= 2;   // 140
echo $total;   // 140

Vergleichsoperatoren

Vergleichsoperatoren vergleichen zwei Werte und geben einen boolean (true oder false) zurück. Beachte den wichtigen Unterschied zwischen dem losen (==) und dem strikten (===) Vergleich.

<?php
var_dump(10 == "10");   // bool(true)  — values match after juggling
var_dump(10 === "10");  // bool(false) — int vs string, types differ
var_dump(5 != 8);       // bool(true)
var_dump(5 >= 5);       // bool(true)

Achtung: Bevorzuge ===, wenn Typen wichtig sind. 0 == "abc" ist in modernem PHP (8.0+) false, aber der lose Vergleich hat immer noch überraschende Randfälle — der strikte Vergleich vermeidet sie.

Der Raumschiff-Operator <=>

Der Raumschiff-Operator vergleicht zwei Werte und gibt -1, 0 oder 1 zurück. Er ist am nützlichsten als Rückgabewert eines Sortier-Callbacks.

<?php
echo 1 <=> 2;   // -1  (left is smaller)
echo 2 <=> 2;   //  0  (equal)
echo 3 <=> 2;   //  1  (left is larger)

Logische Operatoren

Logische Operatoren verknüpfen boolesche Ausdrücke, typischerweise in if-Bedingungen.

<?php
$age = 25;
$hasLicense = true;

var_dump($age >= 18 && $hasLicense);  // bool(true)
var_dump($age < 18 || $hasLicense);   // bool(true)
var_dump(!$hasLicense);               // bool(false)

&& und and verhalten sich in Bedingungen gleich, haben aber eine unterschiedliche Rangfolge — and/or binden lockerer als =, was überraschend sein kann. Verwende besser && und ||.

PHP wertet auch kurzschließend aus: Bei $a && expensive() wird die rechte Seite nie ausgewertet, wenn $a false ist.

Inkrement- und Dekrement-Operatoren

Diese Operatoren addieren oder subtrahieren 1 von einer Variable. Ihre Position (Prä vs. Post) beeinflusst, welchen Wert der Ausdruck annimmt.

<?php
$x = 5;
echo $x++;  // 5  (prints old value, then $x becomes 6)
echo $x;    // 6
echo ++$x;  // 7  (increments first, then prints)

String-Operatoren

PHP hat zwei Operatoren, die speziell für Strings gedacht sind:

• . — der Verkettungs-Operator, verbindet zwei Strings.
• .= — der verkettende Zuweisungs-Operator, hängt an die Variable an.

<?php
$greeting = "Hello";
$greeting .= ", World!";   // append
echo $greeting;            // Hello, World!
echo "PHP" . " " . "rocks"; // PHP rocks

Array-Operatoren

Array-Operatoren arbeiten auf ganzen Arrays.

<?php
$a = ["a" => 1, "b" => 2];
$b = ["b" => 99, "c" => 3];

print_r($a + $b);
// Array ( [a] => 1 [b] => 2 [c] => 3 )
// "b" keeps the LEFT value (2), "c" is added

Null-Koaleszenz-Operator ??

Der ??-Operator gibt seinen linken Operanden zurück, wenn er vorhanden und nicht null ist, andernfalls den rechten Operanden. Er ist der saubere Ersatz für isset()-Prüfungen.

<?php
$data = ["name" => "Ann"];

$name = $data["name"] ?? "Guest";  // "Ann"
$role = $data["role"] ?? "Member"; // "Member" — key missing, no warning
echo "$name / $role";              // Ann / Member

Die ??= Null-Koaleszenz-Zuweisung weist nur dann zu, wenn die Variable aktuell null oder nicht gesetzt ist: $config["theme"] ??= "dark";.

Operator-Rangfolge

Wenn ein Ausdruck mehrere Operatoren enthält, bestimmt die Rangfolge, welcher zuerst ausgeführt wird — genau wie in der Mathematik (* vor +). Verwende Klammern, um die Absicht klar auszudrücken und die Standardreihenfolge zu überschreiben.

<?php
echo 2 + 3 * 4;     // 14  — * binds tighter than +
echo (2 + 3) * 4;   // 20  — parentheses force addition first

Von höchster zu niedrigster Priorität einige wichtige Ebenen: **, dann !, dann * / %, dann + -, dann Vergleiche (< > == ===), dann &&, dann ||, und schließlich =. Im Zweifelsfall Klammern setzen — sie kosten nichts und vermeiden Fehler.

Zusammenfassung

• Arithmetik (+ - * / % **) arbeitet auf Zahlen; / gibt einen Float zurück, % gibt den Rest zurück.
• Zuweisung (= += .= …) speichert und aktualisiert Werte; kombinierte Formen sind Kurzschreibweisen.
• Vergleich (== === != <=>) gibt booleans zurück — bevorzuge striktes ===, um Überraschungen durch Typumwandlung zu vermeiden.
• Logik (&& || !) verknüpft Bedingungen und wertet kurzschließend aus.
• Inkrement/Dekrement (++ --) unterscheiden sich durch die Prä-/Post-Position.
• String (. .=) verbindet Text; Array (+ == ===) vergleicht und zusammenführt Arrays.
• ?? liefert Standardwerte für fehlende Werte; Rangfolge und Klammern steuern die Auswertungsreihenfolge.

Als Nächstes werden diese Operatoren in bedingten Anweisungen und Schleifen eingesetzt.

Übungen