Opérateurs de comparaison PHP : == ou === et <=>

== vérifie si deux valeurs sont égales après que PHP les a converties vers un type commun. === vérifie qu'elles sont égales et du même type. Donc 1 == "1" vaut true, alors que 1 === "1" vaut 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 plupart des bugs de comparaison viennent de == qui convertit quelque chose d'inattendu. Un bon choix par défaut est === et !==, en passant à == seulement quand vous savez que vous voulez la conversion.

Tous les opérateurs de comparaison PHP

Tableau des comparaisons souples et strictes

Chaque case de ce tableau a été calculée par PHP 8.3. Basculez entre == et === et touchez une case pour voir l'expression. La grille == est pleine de surprises dans les lignes null, "", "0" et [] ; la grille === se réduit à sa diagonale.

Comment == compare des types différents

Les règles que suit PHP 8, dans l'ordre où elles comptent en pratique :

1. Deux chaînes numériques sont comparées comme des nombres : "10" == "1e1" et "1" == "01" valent tous deux true.
2. Un nombre et une chaîne numérique : la chaîne devient un nombre. 100 == "1e2" vaut true.
3. Un nombre et une chaîne non numérique : depuis PHP 8, le nombre devient une chaîne et ils sont comparés comme des chaînes. 0 == "a" vaut false (cela valait true en PHP 7).
4. N'importe quoi et un bool : les deux côtés sont convertis en bool. "a" == true et [] == false valent true.
5. null et une chaîne : null devient "", donc null == "" vaut true mais null == "0" vaut false. Face à tout autre type, null est comparé comme false.
6. Deux tableaux : égaux quand ils ont les mêmes paires clé/valeur.

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

Cette dernière ligne montre pourquoi les comparaisons d'ordre avec null ont rarement du sens : null devient false, -1 devient true, et false < true.

Différent : != ou !==

!= et <> sont le même opérateur. !== en est la version stricte. La différence compte surtout avec les fonctions qui renvoient 0 ou false, comme 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 vaut false car 0 se convertit en false. 0 !== false vaut true car un int n'est pas un bool. Le même piège existe avec array_search et avec in_array sans son option stricte.

Comparer des chaînes

< et > comparent les chaînes octet par octet (par ordre alphabétique pour de l'ASCII simple). Si les deux chaînes sont numériques, elles sont comparées comme des nombres. Pour un ordre insensible à la casse ou « naturel », utilisez les fonctions :

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

L'opérateur spaceship <=>

$a <=> $b renvoie -1 quand $a est plus petit, 0 quand ils sont égaux et 1 quand $a est plus grand. Il suit les mêmes règles que < et ==, et c'est la façon la plus courte d'écrire une fonction de tri.

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

Comparer deux tableaux avec <=> les compare élément par élément, et c'est ainsi que la fonction trie d'abord par âge puis par nom. D'autres recettes de tri sont sur la page sur le tri des tableaux.

Erreur fréquente : comparer des floats avec ==

Les floats sont stockés en binaire, donc beaucoup de valeurs décimales sont des approximations. 0.1 + 0.2 ne vaut pas exactement 0.3, et == voit la différence.

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

Pour de l'argent, stockez des centimes entiers et comparez-les avec ===.