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.
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 :
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
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)
<?php // Booléen 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 #3 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:
Soyez 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.
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 la comparaison des valeurs incomparables est indéfini,
et ne devrait pas être utilisé.
Un autre opérateur conditionnel est l'opérateur
ternaire ("?:").
Exemple #4 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 #5 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 raisonnable.
Ceci évaluera au premier argument qui évalue à une valeur non-falsy.
À noter que des valeurs indéfinies émettront toujours un avertissement.
Un autre opérateur court utile est l'opérateur "??" (ou fusion null).
Exemple #7 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';
Please note that using the null coalescing operator to check properties on a class that has the __get magic method (without an __isset magic method) invokes the magic method.
For example:
<?php
class A { public function __get($property) { echo 'Called __get for ' . $property . PHP_EOL; } }
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:
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
}
?>
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:
Please be careful when you try to compare strings that have a plus sign `+` at the beginning (such as phone number, etc). When you use the Equal operator `==` PHP will ignore the plus sign. Use Identical operator `===` instead
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.
Between the "shortcut ternary" (aka "elvis") and "spaceship" operators, you can write some quite compact comparison functions for usort and its ilk.
If you want to sort an array of associative arrays by several different keys you can chain them in the same way that you can list column names in an SQL ORDER BY clause.
<?php usort($array, fn($a, $b) => $a['a'] <=> $b['a'] ?: $b['b'] <=> $a['b'] ?: $a['c'] <=> $b['c']); ?> Will sort the array by column 'a', then by column 'b' descending, then by column 'c'; or in SQL-speak 'ORDER BY a, b DESC, c".
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)
It's worth noting that there can be a difference in the logical operation of shorthand ternary (expr1 ?: expr2) vs the full version (expr1 ? expr1 : expr2). The shorthand style may also offer a slight performance enhancement because the initial expression will only be evaluated once.
Example: <?php // my_func() will be called twice here // additionally, my_func() may not return the same value both times! $var = my_func() ? my_func() : false;
// my_func() will only be called once here $var = my_func() ?: false;