8 Operatoren und Ausdrücke

<?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)
echo $a % $b;    // 1 (Modulo - Rest der Division)
echo $a ** $b;   // 1000 (Potenzierung, seit PHP 5.6)

// Negation
echo -$a;        // -10 (Vorzeichenumkehr)
?>

<?php
// Prüfen, ob eine Zahl gerade ist
$istGerade = ($zahl % 2 == 0);

// Für negative Zahlen folgt der Modulo-Operator in PHP dem Vorzeichen des Dividenden
echo -10 % 3;    // -1 (nicht 2)
echo 10 % -3;    // 1
?>

<?php
echo intdiv(10, 3);    // 3 (Integer-Division)
?>

<?php
$a = 10;    // Weist $a den Wert 10 zu
?>

<?php
$a = 10;

$a += 5;      // Äquivalent zu: $a = $a + 5;  (Ergebnis: 15)
$a -= 3;      // Äquivalent zu: $a = $a - 3;  (Ergebnis: 12)
$a *= 2;      // Äquivalent zu: $a = $a * 2;  (Ergebnis: 24)
$a /= 4;      // Äquivalent zu: $a = $a / 4;  (Ergebnis: 6)
$a %= 4;      // Äquivalent zu: $a = $a % 4;  (Ergebnis: 2)
$a **= 3;     // Äquivalent zu: $a = $a ** 3; (Ergebnis: 8)

// Für Strings:
$str = "Hallo";
$str .= " Welt";   // Äquivalent zu: $str = $str . " Welt"; (Ergebnis: "Hallo Welt")
?>

<?php
$a = 10;
$b =& $a;    // $b ist nun eine Referenz auf $a
$b = 20;     // Ändert auch $a auf 20
echo $a;     // 20
?>

<?php
$a = 5;
$b = '5';
$c = 10;

// Gleichheitsvergleiche
var_dump($a == $b);   // bool(true) - Gleich (Wert wird verglichen, Typ wird konvertiert)
var_dump($a === $b);  // bool(false) - Identisch (Wert UND Typ müssen gleich sein)
var_dump($a != $b);   // bool(false) - Ungleich (Wert wird verglichen, Typ wird konvertiert)
var_dump($a <> $b);   // bool(false) - Alternative Syntax für !=
var_dump($a !== $b);  // bool(true) - Nicht identisch (entweder Wert ODER Typ sind ungleich)

// Größenvergleiche
var_dump($a < $c);    // bool(true) - Kleiner als
var_dump($a > $c);    // bool(false) - Größer als
var_dump($a <= $c);   // bool(true) - Kleiner oder gleich
var_dump($a >= $c);   // bool(false) - Größer oder gleich

// Raumschiff-Operator (seit PHP 7.0)
echo $a <=> $c;       // -1 (wenn $a < $c)
echo $c <=> $a;       // 1 (wenn $c > $a)
echo $a <=> $a;       // 0 (wenn $a == $a)
?>

<?php
var_dump(0 == "0");       // bool(true)
var_dump(0 == "");        // bool(true)
var_dump(0 == false);     // bool(true)
var_dump("0" == false);   // bool(true)

// Für strikte Vergleiche immer === verwenden
var_dump(0 === "0");      // bool(false)
var_dump(0 === false);    // bool(false)
?>

<?php
$a = true;
$b = false;

// Logisches UND
var_dump($a && $b);   // bool(false)
var_dump($a and $b);  // bool(false) - Alternative Syntax, niedrigere Präzedenz

// Logisches ODER
var_dump($a || $b);   // bool(true)
var_dump($a or $b);   // bool(true) - Alternative Syntax, niedrigere Präzedenz

// Logisches XOR (Exklusives ODER)
var_dump($a xor $b);  // bool(true) - Wahr, wenn entweder $a oder $b wahr ist, aber nicht beide

// Logisches NICHT
var_dump(!$a);        // bool(false)
?>

<?php
// Bei && wird der zweite Ausdruck nur ausgewertet, wenn der erste wahr ist
$a = false && funktionMitNebenwirkung();  // funktionMitNebenwirkung() wird nicht aufgerufen

// Bei || wird der zweite Ausdruck nur ausgewertet, wenn der erste falsch ist
$b = true || funktionMitNebenwirkung();   // funktionMitNebenwirkung() wird nicht aufgerufen
?>

<?php
// Diese beiden Ausdrücke werden unterschiedlich ausgewertet
$a = false || true;    // $a ist true
$b = false or true;    // $b ist false, weil die Zuweisung eine höhere Präzedenz hat

$c = true && false;    // $c ist false
$d = true and false;   // $d ist true, weil die Zuweisung eine höhere Präzedenz hat
?>

<?php
$a = 5;    // 101 in Binär
$b = 3;    // 011 in Binär

// Bitweises UND
echo $a & $b;    // 1 (001 in Binär)

// Bitweises ODER
echo $a | $b;    // 7 (111 in Binär)

// Bitweises XOR
echo $a ^ $b;    // 6 (110 in Binär)

// Bitweise Negation
echo ~$a;        // -6 (in Zweierkomplementdarstellung)

// Bitweise Verschiebung nach links
echo $a << 1;    // 10 (1010 in Binär)

// Bitweise Verschiebung nach rechts
echo $a >> 1;    // 2 (10 in Binär)
?>

<?php
// Konkatenation (Verkettung)
$a = "Hallo";
$b = "Welt";
echo $a . $b;         // "HelloWelt"
echo $a . " " . $b;   // "Hello Welt"

// Konkatenation mit Zuweisung
$a .= " " . $b;       // Äquivalent zu: $a = $a . " " . $b;
echo $a;              // "Hallo Welt"
?>

<?php
$a = ["name" => "Max", "alter" => 30];
$b = ["stadt" => "Berlin", "name" => "Moritz"];

// Union-Operator
$c = $a + $b;  // Bei gleichen Schlüsseln behält der linke (erste) Operand den Wert
/*
$c enthält: [
    "name" => "Max",       // Aus $a, nicht überschrieben
    "alter" => 30,         // Aus $a
    "stadt" => "Berlin"    // Aus $b
]
*/

// Vergleichsoperatoren
var_dump($a == $b);   // bool(false) - Gleich (gleiche Schlüssel-Wert-Paare)
var_dump($a === $b);  // bool(false) - Identisch (gleiche Schlüssel-Wert-Paare in gleicher Reihenfolge und vom gleichen Typ)
var_dump($a != $b);   // bool(true) - Ungleich
var_dump($a <> $b);   // bool(true) - Alternative Syntax für !=
var_dump($a !== $b);  // bool(true) - Nicht identisch
?>

<?php
$a = 5;

// Post-Inkrement
echo $a++;    // 5 (gibt den alten Wert zurück, dann erhöht)
echo $a;      // 6

// Pre-Inkrement
echo ++$a;    // 7 (erhöht zuerst, dann gibt den neuen Wert zurück)

// Post-Dekrement
echo $a--;    // 7 (gibt den alten Wert zurück, dann verringert)
echo $a;      // 6

// Pre-Dekrement
echo --$a;    // 5 (verringert zuerst, dann gibt den neuen Wert zurück)
?>

<?php
$str = 'a';
echo ++$str;    // 'b' (Inkrementiert zum nächsten Buchstaben)

$str = 'z';
echo ++$str;    // 'aa' (nach 'z' kommt 'aa')

$str = 'A9';
echo ++$str;    // 'B0' (inkrementiert den ersten Charakter, der zweite wird zurückgesetzt)
?>

<?php
// Syntax: Bedingung ? Wert_wenn_wahr : Wert_wenn_falsch
$alter = 20;
$status = ($alter >= 18) ? "erwachsen" : "minderjährig";
echo $status;    // "erwachsen"

// Verschachtelte ternäre Operatoren (können unübersichtlich werden)
$status = ($alter < 13) ? "Kind" : (($alter < 18) ? "Teenager" : "Erwachsener");
?>

<?php
// Vor PHP 7.0 (unsicher wegen Notices)
$username = isset($_GET['user']) ? $_GET['user'] : 'Gast';

// Ab PHP 7.0 (kurz und sicher)
$username = $_GET['user'] ?? 'Gast';

// Verkettung mehrerer Operatoren
$username = $_GET['user'] ?? $_POST['user'] ?? 'Gast';
?>

<?php
// Vor PHP 7.4
$username = $username ?? 'Gast';

// Ab PHP 7.4
$username ??= 'Gast';
?>

<?php
// Vor PHP 8.0 (umständlich)
$land = ($benutzer !== null && $benutzer->getAdresse() !== null) 
    ? $benutzer->getAdresse()->getLand() 
    : null;

// Ab PHP 8.0 (elegant und sicher)
$land = $benutzer?->getAdresse()?->getLand();
?>

<?php
class Fahrzeug {}
class Auto extends Fahrzeug {}

$meinAuto = new Auto();

var_dump($meinAuto instanceof Auto);     // bool(true)
var_dump($meinAuto instanceof Fahrzeug); // bool(true)
var_dump($meinAuto instanceof stdClass); // bool(false)
?>

<?php
// Nicht empfohlen - Sicherheitsrisiko!
$ausgabe = `ls -la`;
echo $ausgabe;

// Bessere Alternative
$ausgabe = shell_exec('ls -la');
// oder
$ausgabe = system('ls -la');
?>

<?php
// Ohne Fehlerunterdrückung würde dies eine Warnung erzeugen, wenn die Datei nicht existiert
$inhalt = @file_get_contents('nicht_existierende_datei.txt');
?>

<?php
// Präzedenz-Beispiel
echo 5 + 3 * 2;         // 11 (nicht 16), weil * eine höhere Präzedenz hat als +

// Assoziativität-Beispiel (left-to-right)
echo 10 / 5 / 2;        // 1 (nicht 4), weil 10/5 = 2, dann 2/2 = 1

// Verwendung von Klammern zur expliziten Steuerung der Auswertungsreihenfolge
echo (5 + 3) * 2;       // 16
?>

<?php
$status = 2;

// Switch-Statement (traditionell)
switch ($status) {
    case 1:
        $message = "Aktiv";
        break;
    case 2:
        $message = "Inaktiv";
        break;
    default:
        $message = "Unbekannt";
        break;
}

// Match-Ausdruck (seit PHP 8.0)
$message = match ($status) {
    1 => "Aktiv",
    2 => "Inaktiv",
    default => "Unbekannt",
};

// Mehrere Werte pro Arm
$message = match ($status) {
    1, 3, 5 => "Aktiv",
    2, 4, 6 => "Inaktiv",
    default => "Unbekannt",
};

// Ausdrücke als Bedingungen
$message = match (true) {
    $status >= 100 => "Kritisch",
    $status >= 50 => "Warnung",
    $status >= 0 => "Normal",
    default => "Ungültig",
};
?>

<?php
// Komplexer arithmetischer Ausdruck
$result = 5 * (10 + 3) / 2 - 4;

// Komplexer logischer Ausdruck
$isValid = ($age >= 18 && $hasConsent) || ($isSpecialCase && $hasPermission);

// Komplexer Array-Manipulationsausdruck
$filteredData = array_filter(
    array_map(
        fn($item) => $item * 2, 
        array_values($sourceArray)
    ),
    fn($item) => $item > 10
);
?>