Operadores de comparación en PHP: == vs === y <=>

== comprueba si dos valores son iguales después de que PHP los convierta a un tipo común. === comprueba que sean iguales y del mismo tipo. Así, 1 == "1" es true, mientras que 1 === "1" es 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

La mayoría de los bugs con comparaciones vienen de que == convierte algo que no esperabas. Un buen hábito por defecto es === y !==, y pasar a == solo cuando sabes que quieres la conversión.

Todos los operadores de comparación de PHP

Tabla de comparación flexible y estricta

Cada celda de esta tabla la calculó PHP 8.3. Cambia entre == y === y toca una celda para ver la expresión. La cuadrícula de == está llena de sorpresas en las filas de null, "", "0" y []; la de === es solo su diagonal.

Cómo compara == tipos distintos

Las reglas que sigue PHP 8, en el orden en que importan en la práctica:

1. Dos cadenas numéricas se comparan como números: "10" == "1e1" y "1" == "01" son true.
2. Un número y una cadena numérica: la cadena se convierte en número. 100 == "1e2" es true.
3. Un número y una cadena no numérica: desde PHP 8, el número se convierte en cadena y se comparan como cadenas. 0 == "a" es false (era true en PHP 7).
4. Cualquier cosa y un bool: los dos lados se convierten a bool. "a" == true y [] == false son true.
5. null y una cadena: null se convierte en "", así que null == "" es true pero null == "0" es false. Frente a cualquier otro tipo, null se compara como false.
6. Dos arrays: son iguales cuando tienen los mismos pares clave/valor.

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

Esa última línea muestra por qué las comparaciones de orden con null rara vez tienen sentido: null se convierte en false, -1 en true, y false < true.

Distinto: != vs !==

!= y <> son el mismo operador. !== es la versión estricta. La diferencia importa sobre todo con funciones que devuelven 0 o false, como 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 es false porque 0 se convierte en false. 0 !== false es true porque un int no es un bool. La misma trampa se aplica a array_search y a in_array sin su opción estricta.

Comparar cadenas

< y > comparan cadenas byte a byte (en orden alfabético para ASCII simple). Si las dos cadenas son numéricas, se comparan como números. Para un orden sin distinguir mayúsculas o un orden "natural", usa las funciones:

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

El operador nave espacial <=>

$a <=> $b devuelve -1 cuando $a es menor, 0 cuando son iguales y 1 cuando $a es mayor. Usa las mismas reglas que < y ==, y es la forma más corta de escribir un callback de ordenación.

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

Comparar dos arrays con <=> los compara elemento a elemento, y así es como el callback ordena primero por edad y después por nombre. Hay más recetas de ordenación en la página de ordenar arrays.

Error frecuente: comparar floats con ==

Los floats se guardan en binario, así que muchos valores decimales son aproximaciones. 0.1 + 0.2 no es exactamente 0.3, y == ve la diferencia.

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

Para dinero, guarda céntimos enteros como integers y compáralos con ===.