Les opérateurs de comparaison, comme leur nom l'indique, vous permettent de comparer deux valeurs. Vous devriez également être intéressés par les tables de comparaisons de types, car ils montrent des exemples de beaucoup de types de comparaisons.
| Exemple | Nom | Résultat |
|---|---|---|
| $a == $b | Egal | TRUE si $a est égal à
$b après le transtypage. |
| $a === $b | Identique |
TRUE si $a est égal à $b et
qu'ils sont de même type.
|
| $a != $b | Différent | TRUE si $a est différent de
$b après le transtypage. |
| $a <> $b | Différent | TRUE si $a est différent de
$b après le transtypage. |
| $a !== $b | Différent |
TRUE si $a est différent de $b
ou bien s'ils ne sont pas du même type.
|
| $a < $b | Plus petit que | TRUE si $a est strictement plus petit que
$b. |
| $a > $b | Plus grand | TRUE si $a est strictement plus grand que
$b. |
| $a <= $b | Inférieur ou égal | TRUE si $a est plus petit ou égal à
$b. |
| $a >= $b | Supérieur ou égal | TRUE si $a est plus grand ou égal à
$b. |
| $a <=> $b | Combiné | Un entier inférieur, égal ou supérieur à zéro lorsque $a est respectivement inférieur, égal, ou supérieur à $b. Disponible depuis PHP 7. |
Si vous comparez un nombre avec une chaîne ou bien que la comparaison implique des chaînes numériques, alors chaque chaîne sera convertie en un nombre et la comparaison sera effectuée numériquement. Ces règles s'appliquent également à l'instruction switch. La conversion de type n'intervient pas lorsque la comparaison est === ou !== vu que ceci engendre aussi bien une comparaison de type que de valeur.
<?php
var_dump(0 == "a"); // 0 == 0 -> true
var_dump("1" == "01"); // 1 == 1 -> true
var_dump("10" == "1e1"); // 10 == 10 -> true
var_dump(100 == "1e2"); // 100 == 100 -> true
switch ("a") {
case 0:
echo "0";
break;
case "a": // jamais évalué parce que "a" est déjà trouvé avec 0
echo "a";
break;
}
?>
<?php
// Entiers
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1
// Nombre flottants
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
// Chaines de caractères
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1
// Tableaux
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1
// Objets
$a = (object) ["a" => "b"];
$b = (object) ["a" => "b"];
echo $a <=> $b; // 0
$a = (object) ["a" => "b"];
$b = (object) ["a" => "c"];
echo $a <=> $b; // -1
$a = (object) ["a" => "c"];
$b = (object) ["a" => "b"];
echo $a <=> $b; // 1
// non seulement les valeurs sont comparées; les clés doivent correspondre
$a = (object) ["a" => "b"];
$b = (object) ["b" => "b"];
echo $a <=> $b; // 1
?>
Pour les différents types, la comparaison est faite en suivant la table suivante (dans l'ordre).
| Type de l'opérande 1 | Type de l'opérande 2 | Résultat |
|---|---|---|
| null ou chaîne de caractères | string | Convertit NULL en "", comparaison numérique ou lexicale |
| booléen ou null | N'importe quoi | Convertit en booléen, FALSE < TRUE |
| objet | objet | Les classes internes peuvent définir leur propre méthode de comparaison; différentes classes ne sont pas comparables; entre objets de même classe voir Comparaison d'objet |
| chaîne de caractères, ressource ou nombre | chaîne de caractères, ressource ou nombre | Transforme les chaînes de caractères et les ressources en nombres |
| tableaux | tableaux | Le tableau avec le moins de membres est plus petit, si la clé de l'opérande 1 n'est pas trouvée dans l'opérande 2, alors les tableaux ne sont pas comparables, sinon la comparaison se fait valeur par valeur (voir l'exemple suivant) |
| object | N'importe quoi | L'objet est toujours plus grand |
| array | N'importe quoi | Le tableau est toujours plus grand |
Exemple #1 Comparaison Booléen/null
<?php
// Boolén et null sont toujours comparés comme des booléens
var_dump(1 == TRUE); // TRUE - identique à (bool)1 == TRUE
var_dump(0 == FALSE); // TRUE - identique à (bool)0 == FALSE
var_dump(100 < TRUE); // FALSE - identique à (bool)100 < TRUE
var_dump(-10 < FALSE);// FALSE - identique à (bool)-10 < FALSE
var_dump(min(-100, -10, NULL, 10, 100)); // NULL - (bool)NULL < (bool)-100 est identique à FALSE < TRUE
?>
Exemple #2 Transcription des comparaisons standards des tableaux
<?php
// Les tableaux sont comparés comme ceci avec les opérateurs standards de comparaison
function standard_array_compare($op1, $op2)
{
if (count($op1) < count($op2)) {
return -1; // $op1 < $op2
} elseif (count($op1) > count($op2)) {
return 1; // $op1 > $op2
}
foreach ($op1 as $key => $val) {
if (!array_key_exists($key, $op2)) {
return null; // incomparable
} elseif ($val < $op2[$key]) {
return -1;
} elseif ($val > $op2[$key]) {
return 1;
}
}
return 0; // $op1 == $op2
}
?>
Voir aussi strcasecmp(), strcmp() les opérateurs de tableaux, et le chapitre sur les types.
A cause de la façon dont les nombres à virgule flottante sont représentés en interne, vous ne devriez pas tester l'égalité entre deux nombres de type float.
Voyez la documentation de float pour plus d'informations.
Un autre opérateur conditionnel est l'opérateur ternaire ("?:").
Exemple #3 Affectation d'une valeur par défaut
<?php
// Exemple d'utilisation pour l'opérateur ternaire
$action = (empty($_POST['action'])) ? 'default' : $_POST['action'];
// La ligne ci-dessus est identique à la condition suivante :
if (empty($_POST['action'])) {
$action = 'default';
} else {
$action = $_POST['action'];
}
?>
TRUE, et
expr3 si
expr1 est évaluée à FALSE.
Depuis PHP 5.3, il est possible d'omettre la partie centrale de l'opérateur
ternaire. L'expression expr1 ?: expr3 retourne
expr1 si expr1
vaut TRUE, et expr3 sinon.
Note: Notez que l'opérateur ternaire est une expression, et il n'est pas évalué en tant que variable, mais en tant que résultat de l'expression. Il est important de le savoir si vous voulez retourner une variable par référence. L'instruction return $var == 42 ? $a : $b; dans une fonction retournée par référence ne fonctionnera donc pas et une alerte est émise.
Note:
Il est recommandé de ne pas "empiler" les expressions ternaires. Le comportement de PHP lors de l'utilisation de plus d'un opérateur ternaire dans une seule instruction n'est pas évident :
Exemple #4 Comportement de PHP
<?php
// A première vue, ce qui suit devrait retourner 'true'
echo (true?'true':false?'t':'f');
// cependant, l'expression ci-dessus retournera 't'
// car l'expression ternaire est évaluée de gauche à droite
// l'expression suivante est une version plus évidente du même code
echo ((true ? 'true' : false) ? 't' : 'f');
// ici, vous pouvez voir que la première expression est évaluée à 'true',
// ce qui fait qu'elle est évaluée à (bool)true, ce qui retourne la branche
// 'vraie' de la seconde expression ternaire.
?>
Il existe également l'opérateur "??" (ou fusion null), disponible depuis PHP 7.
Exemple #5 Assigner une valeur par défaut
<?php
// Exemple d'utilisation pour: Opérateur de fusion Null
$action = $_POST['action'] ?? 'default';
// le code ci-dessus est équivalent à cette structure if/else
if (isset($_POST['action'])) {
$action = $_POST['action'];
} else {
$action = 'default';
}
?>
NULL, et expr1 dans les autres cas.
En particulier, cet opérateur n'émet pas de notice si la partie gauche n'existe pas, exactement comme isset(). Ceci est particulièrement utile pour les clés des tableaux.
Note: Veuillez noter que l'opérateur null de fusion est une expression, et qu'il ne s'évalue pas comme une variable, mais comme le résultat d'une expression. Il est important de le savoir si vous souhaitez renvoyer une variable par référence. L'expression return $foo ?? $bar; est un retour par référence qui ne fonctionne donc pas, et emet un warning.
Note:
Veuillez noter que l'opérateur de fusion null permet une imbrication simple:
Exemple #6 Imbrication de l'opération de fusion null
<?php
$foo = null;
$bar = null;
$baz = 1;
$qux = 2;
echo $foo ?? $bar ?? $baz ?? $qux; // sortie 1
?>