PHP Vergleichsoperatoren: == vs === und <=>

== prüft, ob zwei Werte gleich sind, nachdem PHP sie in einen gemeinsamen Typ umgewandelt hat. === prüft, ob sie gleich und vom selben Typ sind. Also ist 1 == "1" gleich true, während 1 === "1" gleich false ist.

<?php
var_dump(1 == "1");      // same value after conversion
var_dump(1 === "1");     // int vs string
var_dump(0 == false);
var_dump(0 === false);
var_dump(null == false);
var_dump("abc" == "ABC"); // case matters

Die meisten Bugs bei Vergleichen entstehen, weil == etwas umwandelt, womit du nicht gerechnet hast. Ein guter Standard ist === und !==; wechsle nur dann zu ==, wenn du die Umwandlung bewusst willst.

Alle Vergleichsoperatoren in PHP

Tabelle für lockeren und strikten Vergleich

Jede Zelle dieser Tabelle wurde von PHP 8.3 berechnet. Wechsle zwischen == und === und tippe auf eine Zelle, um den Ausdruck zu sehen. Das Raster für == steckt voller Überraschungen in den Zeilen für null, "", "0" und []; das Raster für === ist nur seine Diagonale.

Wie == verschiedene Typen vergleicht

Die Regeln, denen PHP 8 folgt, in der Reihenfolge, in der sie in der Praxis zählen:

1. Zwei numerische Strings werden als Zahlen verglichen: "10" == "1e1" und "1" == "01" sind beide true.
2. Eine Zahl und ein numerischer String: Der String wird zur Zahl. 100 == "1e2" ist true.
3. Eine Zahl und ein nicht numerischer String: Seit PHP 8 wird die Zahl zum String, und beide werden als Strings verglichen. 0 == "a" ist false (in PHP 7 war es true).
4. Irgendetwas und ein Bool: Beide Seiten werden in bool umgewandelt. "a" == true und [] == false sind true.
5. null und ein String: null wird zu "", also ist null == "" gleich true, aber null == "0" gleich false. Gegenüber jedem anderen Typ wird null wie false verglichen.
6. Zwei Arrays: gleich, wenn sie dieselben Schlüssel/Wert-Paare haben.

<?php
var_dump("10" == "1e1");   // both numeric strings
var_dump("1" == "01");
var_dump(100 == "1e2");
var_dump(0 == "a");        // false since PHP 8
var_dump("1" == " 1");     // whitespace around a number is allowed
var_dump([] == false);     // empty array is falsy
var_dump(null == "0");     // null becomes "", and "" is not "0"
var_dump(null < -1);       // null and -1 become false < true

Die letzte Zeile zeigt, warum Größenvergleiche mit null selten sinnvoll sind: null wird zu false, -1 wird zu true, und false < true.

Ungleich: != vs !==

!= und <> sind derselbe Operator. !== ist die strikte Version. Der Unterschied zählt am meisten bei Funktionen, die 0 oder false zurückgeben, etwa strpos:

<?php
$text = "php is fun";
$pos = strpos($text, "php");   // found at position 0

if ($pos != false) {
    echo "!= says found\n";
} else {
    echo "!= says NOT found (wrong)\n";
}

if ($pos !== false) {
    echo "!== says found at $pos\n";
}

0 != false ist false, weil 0 in false umgewandelt wird. 0 !== false ist true, weil ein int kein bool ist. Dieselbe Falle gilt für array_search und für in_array ohne sein Strict-Flag.

Strings vergleichen

< und > vergleichen Strings Byte für Byte (bei reinem ASCII alphabetisch). Wenn beide Strings numerisch sind, werden sie als Zahlen verglichen. Für Vergleiche ohne Groß- und Kleinschreibung oder in „natürlicher“ Reihenfolge nimmst du die Funktionen:

<?php
var_dump("apple" < "banana");
var_dump("10" < "9");      // both numeric: 10 < 9
var_dump("10" < "9a");     // not both numeric: compared as text

var_dump(strcmp("a", "b"));            // < 0
var_dump(strcasecmp("HELLO", "hello")); // 0 means equal
var_dump(strnatcmp("img12", "img10"));  // natural order

Der Spaceship-Operator <=>

$a <=> $b liefert -1, wenn $a kleiner ist, 0, wenn beide gleich sind, und 1, wenn $a größer ist. Er folgt denselben Regeln wie < und == und ist der kürzeste Weg, einen Sortier-Callback zu schreiben.

<?php
var_dump(1 <=> 2, 2 <=> 2, 3 <=> 2);
var_dump("a" <=> "b");
var_dump([1, 2] <=> [1, 3]);

$people = [
    ["name" => "Ada", "age" => 36],
    ["name" => "Linus", "age" => 28],
    ["name" => "Grace", "age" => 85],
];

// sort by age, then by name
usort($people, fn($a, $b) => [$a["age"], $a["name"]] <=> [$b["age"], $b["name"]]);
echo implode(", ", array_column($people, "name")), "\n";

Zwei Arrays mit <=> zu vergleichen, vergleicht sie Element für Element, und so sortiert der Callback zuerst nach Alter und dann nach Name. Weitere Sortierrezepte stehen auf der Seite zum Sortieren von Arrays.

Typischer Fehler: Floats mit == vergleichen

Floats werden binär gespeichert, deshalb sind viele Dezimalwerte nur Näherungen. 0.1 + 0.2 ist nicht genau 0.3, und == sieht den Unterschied.

<?php
$sum = 0.1 + 0.2;

var_dump($sum == 0.3);
var_dump($sum);

// Compare with a tolerance
var_dump(abs($sum - 0.3) < PHP_FLOAT_EPSILON);

// Or round to the precision you need, e.g. money in cents
var_dump(round($sum, 2) == round(0.3, 2));

Für Geldbeträge speicherst du ganze Cent als Ganzzahlen und vergleichst diese mit ===.