# 4.5 Operatoren in PHP

Die meisten Operatoren werden Ihnen bekannt vorkommen. Achten Sie also auf die Operatoren, die PHP-spezifisch oder neu für Sie sind.

Hier erhalten Sie eine tabellarische Übersicht über die Operatoren. Vergleichen Sie diese Operatoren mit den Ihnen bekannten Operatoren aus der von Ihnen meistgenutzten Programmiersprache.

## Allgemeine Operatoren

Operator | Beschreibung
--- | ---
`.` | String-Verkettungsoperator
`=` | Zuweisungsoperator

## Rechenoperatoren

Operator | Beschreibung
--- | ---
`+` | Addition
`-` | Subtraktion
`*` | Multiplikation
`**` | Potentieren
`/` | Division
`%` | Modulo; Ergibt den Rest einer ganzzahligen Division

Der Operator "+" funktioniert auch für Arrays (als Array-Operator). Er "addiert" die Arrays indem er sie hintereinander hängt.

## Kombinierte Zuweisungsoperatoren

Operator | Beschreibung
--- | ---
`+=` | Addiert neuen Wert zum alten Wert.
`-=` | Zieht neuen Wert vom alten Wert ab.
`/=` | Teilt alten Wert durch den neuen Wert.
`*=` | Multipliziert alten und neuen Wert.
`%=` | Modulo vom alten und neuen Wert.
`.=` | Schreibt neuen Wert anhängend an den alten Wert.

## Inkrement- und Dekrement-Operatoren

Operator | Beschreibung
--- | ---
`$digit++` | Erhöht $digit um 1
`$digit--` | Verringert $digit um 1
`++$digit` | Erhöht $digit um 1, welche sofort auf die Variable geschrieben wird
`--$digit` | Verringert $digit um 1, welche sofort von der Variablen abgezogen wird

## Vergleichsoperatoren

Operator | Beschreibung
--- | ---
`==` | Prüft, ob Inhalt der Variablen gleich ist (ungeachtet des Typs)
`!=` | Prüft, ob Inhalt der Variablen ungleich ist (ungeachtet des Typs)
`===` | Prüft, ob Inhalt sowie Typ der Variablen gleich ist
`!==` | Prüft, ob Inhalt oder Typ der Variablen ungleich ist
`>` | Größer als…
`<` | Kleiner als…
`>=` | Größer oder gleich…
`<=` | Kleiner oder gleich…

## Logische Operatoren

UND

Operator | Beschreibung
--- | ---
`&&` | und-Verknüpfung z.B. `$a && $b` (`&&` hat Vorrang vor and)
`and` | und-Verknüpfung z.B. `$a and $b`

ODER

Operator | Beschreibung
--- | ---
`||` | oder-Verknüpfung z.B. `$a || $b` (`||` hat Vorrang vor or)
`or` | oder-Verknüpfung z.B. `$a or $b`

Weitere logische Operatoren

Operator | Beschreibung
--- | ---
`xor` | entweder-oder (aber nicht beide) z.B. `$a xor $b`
`!` | nicht-Operator z.B. `!$a`

Beispiel für die Reihenfolge

    $a && $b or $c;
    $a and $b || $c;

In diesem Beispiel ist die Rangfolge entscheidend. In der ersten Zeile ergibt die Gleichung `($a und $b) oder $c`, während die zweite Zeile `$a und ($b oder $c)` meint. `&&` ist somit höherrangiger als `and`, und `||` höherrangiger als `or`.

Merke: Zeichen (`&&`, `||`) sind höherrangiger als Worte (`und`, `oder`).

## Bitweise Operatoren

Bitweise Operatoren in PHP ermöglichen die direkte Manipulation der einzelnen Bits innerhalb der Binärdarstellung von Zahlen. Hier eine verständlichere Erläuterung ihrer Funktionen als Tabelle:

Operator | Beschreibung
--- | ---
`~` | Negation: kehrt alle Bits um: aus 0 wird 1 und umgekehrt.
`&` | Setzt ein Bit, wenn es in beiden Operanden gesetzt ist.
`|` | Setzt ein Bit, wenn es in mindestens einem Operanden gesetzt ist.
`^` | Setzt ein Bit, wenn es in genau einem der beiden Operanden gesetzt ist.
`>>` | Verschiebt Bits nach rechts, was der Division durch 2 entspricht.
`<<` | Verschiebt Bits nach links, was der Multiplikation mit 2 entspricht.

Diese Operatoren sind nützlich für Aufgaben, die eine direkte Kontrolle über die Binärdaten einer Zahl erfordern, wie zum Beispiel in der Kryptographie oder Datenkompression.

Hinweis

Auch ein `@` gilt als Operator. Er dient dazu, Fehler zu unterdrücken und dabei das Programm nicht abzubrechen. Das `@` muss vor der Funktion stehen, die ausgeführt werden soll: z.B. `@readfile("DATEI")`.

## Beispiele für Operatoren

In diesem Unterkapitel sehen Sie zwei Beispiele für den Einsatz von Operatoren.

Beispiel 1

    1
    2
    3
    4
    5
    6
    7
    8
    <?php
    $number = 5;
    $location = "Seminar";
    $location .= "raum";

    echo "$number Männer und ", --$number, " Frauen sitzen im $location.<br>";
    echo "Die Frauen sind im ", $number--, ". Semester<br>";
    echo "und $number Männer sind im ", $number*2, ". Semester.";

Ausgabe:
5 Männer und 4 Frauen sitzen im Seminarraum.
Die Frauen sind im 4. Semester
und 3 Männer sind im 6. Semester.

Beispiel 2

S202 S202 mit PHP 7.x S202 ab PHP 8.x

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    <?php
    $a = 202;
    $b = "S202"; // Buchstabe vorne

    if ($a == $b) {
        echo '$a und $b sind gleich!<br>';
    } else {
        echo '$a und $b sind NICHT gleich!<br>';
    }

    if ($a === $b) {
        echo '$a und $b sind identisch!<br>';
    } else {
        echo '$a und $b sind NICHT identisch!<br>';
    }

Ausgabe (wie wir es erwarten):
`$a` und `$b` sind NICHT gleich!
`$a` und `$b` sind NICHT identisch!

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    <?php
    $a = 202;
    $b = "202S"; // Buchstabe hinten

    if ($a == $b) {
        echo '$a und $b sind gleich!<br>';
    } else {
        echo '$a und $b sind NICHT gleich!<br>';
    }

    if ($a === $b) {
        echo '$a und $b sind identisch!<br>';
    } else {
        echo '$a und $b sind NICHT identisch!<br>';
    }

Ausgabe (so erwarten wir es nicht):
`$a` und `$b` sind gleich!
`$a` und `$b` sind NICHT identisch!

Die Umstellung erfolgte mit PHP 8.0. Das zugrunde liegende RFC heißt „String to Number Comparison" und änderte die Semantik der nicht-strikten Vergleichsoperatoren (`==`, `!=`, `<`, `>` etc.).

In PHP 7.x wurde bei `202 == "202S"` der String `"202S"` zunächst in eine Zahl konvertiert. Da er mit einer gültigen Ziffernfolge beginnt („leading numeric string"), wurde er zu `202` gecastet → `202 == 202` → `true`.

Seit PHP 8.0 gilt: Wenn der String nicht vollständig numerisch ist, wird stattdessen die Zahl in einen String konvertiert und ein String-Vergleich durchgeführt. Also wird `202` zu `"202"` gecastet → `"202" == "202S"` → `false`.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    <?php
    $a = 202;
    $b = "202S"; // Buchstabe hinten

    if ($a == $b) {
        echo '$a und $b sind gleich!<br>';
    } else {
        echo '$a und $b sind NICHT gleich!<br>';
    }

    if ($a === $b) {
        echo '$a und $b sind identisch!<br>';
    } else {
        echo '$a und $b sind NICHT identisch!<br>';
    }

Ausgabe (hier ist es wieder "richtig"):
`$a` und `$b` sind NICHT gleich!
`$a` und `$b` sind NICHT identisch!

Diese Beispiele demonstrieren den Unterschied zwischen Gleichheit (`==`) und Identität (`===`) in PHP, was besonders wichtig ist, wenn mit verschiedenen Datentypen gearbeitet wird.

Type Juggling ist auch in PHP 8 nicht harmlos

PHP 8 hat die gröbsten Stolperfallen bei `==` beseitigt und insbesondere liefert `0 == "text"` nun korrekt `false`. Dennoch bleibt der Vergleichsoperator `==` (gleich) bei gemischten Typen problematisch. Auch in PHP 8 ergeben diese Vergleiche `true`:

    if("0" == false)              // true
    if("" == null)                // true
    if(true == "beliebiger Text") // true
    if("42" == 42)                // true
    if("42.0" == 42)              // true

Empfehlung: Verwenden Sie grundsätzlich `===` (identisch) statt `==` (gleich), um unerwartetes Verhalten durch implizite Typkonvertierung zu vermeiden.