Appearance
Kapitel 5: Operatoren und Ausdrücke
5.1 Arithmetische Operatoren (+ - * / % ++ --)
Grundlegende arithmetische Operatoren
php
<?php
$a = 10;
$b = 3;
echo $a + $b; // 13 (Addition)
echo $a - $b; // 7 (Subtraktion)
echo $a * $b; // 30 (Multiplikation)
echo $a / $b; // 3.3333... (Division, ergibt Float!)
echo $a % $b; // 1 (Modulo - Rest der Division)
echo -$a; // -10 (Negation)
// Achtung: Division ergibt bei ganzzahligem Ergebnis trotzdem Float
echo 10 / 2; // 5.0 (Float!), nicht 5 (Integer)
?>Inkrement- und Dekrement-Operatoren (++ --)
php
<?php
$x = 5;
// Post-Inkrement: Wert wird nach der Verwendung erhöht
echo $x++; // Gibt 5 aus, dann wird $x zu 6
echo $x; // 6
$y = 5;
// Pre-Inkrement: Wert wird vor der Verwendung erhöht
echo ++$y; // Gibt 6 aus, $y ist bereits 6
echo $y; // 6
// Das gleiche für Dekrement (--)
$z = 5;
echo $z--; // 5, dann $z wird 4
echo --$z; // 3, $z wird zuerst 3
?>5.2 Zuweisungsoperatoren (= += -= etc.)
Einfache und kombinierte Zuweisung
php
<?php
// Einfache Zuweisung
$x = 10;
// Kombinierte Zuweisung
$x += 5; // Entspricht: $x = $x + 5; (jetzt $x = 15)
$x -= 3; // Entspricht: $x = $x - 3; (jetzt $x = 12)
$x *= 2; // Entspricht: $x = $x * 2; (jetzt $x = 24)
$x /= 4; // Entspricht: $x = $x / 4; (jetzt $x = 6)
$x %= 4; // Entspricht: $x = $x % 4; (jetzt $x = 2)
// String-Verknüpfung
$name = "Max";
$name .= " Müller"; // Entspricht: $name = $name . " Müller";
echo $name; // Max Müller
// Für Arrays
$arr = ["a", "b"];
$arr += [2 => "c"]; // Fügt Element hinzu, wenn Index nicht existiert
?>5.3 Vergleichsoperatoren (== != > < etc.)
Lose und strenge Vergleiche
php
<?php
$a = 42;
$b = "42";
// Lose Gleichheit (==) - Typ wird automatisch umgewandelt
var_dump($a == $b); // true (42 == "42" → 42 == 42)
// Strenge Gleichheit (===) - Typ wird NICHT umgewandelt
var_dump($a === $b); // false (Integer vs. String)
// Lose Ungleichheit (!=)
var_dump($a != $b); // false (sind gleich nach Typumwandlung)
// Strenge Ungleichheit (!==)
var_dump($a !== $b); // true (Typ ist unterschiedlich)
// Weitere Vergleichsoperatoren
var_dump($a > $b); // false (42 > 42 ist false)
var_dump($a >= $b); // true (42 >= 42 ist true)
var_dump($a < $b); // false
var_dump($a <= $b); // true
// Spaceship Operator (<=>) - PHP 7+
// Gibt -1, 0 oder 1 zurück
echo $a <=> $b; // 0 (gleich)
echo 40 <=> $b; // -1 (links kleiner)
echo 50 <=> $b; // 1 (links größer)
?>Wichtig: Immer === (strenge Gleichheit) verwenden, um unerwartete Fehler zu vermeiden!
5.4 Logische Operatoren (&& || !)
Logische Operatoren für Bedingungen
php
<?php
$alter = 25;
$hat_fuehrerschein = true;
// AND (&& oder and)
var_dump($alter >= 18 && $hat_fuehrerschein); // true (beide Bedingungen erfüllt)
// OR (|| oder or)
var_dump($alter >= 18 || $hat_fuehrerschein); // true (mindestens eine Bedingung erfüllt)
// NOT (!)
var_dump(!$hat_fuehrerschein); // false (Negation)
// XOR (exklusives ODER)
var_dump(true xor false); // true (genau eine Bedingung ist true)
var_dump(true xor true); // false (beide sind true)
// Praxisbeispiel
$ist_eingeloggt = true;
$ist_admin = false;
if ($ist_eingeloggt && $ist_admin) {
echo "Willkommen, Administrator!";
} elseif ($ist_eingeloggt) {
echo "Willkommen, Benutzer!";
} else {
echo "Bitte einloggen!";
}
?>Unterschied zwischen &&/|| und and/or
php
<?php
// Achtung: and/or haben niedrigere Priorität als &&/||
$result1 = true && false; // false
$result2 = true and false; // true!!! (Wegen Operatorpriorität)
// Warum?
// $result2 = true and false; wird interpretiert als:
// ($result2 = true) and false;
// $result2 wird zuerst true zugewiesen, dann kommt "and false"
// Sicherer: Klammern verwenden
$result3 = (true and false); // false
// Empfehlung: Immer && und || verwenden!
?>5.5 Ternärer Operator, Null-Koaleszenz-Operator
Ternärer Operator (Bedingung ? wahr : falsch)
php
<?php
$alter = 20;
// Klassisch mit if-else
if ($alter >= 18) {
$status = "volljährig";
} else {
$status = "minderjährig";
}
// Mit ternärem Operator (kürzer)
$status = ($alter >= 18) ? "volljährig" : "minderjährig";
echo $status; // volljährig
// Verschachtelter ternärer Operator (nicht empfohlen, schwer lesbar)
$note = 85;
$bewertung = ($note >= 90) ? "sehr gut" :
(($note >= 75) ? "gut" : "verbesserungswürdig");
// Besser: if-elseif-else verwenden für komplexe Bedingungen
?>Null-Koaleszenz-Operator (??) - PHP 7+
php
<?php
// Früher: Prüfen, ob Variable gesetzt ist
$name = isset($_GET['name']) ? $_GET['name'] : 'Gast';
// Mit Null-Koaleszenz-Operator (??)
$name = $_GET['name'] ?? 'Gast';
// Noch kürzer: Null-Koaleszenz-Operator-Kette
$name = $_GET['name'] ?? $_POST['name'] ?? 'Gast';
// Unterschied zwischen ?? und ?:
$var1 = null;
$var2 = "";
echo $var1 ?? "Standard"; // "Standard" (null wird ersetzt)
echo $var1 ?: "Standard"; // "Standard" (null ist falsy)
echo $var2 ?? "Standard"; // "" (leerer String wird NICHT ersetzt)
echo $var2 ?: "Standard"; // "Standard" (leerer String ist falsy)
?>5.6 Operatorpriorität
Reihenfolge der Auswertung
Operatorpriorität bestimmt, in welcher Reihenfolge Operatoren ausgewertet werden.
Prioritätsliste (hoch → niedrig):
++ --(Inkrement/Dekrement)**(Potenz - PHP 5.6+)!(logische Negation)* / %+ - .(Addition, Subtraktion, Verknüpfung)<< >>(Bit-Shift)< <= > >=== != === !==&(Bit-AND)^(Bit-XOR)|(Bit-OR)&&||? :(ternärer Operator)= += -= *= /= .= %= ...(Zuweisung)andxoror
php
<?php
// Beispiel: Was wird ausgewertet?
$result = 2 + 3 * 4; // 14 (nicht 20!)
// Erklärung: * hat höhere Priorität als +
$result2 = (2 + 3) * 4; // 20 (Klammern erzwingen Reihenfolge)
// Komplexes Beispiel
$x = 5;
$y = 10;
$z = $x++ + --$y * 2; // $z = 5 + 9 * 2 = 5 + 18 = 23
// Nach der Auswertung: $x = 6, $y = 9
// Empfehlung: Immer Klammern verwenden, um Klarheit zu schaffen!
$z_klar = ($x++) + ((--$y) * 2); // Viel lesbarer
?>5.7 Praxis: Einfacher Taschenrechner
Aufgabe: Erstellen Sie einen einfachen Taschenrechner mit PHP.
php
<?php
// Simuliere Formulareingaben
$zahl1 = 10;
$zahl2 = 5;
$operator = "+";
// Ergebnis berechnen
$ergebnis = 0;
switch ($operator) {
case '+':
$ergebnis = $zahl1 + $zahl2;
break;
case '-':
$ergebnis = $zahl1 - $zahl2;
break;
case '*':
$ergebnis = $zahl1 * $zahl2;
break;
case '/':
if ($zahl2 != 0) {
$ergebnis = $zahl1 / $zahl2;
} else {
$ergebnis = "Fehler: Division durch Null!";
}
break;
case '%':
$ergebnis = $zahl1 % $zahl2;
break;
default:
$ergebnis = "Ungültiger Operator!";
}
// Ausgabe
echo "<h2>Taschenrechner</h2>";
echo "$zahl1 $operator $zahl2 = <strong>$ergebnis</strong><br>";
// Erweiterter Taschenrechner mit ternärem Operator
$zahl3 = 7;
$zahl4 = 3;
// Größte Zahl finden
$max = ($zahl3 > $zahl4) ? $zahl3 : $zahl4;
echo "Die größere Zahl zwischen $zahl3 und $zahl4 ist: $max<br>";
// Kleinste Zahl finden
$min = ($zahl3 < $zahl4) ? $zahl3 : $zahl4;
echo "Die kleinere Zahl zwischen $zahl3 und $zahl4 ist: $min<br>";
// Mittelwert berechnen
$mittelwert = ($zahl3 + $zahl4) / 2;
echo "Mittelwert: $mittelwert<br>";
?>Zusammenfassung
In diesem Kapitel haben Sie:
- ✅ Arithmetische Operatoren (+, -, *, /, %, ++, --) verwendet
- ✅ Zuweisungsoperatoren (=, +=, -=, etc.) gelernt
- ✅ Vergleichsoperatoren (==, ===, !=, !==, >, <, etc.) verstanden
- ✅ Logische Operatoren (&&, ||, !) angewendet
- ✅ Ternären Operator und Null-Koaleszenz-Operator (??) kennengelernt
- ✅ Operatorpriorität verstanden
- ✅ Einen einfachen Taschenrechner erstellt
Nächstes Kapitel: Wir werden Ablaufsteuerung lernen (if/else, switch, Schleifen).
Übungsaufgaben:
- Schreiben Sie ein Skript, das prüft, ob eine Zahl gerade oder ungerade ist
- Berechnen Sie den Flächeninhalt eines Kreises (πr²)
- Verwenden Sie den ternären Operator, um die größte von drei Zahlen zu finden
- Erstellen Sie einen Taschenrechner mit Modulo-Operator
Häufige Fehler:
- ❌
==statt===verwenden → Immer===bevorzugen - ❌
$x = 5; $y = $x++ + ++$x;schreiben → Zu verwirrend, besser aufteilen - ❌
and/orstatt&&/||verwenden →&&/||haben höhere Priorität - ❌ Division vergessen →
10 / 3ergibt3.333..., nicht3!