Operatoren

Geschätzte Lektüre: 12 Minuten 454 Ansichten

Operatoren sind grundlegende Bausteine in PHP, mit denen Sie Operationen auf Variablen und Werten durchführen können. In dieser Anleitung werden wir alle wichtigen PHP-Operatoren detailliert erklären, mit verständlichen Beispielen illustrieren und praktische Anwendungsfälle zeigen.

Arithmetische Operatoren

Arithmetische Operatoren werden für mathematische Berechnungen verwendet.

Grundlegende arithmetische Operatoren:

$a = 10;
$b = 3;

// Addition (+)
$summe = $a + $b; // 13

// Subtraktion (-)
$differenz = $a - $b; // 7

// Multiplikation (*)
$produkt = $a * $b; // 30

// Division (/)
$quotient = $a / $b; // 3.333...

// Modulus (Rest der Division) (%)
$rest = $a % $b; // 1 (10 ÷ 3 = 3 mit Rest 1)

// Potenzierung (**)
$potenz = $a ** $b; // 1000 (10 hoch 3)

Zuweisungsoperatoren

Diese Operatoren weisen Variablen Werte zu.

$x = 5; // weist $x den Wert 5 zu

// Kombinierte Zuweisungsoperatoren:

$a = 10;

$a += 5;  // $a = $a + 5; → 15
$a -= 3;  // $a = $a - 3; → 12
$a *= 2;  // $a = $a * 2; → 24
$a /= 4;  // $a = $a / 4; → 6
$a %= 4;  // $a = $a % 4; → 2
$a **= 3; // $a = $a ** 3; → 8

Inkrement- und Dekrementoperatoren

Diese Operatoren erhöhen oder verringern einen Wert um 1.

// Prä-Inkrement (++ vor der Variable):
$a = 5;
$b = ++$a; // $a wird zuerst auf 6 erhöht, dann $b zugewiesen
echo "a: $a, b: $b"; // a: 6, b: 6




// Post-Inkrement (++ nach der Variable):
$a = 5;
$b = $a++; // $b erhält zuerst den Wert 5, dann wird $a auf 6 erhöht
echo "a: $a, b: $b"; // a: 6, b: 5



// Prä- und Post-Dekrement (--):
$a = 5;
$b = --$a; // a: 4, b: 4

$a = 5;
$b = $a--; // a: 4, b: 5

Vergleichsoperatoren

Diese Operatoren vergleichen Werte und geben einen booleschen Wert (true/false) zurück.

// Gleichheitsoperatoren:
$a = 5;
$b = "5";

// Gleich (nur Wert)
var_dump($a == $b);  // true

// Identisch (Wert und Typ)
var_dump($a === $b); // false

// Ungleich (nur Wert)
var_dump($a != $b);  // false

// Nicht identisch (Wert oder Typ unterschiedlich)
var_dump($a !== $b); // true



// Größer/Kleiner-Operatoren:
$a = 10;
$b = 5;

var_dump($a > $b);  // true
var_dump($a < $b);  // false
var_dump($a >= $b); // true
var_dump($a <= $b); // false

Logische Operatoren

Diese Operatoren werden verwendet, um Bedingungen zu kombinieren.

// Grundlegende logische Operatoren:
$wahr = true;
$falsch = false;

// UND (beide müssen true sein)
var_dump($wahr && $falsch); // false
var_dump($wahr and $falsch); // false (and hat niedrigere Priorität)

// ODER (mindestens einer true)
var_dump($wahr || $falsch); // true
var_dump($wahr or $falsch); // true (or hat niedrigere Priorität)

// XOR (genau einer true)
var_dump($wahr xor $falsch); // true
var_dump($wahr xor true);    // false

// NICHT
var_dump(!$wahr); // false





// Anwendungsfall: Komplexe Bedingungen:
$alter = 25;
$mitglied = true;
$guthaben = 50;

if ($alter >= 18 && ($mitglied || $guthaben >= 100)) {
    echo "Zugang zum Premium-Bereich gewährt";
} else {
    echo "Zugang verweigert";
}

String-Operatoren

Für die Manipulation von Zeichenketten (Strings).

// Verkettungsoperator (.)
$vorname = "Max";
$nachname = "Mustermann";
$vollname = $vorname . " " . $nachname; // "Max Mustermann"


// Kombinierter Verkettungsoperator (.=)
$text = "Hallo";
$text .= " Welt!"; // "Hallo Welt!"



// Anwendungsfall: Dynamische Nachrichtenerstellung:
$produkt = "Buch";
$preis = 19.99;
$nachricht = "Das Produkt \"" . $produkt . "\" kostet " . $preis . "€.";
echo $nachricht; // Das Produkt "Buch" kostet 19.99€.

Array-Operatoren

// Grundlegende Array-Operatoren:
$a = [1, 2, 3];
$b = ["a", "b", "c"];

// Vereinigung (+)
$c = $a + $b; // [1, 2, 3] (bei gleichen Schlüsseln wird der Wert von $a behalten)

// Gleichheit
var_dump($a == $b);  // false (gleiche Schlüssel/Wert-Paare)
var_dump($a === $b); // false (gleiche Schlüssel/Wert-Paare in gleicher Reihenfolge und Typ)

// Identisch
$d = [1, 2, 3];
var_dump($a === $d); // true




// Anwendungsfall: Standardwerte mit Array-Union:
$standard = [
    'farbe' => 'blau',
    'groesse' => 'M',
    'menge' => 1
];

$benutzerwahl = [
    'farbe' => 'rot',
    'menge' => 2
];

$ergebnis = $benutzerwahl + $standard;
print_r($ergebnis);
/*
Array
(
    [farbe] => rot
    [menge] => 2
    [groesse] => M
)
*/

Typ-Operatoren

Für die Überprüfung von Objekttypen.

// instanceof
class Hund {}
class Katze {}

$tier = new Hund();

var_dump($tier instanceof Hund);  // true
var_dump($tier instanceof Katze); // false




// Anwendungsfall: Polymorphismus:
interface Tier {
    public function macheGeraeusch();
}

class Hund implements Tier {
    public function macheGeraeusch() {
        return "Wuff!";
    }
}

class Katze implements Tier {
    public function macheGeraeusch() {
        return "Miau!";
    }
}

function tierGeraeusch(Tier $tier) {
    if ($tier instanceof Hund) {
        echo "Der Hund sagt: ";
    } elseif ($tier instanceof Katze) {
        echo "Die Katze sagt: ";
    }
    echo $tier->macheGeraeusch();
}

$hund = new Hund();
tierGeraeusch($hund); // Der Hund sagt: Wuff!

Bit-Operatoren

Für Operationen auf Bit-Ebene (fortgeschritten).

// Grundlegende Bit-Operatoren:
$a = 0b1010; // 10
$b = 0b1100; // 12

// AND (&)
var_dump(decbin($a & $b)); // "1000" (8)

// OR (|)
var_dump(decbin($a | $b)); // "1110" (14)

// XOR (^)
var_dump(decbin($a ^ $b)); // "0110" (6)

// NOT (~)
var_dump(decbin(~$a)); // abhängig von der Systemarchitektur

// Links-Shift (<<)
var_dump(decbin($a << 2)); // "101000" (40)

// Rechts-Shift (>>)
var_dump(decbin($a >> 1)); // "0101" (5)

Fehlerkontrolloperator

Unterdrückt Fehlermeldungen.

@-Operator

// Ohne @ würde ein Fehler angezeigt werden, wenn die Datei nicht existiert
$inhalt = @file_get_contents('nicht_existierende_datei.txt');
if ($inhalt === false) {
    echo "Datei konnte nicht gelesen werden.";
}

Wichtiger Hinweis: Der @-Operator sollte sparsam verwendet werden, da er die Fehlerbehandlung erschwert. Besser ist eine ordentliche Fehlerbehandlung mit try-catch-Blöcken oder expliziten Prüfungen.

Ausführungsoperator

Führt Shell-Befehle aus.

Backticks (` `)

$output = `ls -la`; // Listet Verzeichnisinhalte auf Unix-Systemen
echo "<pre>$output</pre>";

Hinweis: Diese Funktion ist oft aus Sicherheitsgründen deaktiviert und sollte mit Vorsicht verwendet werden.

Null-Koaleszenz-Operatoren

Einfache Überprüfung auf NULL.

// Null-Koaleszenz (??)
$username = $_GET['user'] ?? 'Gast';
// Äquivalent zu:
// $username = isset($_GET['user']) ? $_GET['user'] : 'Gast';



// Null-Koaleszenz-Zuweisung (??=) (ab PHP 7.4)
$options['timeout'] ??= 30;
// Setzt $options['timeout'] auf 30, wenn es nicht gesetzt oder null ist

Spaceship-Operator (<=>)

Für dreiseitige Vergleiche

// Spaceship-Operator
var_dump(2 <=> 1); // 1 (weil 2 > 1)
var_dump(1 <=> 1); // 0 (weil 1 == 1)
var_dump(1 <=> 2); // -1 (weil 1 < 2)



// Anwendungsfall: Sortierfunktionen:
$zahlen = [3, 1, 4, 1, 5, 9, 2];
usort($zahlen, function($a, $b) {
    return $a <=> $b;
});
print_r($zahlen); // [1, 1, 2, 3, 4, 5, 9]

Ternärer Operator (?:)

Der ternäre Operator ist eine kompakte Alternative zur einfachen if-else-Struktur.

// Grundsyntax:
$bedingung ? $wert_wenn_wahr : $wert_wenn_falsch;


// Beispiel:
$alter = 20;
$status = ($alter >= 18) ? "volljährig" : "minderjährig";
echo $status; // Ausgabe: "volljährig"



// Anwendungsfall:
$punkte = 85;
$note = ($punkte >= 90) ? "A" : 
        (($punkte >= 80) ? "B" : 
        (($punkte >= 70) ? "C" : "D"));
echo "Deine Note: $note"; // Ausgabe: "Deine Note: B"

Operator-Präzedenz

Operatoren haben unterschiedliche Prioritäten, die bestimmen, in welcher Reihenfolge sie ausgewertet werden. Hier eine vereinfachte Reihenfolge (von hoch nach niedrig):

• clone, new
• **
• ++, –, ~, (int), (string), etc. (Typumwandlung), @
• *, /, %
• +, -, .
• <<, >>
• <, <=, >, >=
• ==, !=, ===, !==, <>, <=>
• &
• ^
• |
• &&
• ||
• ??
• ?: (ternärer Operator)
• =, +=, -=, etc.
• and
• xor
• or

Beispiel für Präzedenz:

$result = 2 + 3 * 4; // 14 (nicht 20), weil * vor + ausgewertet wird
$result = (2 + 3) * 4; // 20, wegen Klammern

Best Practices im Umgang mit Operatoren

  1. Klammern für Klarheit: Selbst wenn nicht nötig, können Klammern den Code lesbarer machen.
  2. Konsistente Formatierung: Halten Sie Leerzeichen um Operatoren konsistent.
  3. Typen beachten: PHP ist schwach typisiert – seien Sie sich der impliziten Typumwandlungen bewusst.
  4. Strikte Vergleiche: Verwenden Sie === und !== statt == und !=, wo möglich.
  5. Fehlerbehandlung: Vermeiden Sie den übermäßigen Gebrauch des @-Operators.
Dieses Dokument teilen

Operatoren

Oder Link kopieren

INHALT

Abonnieren

×
Cancel