PHP Comparison Operators: == vs === and <=>

== checks whether two values are equal after PHP converts them to a common type. === checks that they are equal and of the same type. So 1 == "1" is true, while 1 === "1" is false.

<?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

Most bugs with comparisons come from == converting something you did not expect. A good default is === and !==, switching to == only when you know you want the conversion.

All PHP comparison operators

Loose and strict comparison table

Every cell of this table was computed by PHP 8.3. Switch between == and === and tap a cell to see the expression. The == grid is full of surprises in the rows for null, "", "0" and []; the === grid is just its diagonal.

How == compares different types

The rules PHP 8 follows, in the order they matter in practice:

1. Two numeric strings are compared as numbers: "10" == "1e1" and "1" == "01" are both true.
2. A number and a numeric string: the string becomes a number. 100 == "1e2" is true.
3. A number and a non-numeric string: since PHP 8, the number becomes a string and they are compared as strings. 0 == "a" is false (it was true in PHP 7).
4. Anything and a bool: both sides are converted to bool. "a" == true and [] == false are true.
5. null and a string: null becomes "", so null == "" is true but null == "0" is false. Against any other type, null is compared as false.
6. Two arrays: equal when they have the same key/value pairs.

<?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

That last line shows why ordering comparisons with null are rarely meaningful: null becomes false, -1 becomes true, and false < true.

Not equal: != vs !==

!= and <> are the same operator. !== is the strict version. The difference matters most with functions that return 0 or false, like 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 is false because 0 converts to false. 0 !== false is true because an int is not a bool. The same trap applies to array_search and in_array without its strict flag.

Compare strings

< and > compare strings byte by byte (alphabetically for plain ASCII). If both strings are numeric, they are compared as numbers. For case-insensitive or "natural" order use the functions:

<?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

The spaceship operator <=>

$a <=> $b returns -1 when $a is smaller, 0 when they are equal and 1 when $a is larger. It uses the same rules as < and ==, and it is the shortest way to write a sort callback.

<?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";

Comparing two arrays with <=> compares them element by element, which is how the callback sorts by age first and name second. More sorting recipes are on the sort arrays page.

Common mistake: comparing floats with ==

Floats are stored in binary, so many decimal values are approximations. 0.1 + 0.2 is not exactly 0.3, and == sees the difference.

<?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));

For money, store whole cents as integers and compare those with ===.