Operadores de comparação PHP: == ou === e <=>

== verifica se dois valores são iguais depois que o PHP os converte para um tipo comum. === verifica se eles são iguais e do mesmo tipo. Então 1 == "1" é true, enquanto 1 === "1" é 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

A maioria dos bugs em comparações vem de um == convertendo algo que você não esperava. Um bom padrão é === e !==, passando para == só quando você sabe que quer a conversão.

Todos os operadores de comparação do PHP

Tabela de comparação frouxa e estrita

Cada célula desta tabela foi calculada pelo PHP 8.3. Alterne entre == e === e toque numa célula para ver a expressão. A grade do == está cheia de surpresas nas linhas de null, "", "0" e []; a grade do === é só a diagonal.

Como o == compara tipos diferentes

As regras que o PHP 8 segue, na ordem em que importam na prática:

1. Duas strings numéricas são comparadas como números: "10" == "1e1" e "1" == "01" são ambos true.
2. Um número e uma string numérica: a string vira número. 100 == "1e2" é true.
3. Um número e uma string não numérica: desde o PHP 8, o número vira string e os dois são comparados como strings. 0 == "a" é false (era true no PHP 7).
4. Qualquer coisa e um bool: os dois lados são convertidos para bool. "a" == true e [] == false são true.
5. null e uma string: null vira "", então null == "" é true mas null == "0" é false. Contra qualquer outro tipo, null é comparado como false.
6. Dois arrays: iguais quando têm os mesmos pares chave/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

A última linha mostra por que comparações de ordem com null raramente fazem sentido: null vira false, -1 vira true, e false < true.

Diferente: != ou !==

!= e <> são o mesmo operador. !== é a versão estrita. A diferença importa mais com funções que retornam 0 ou 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 é false porque 0 vira false. 0 !== false é true porque um int não é um bool. A mesma armadilha vale para array_search e para in_array sem o parâmetro strict.

Comparar strings

< e > comparam strings byte a byte (em ordem alfabética para ASCII simples). Se as duas strings forem numéricas, elas são comparadas como números. Para ordem sem diferenciar maiúsculas ou ordem "natural", use as funções:

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

O operador spaceship <=>

$a <=> $b retorna -1 quando $a é menor, 0 quando são iguais e 1 quando $a é maior. Ele usa as mesmas regras de < e ==, e é o jeito mais curto de escrever um callback de ordenação.

<?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 dois arrays com <=> compara elemento por elemento, e é assim que o callback ordena primeiro por idade e depois por nome. Mais receitas de ordenação estão na página sobre ordenar arrays.

Erro comum: comparar floats com ==

Floats são guardados em binário, então muitos valores decimais são aproximações. 0.1 + 0.2 não é exatamente 0.3, e o == enxerga a diferença.

<?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 dinheiro, guarde centavos inteiros como integers e compare-os com ===.