SymfonyWorld Online 2022 Winter Edition

Opérateurs de comparaison

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.

Opérateurs de comparaison
Exemple Nom Résultat
$a == $b Égal 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 inférieur, égal, ou supérieur à $b respectivement.

Si les deux opérandes sont des chaînes numériques, ou si un opérande est un nombre et l'autre est une chaîne numérique, alors 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.

Avertissement

Antérieur à PHP 8.0.0, si une string est comparé à un nombre ou à une chaîne numérique alors la string sera convertie en un nombre avant d'effectuer la comparaison. Ceci peut mener à des résultats surprenant comme il peut être vu avec l'exemple suivant :

<?php
var_dump
(== "a");
var_dump("1" == "01");
var_dump("10" == "1e1");
var_dump(100 == "1e2");

switch (
"a") {
case 
0:
    echo 
"0";
    break;
case 
"a":
    echo 
"a";
    break;
}
?>

Résultat de l'exemple ci-dessus en PHP 7 :

bool(true)
bool(true)
bool(true)
bool(true)
0

Résultat de l'exemple ci-dessus en PHP 8 :

bool(false)
bool(true)
bool(true)
bool(true)
a

<?php  
// Entiers
echo <=> 1// 0
echo <=> 2// -1
echo <=> 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 [123] <=> [123]; // 0
echo [123] <=> []; // 1
echo [123] <=> [121]; // 1
echo [123] <=> [124]; // -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).

Comparaison avec plusieurs types
Type de l'opérande 1 Type de l'opérande 2 Résultat
null ou string string Convertit null en "", comparaison numérique ou lexicale
bool ou null N'importe quoi Convertit en bool, false < true
object object Les classes internes peuvent définir leur propre méthode de comparaison ; différentes classes sont incomparables ; entre objets de même classe voir Comparaison d'objet
chaîne de caractères, ressource, entier ou nombre décimal chaîne de caractères, ressource, entier ou nombre décimal Transforme les chaînes de caractères et les ressources en nombres
array array 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 sont incomparables, 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éen et null sont toujours comparés comme des booléens
var_dump(== TRUE);  // TRUE - identique à (bool)1 == TRUE
var_dump(== 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, -10NULL10100)); // 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 et l'opérateur combiné
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 
1;
      } elseif (
$val $op2[$key]) {
         return -
1;
      } elseif (
$val $op2[$key]) {
         return 
1;
      }
   }
   return 
0// $op1 == $op2
}
?>

Avertissement

Comparaison de nombre à virgule flottante

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.

Note: Soyer conscient que la manipulation des types n'est pas toujours évidente lors de la comparaison de valeurs de différents types, en particulier comparant des entiers à des booléens ou des entiers à des chaîne de caractèress. Il est par conséquent généralement recommandé d'utiliser les opérateurs de comparaison === et !== au lieu de == et != dans la plupart des cas.

Valeurs incomparables

Tandis que les comparaisons d'identité (=== et !==) peuvent être appliqué à des valeurs arbitraires, les autres opérateurs de comparaisons devrait seulement être appliqué à des valeurs comparables. Le résultat de comparer des valeurs incomparables est indéfinie, et ne devrait pas être dépendu.

L'opérateur ternaire

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'];
}
?>
L'expression (expr1) ? (expr2) : (expr3) est évaluée à expr2 si expr1 est évaluée à true, et expr3 si expr1 est évaluée à false.

Il est possible d'omettre la partie centrale de l'opérateur ternaire. L'expression expr1 ?: expr3 évalue le résultat de expr1 si expr1 vaut true, et expr3 sinon. expr1 n'est évalué qu'une seule fois dans ce cas.

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 plusieurs opérateurs ternaire qui ne sont pas entre parenthèse en une unique expression est non évident comparé à d'autres langages. En effet antérieur à PHP 8.0.0, l'expression ternaire était évalué gauche-associatif, au lieu de droite-associatif comme la plupart des autres langages de programmations. Dépendre de la gauche associativité est obsolète à partir de PHP 7.4.0. À partir de PHP 8.0.0, l'opérateur ternaire est non associatif.

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' antérieur à PHP 8.0.0
// car l'expression ternaire est gauche-associatif

// l'expression suivante est une version plus évidente du même code
echo ((true 'true' false) ? 't' 'f');

// ici, on peut constater 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.
?>

Note:

La combinaison de ternaire court (?:), cependant, est stable et se comporte de manière résonable. Ceci évaluera au premier argument qui évalue à une valeur non-falsy. À noter que des valeurs indéfinies émettront toujours un avertissement.

Exemple #5 Combinaison de ternaire court

<?php
echo ?: ?: ?: 3PHP_EOL//1
echo ?: ?: ?: 3PHP_EOL//2
echo ?: ?: ?: 3PHP_EOL//3
?>

Opérateur de fusion Null

Un autre opérateur court utile est l'opérateur "??" (ou fusion null).

Exemple #6 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';
}
?>
L'expression (expr1) ?? (expr2) retourne expr2 si expr1 est null, et expr1 dans les autres cas.

En particulier, cet opérateur n'émet pas de notice ou avertissement 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 émet un avertissement.

Note:

L'opérateur de fusion null à une précédence faible. Ceci signifie que le mélanger avec d'autres opérateurs (tel que la concaténation de chaînes ou les opérateurs arithmétiques) des parenthèses seront requis.

<?php
// Émet un avertissement que $name est indéfinie.
print 'Mr. ' $name ?? 'Anonymous';

// Prints "Mr. Anonymous"
print 'Mr. ' . ($name ?? 'Anonymous');
?>

Note:

Veuillez noter que l'opérateur de fusion null permet une imbrication simple:

Exemple #7 Imbrication de l'opération de fusion null

<?php

$foo 
null;
$bar null;
$baz 1;
$qux 2;

echo 
$foo ?? $bar ?? $baz ?? $qux// sortie 1

?>

add a note

User Contributed Notes 10 notes

up
162
crazy888s at hotmail dot com
12 years ago
I couldn't find much info on stacking the new ternary operator, so I ran some tests:

<?php
echo 0 ?: 1 ?: 2 ?: 3; //1
echo 1 ?: 0 ?: 3 ?: 2; //1
echo 2 ?: 1 ?: 0 ?: 3; //2
echo 3 ?: 2 ?: 1 ?: 0; //3

echo 0 ?: 1 ?: 2 ?: 3; //1
echo 0 ?: 0 ?: 2 ?: 3; //2
echo 0 ?: 0 ?: 0 ?: 3; //3
?>

It works just as expected, returning the first non-false value within a group of expressions.
up
3
Sumon Mahmud
2 years ago
Extending from here: https://www.php.net/manual/en/language.operators.comparison.php#121907

$a = ['a' => 1, 'b' => 2, 'c' => 3, 'e' => 4];
$b = ['a' => 1, 'b' => 2, 'd' => 3, 'e' => 4];

echo $a > $b; // 0
echo $b > $a; // 0
echo $a <$b; // 0
echo $b < $a; // 0

If using spaceship operator then it is returning true like :

echo $a <=> $b; //1
echo $b <=> $a; //1
echo $a <=> $b; //1
echo $b <=> $a; //1
up
6
niall at maranelda dot org
4 years ago
Care must be taken when using the spaceship operator with arrays that do not have the same keys:

- Contrary to the notes above ("Example #2 Transcription of standard array comparison"), it does *not* return null if the left-hand array contains a key that the right-hand array does not.
- Because of this, the result depends on the order you do the comparison in.

For example:

<?php
$a
= ['a' => 1, 'b' => 2, 'c' => 3, 'e' => 4];
$b = ['a' => 1, 'b' => 2, 'd' => 3, 'e' => 4];

var_dump($a <=> $b);        // int(1) : $a > $b because $a has the 'c' key and $b doesn't.

var_dump($b <=> $a);        // int(1) : $b > $a because $b has the 'd' key and $a doesn't.
?>
up
19
rshawiii at yahoo dot com
16 years ago
You can't just compare two arrays with the === operator
like you would think to find out if they are equal or not.  This is more complicated when you have multi-dimensional arrays.  Here is a recursive comparison function.

<?php
/**
* Compares two arrays to see if they contain the same values.  Returns TRUE or FALSE.
* usefull for determining if a record or block of data was modified (perhaps by user input)
* prior to setting a "date_last_updated" or skipping updating the db in the case of no change.
*
* @param array $a1
* @param array $a2
* @return boolean
*/
function array_compare_recursive($a1, $a2)
{
   if (!(
is_array($a1) and (is_array($a2)))) { return FALSE;}   
   
   if (!
count($a1) == count($a2))
      {
       return
FALSE; // arrays don't have same number of entries
     
}
     
   foreach (
$a1 as $key => $val)
   {
       if (!
array_key_exists($key, $a2))
           {return
FALSE; // uncomparable array keys don't match
             
}
       elseif (
is_array($val) and is_array($a2[$key]))  // if both entries are arrays then compare recursive
          
{if (!array_compare_recursive($val,$a2[$key])) return FALSE;
           }
       elseif (!(
$val === $a2[$key])) // compare entries must be of same type.
          
{return FALSE;
           }
   }
   return
TRUE; // $a1 === $a2
}
?>
up
21
adam at caucho dot com
16 years ago
Note: according to the spec, PHP's comparison operators are not transitive.  For example, the following are all true in PHP5:

"11" < "a" < 2 < "11"

As a result, the outcome of sorting an array depends on the order the elements appear in the pre-sort array.  The following code will dump out two arrays with *different* orderings:

<?php
$a
= array(2,    "a""11", 2);
$b = array(2,    "11", "a"2);
sort($a);
var_dump($a);
sort($b);
var_dump($b);
?>

This is not a bug report -- given the spec on this documentation page, what PHP does is "correct".  But that may not be what was intended...
up
13
bishop
15 years ago
When you want to know if two arrays contain the same values, regardless of the values' order, you cannot use "==" or "===".  In other words:

<?php
(array(1,2) == array(2,1)) === false;
?>

To answer that question, use:

<?php
function array_equal($a, $b) {
    return (
is_array($a) && is_array($b) && array_diff($a, $b) === array_diff($b, $a));
}
?>

A related, but more strict problem, is if you need to ensure that two arrays contain the same key=>value pairs, regardless of the order of the pairs.  In that case, use:

<?php
function array_identical($a, $b) {
    return (
is_array($a) && is_array($b) && array_diff_assoc($a, $b) === array_diff_assoc($b, $a));
}
?>

Example:
<?php
$a
= array (2, 1);
$b = array (1, 2);
// true === array_equal($a, $b);
// false === array_identical($a, $b);

$a = array ('a' => 2, 'b' => 1);
$b = array ('b' => 1, 'a' => 2);
// true === array_identical($a, $b)
// true === array_equal($a, $b)
?>

(See also the solution "rshawiii at yahoo dot com" posted)
up
4
Ryan Mott
2 years ago
Searching for "double question mark" operator should find this page (and hopefully after this comment the crawlers will agree)
up
10
Cuong Huy To
10 years ago
In the table "Comparison with Various Types", please move the last line about "Object" to be above the line about "Array", since Object is considered to be greater than Array (tested on 5.3.3)

(Please remove my "Anonymous" post of the same content before. You could check IP to see that I forgot to type my name)
up
1
Tahazzot
1 year ago
Very careful when reading PHP documentation, Here's a lot of miss information.

According to documentation, They say's (int) 0 == (string) "a" is true. But it is not in PHP 8.

var_dump(0 == "a"); // 0 == 0 -> true

Now In PHP 8 it's False.
up
4
Marcin Kuzawiski
7 years ago
A < B and still B < A...

$A = [1 => 1, 2 => 0, 3 => 1];
$B = [1 => 1, 3 => 0, 2 => 1];

var_dump($A < $B);  // TRUE
var_dump($B < $A);  // TRUE

var_dump($A > $B);  // TRUE
var_dump($B > $A);  // TRUE

Next - C and D are comparable, but neither C < D nor D < C (and still C != D)...

$C = [1 => 1, 2 => 1, 3 => 0];
$D = [1 => 1, 3 => 1, 2 => 0];

var_dump($C < $D); // FALSE
var_dump($D < $C); // FALSE

var_dump($C > $D); // FALSE
var_dump($D > $C); // FALSE

var_dump($D == $C); // FALSE
To Top