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
(0 == "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 <=> 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).

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(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 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.

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 la comparaison des valeurs incomparables est indéfini, et ne devrait pas être utilisé.

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 raisonnable. 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 0 ?: 1 ?: 2 ?: 3, PHP_EOL; //1
echo 0 ?: 0 ?: 2 ?: 3, PHP_EOL; //2
echo 0 ?: 0 ?: 0 ?: 3, PHP_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 add a note

User Contributed Notes 45 notes

up
144
crazy888s at hotmail dot com
14 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
88
arnaud at arnapou dot net
13 years ago
[Editor's note: consider using ===]

I discover after 10 years of PHP development something awfull : even if you make a string comparison (both are strings), strings are tested like integers and leading "space" character (even \n, \r, \t) is ignored ....

I spent hours because of leading \n in a string ... it hurts my developper sensibility to see two strings beeing compared like integers and not like strings ... I use strcmp now for string comparison ... so stupid ...

Test code :
<?php

test
("1234", "1234");
test("1234", " 1234");
test("1234", "\n1234");
test("1234", "1234 ");
test("1234", "1234\n");

function
test($v1, $v2) {
    echo
"<h1>[".show_cr($v1)."] vs [".show_cr($v2)."]</h1>";
    echo
my_var_dump($v1)."<br />";
    echo
my_var_dump($v2)."<br />";
    if(
$v1 == $v2) {
        echo
"EQUAL !";
    }
    else {
        echo
"DIFFERENT !";
    }
}

function
show_cr($var) {
    return
str_replace("\n", "\\n", $var);
}

function
my_var_dump($var) {
   
ob_start();
   
var_dump($var);
   
$dump = show_cr(trim(ob_get_contents()));
   
ob_end_clean();
    return
$dump;
}

?>

Displays this ->

[1234] vs [1234]
string(4) "1234"
string(4) "1234"
EQUAL !

[1234] vs [ 1234]
string(4) "1234"
string(5) " 1234"
EQUAL !

[1234] vs [\n1234]
string(4) "1234"
string(5) "\n1234"
EQUAL !

[1234] vs [1234 ]
string(4) "1234"
string(5) "1234 "
DIFFERENT !

[1234] vs [1234\n]
string(4) "1234"
string(5) "1234\n"
DIFFERENT !
up
46
Harry Willis
9 years ago
I was interested about the following two uses of the ternary operator (PHP >= 5.3) for using a "default" value if a variable is not set or evaluates to false:

<?php
(isset($some_variable) && $some_variable) ? $some_variable : 'default_value';

$some_variable ?: 'default_value';
?>

The second is more readable, but will throw an ERR_NOTICE is $some_variable is not set. Of course, this could be overcome by suppressing the notice using the @ operator.

Performance-wise, though, comparing 1 million iterations of the three statements

  (isset($foo) && $foo) ? $foo : ''
  ($foo) ?: ''
  (@$foo) ?: ''

results in the following:

  $foo is NOT SET.
    [isset] 0.18222403526306
    [?:]    0.57496404647827
    [@ ?:]  0.64780592918396
  $foo is NULL.
    [isset] 0.17995285987854
    [?:]    0.15304207801819
    [@ ?:]  0.20394206047058
  $foo is FALSE.
    [isset] 0.19388508796692
    [?:]    0.15359902381897
    [@ ?:]  0.20741701126099
  $foo is TRUE.
    [isset] 0.17265486717224
    [?:]    0.11773896217346
    [@ ?:]  0.16193103790283

In other words, using the long-form ternary operator with isset($some_variable) is preferable overall if $some_variable may not be set.

(error_reporting was set to zero for the benchmark, to avoid printing a million notices...)
up
31
thomas dot oldbury at tgohome dot com
17 years ago
Be careful when using the ternary operator!

The following will not evaluate to the expected result:

<?php
echo "a string that has a " . (true) ? 'true' : 'false' . " condition in. ";
?>

Will print true.

Instead, use this:

<?php
echo "a string that has a " . ((true) ? 'true' : 'false') . " condition in. ";
?>

This will evaluate to the expected result: "a string that has a true condition in. "

I hope this helps.
up
36
jwhiting at hampshire dot edu
20 years ago
note: the behavior below is documented in the appendix K about type comparisons, but since it is somewhat buried i thought i should raise it here for people since it threw me for a loop until i figured it out completely.

just to clarify a tricky point about the == comparison operator when dealing with strings and numbers:

('some string' == 0) returns TRUE

however, ('123' == 0) returns FALSE

also note that ((int) 'some string') returns 0

and ((int) '123') returns 123

the behavior makes senes but you must be careful when comparing strings to numbers, e.g. when you're comparing a request variable which you expect to be numeric. its easy to fall into the trap of:

if ($_GET['myvar']==0) dosomething();

as this will dosomething() even when $_GET['myvar'] is 'some string' and clearly not the value 0

i was getting lazy with my types since php vars are so flexible, so be warned to pay attention to the details...
up
20
jeronimo at DELETE_THIS dot transartmedia dot com
19 years ago
For converted Perl programmers: use strict comparison operators (===, !==) in place of string comparison operators (eq, ne). Don't use the simple equality operators (==, !=), because ($a == $b) will return TRUE in many situations where ($a eq $b) would return FALSE.

For instance...
"mary" == "fred" is FALSE, but
"+010" == "10.0" is TRUE (!)

In the following examples, none of the strings being compared are identical, but because PHP *can* evaluate them as numbers, it does so, and therefore finds them equal...

<?php

echo ("007" == "7" ? "EQUAL" : "not equal");
// Prints: EQUAL

// Surrounding the strings with single quotes (') instead of double
// quotes (") to ensure the contents aren't evaluated, and forcing
// string types has no effect.
echo ( (string)'0001' == (string)'+1.' ? "EQUAL" : "not equal");
// Prints: EQUAL

// Including non-digit characters (like leading spaces, "e", the plus
// or minus sign, period, ...) can still result in this behavior, if
// a string happens to be valid scientific notation.
echo ('  131e-2' == '001.3100' ? "EQUAL" : "not equal");
// Prints: EQUAL

?>

If you're comparing passwords (or anything else for which "near" precision isn't good enough) this confusion could be detrimental. Stick with strict comparisons...

<?php

// Same examples as above, using === instead of ==

echo ("007" === "7" ? "EQUAL" : "not equal");
// Prints: not equal

echo ( (string)'0001' === (string)'+1.' ? "EQUAL" : "not equal");
// Prints: not equal

echo ('  131e-2' === '001.3100' ? "EQUAL" : "not equal");
// Prints: not equal

?>
up
34
mail at mkharitonov dot net
9 years ago
Be careful with the "==" operator when both operands are strings:
<?php
var_dump
('123' == '       123'); // true
var_dump('1e3' == '1000'); // true
var_dump('+74951112233' == '74951112233'); // true
var_dump('00000020' == '0000000000000000020'); // true
var_dump('0X1D' == '29E0'); // true
var_dump('0xafebac' == '11529132'); // true
var_dump('0xafebac' == '0XAFEBAC'); // true
var_dump('0xeb' == '+235e-0'); // true
var_dump('0.235' == '+.235'); // true
var_dump('0.2e-10' == '2.0E-11'); // true
var_dump('61529519452809720693702583126814' == '61529519452809720000000000000000'); // true in php < 5.4.4
up
20
hiroh2k at yahoo dot com
19 years ago
if you want to use the ?: operator, you should be careful with the precedence.

Here's an example of the priority of operators:

<?php
echo 'Hello, ' . isset($i) ? 'my friend: ' . $username . ', how are you doing?' : 'my guest, ' . $guestusername . ', please register';
?>

This make "'Hello, ' . isset($i)" the sentence to evaluate. So, if you think to mix more sentences with the ?: operator, please use always parentheses to force the proper evaluation of the sentence.

<?php
echo 'Hello, ' . (isset($i) ? 'my friend: ' . $username . ', how are you doing?' : 'my guest, ' . $guestusername . ', please register');
?>

for general rule, if you mix ?: with other sentences, always close it with parentheses.
up
39
Anonymous
18 years ago
The following contrasts the trinary operator associativity in PHP and Java.  The first test would work as expected in Java (evaluates left-to-right, associates right-to-left, like if stmnt), the second in PHP (evaluates and associates left-to-right)

<?php

echo "\n\n######----------- trinary operator associativity\n\n";

function
trinaryTest($foo){

   
$bar    = $foo > 20
           
? "greater than 20"
           
: $foo > 10
               
? "greater than 10"
               
: $foo > 5
                   
? "greater than 5"
                   
: "not worthy of consideration";   
    echo
$foo." =>  ".$bar."\n";
}

echo
"----trinaryTest\n\n";
trinaryTest(21);
trinaryTest(11);
trinaryTest(6);
trinaryTest(4);

function
trinaryTestParens($foo){
   
   
$bar    = $foo > 20
           
? "greater than 20"
           
: ($foo > 10
               
? "greater than 10"
               
: ($foo > 5
                   
? "greater than 5"
                   
: "not worthy of consideration"));   
    echo
$foo." =>  ".$bar."\n";
}

echo
"----trinaryTestParens\n\n";
trinaryTestParens(21);
trinaryTestParens(11);
trinaryTest(6);
trinaryTestParens(4);

?>

Output:

######----------- trinary operator associativity

----trinaryTest

21 =>  greater than 5
11 =>  greater than 5
6 =>  greater than 5
4 =>  not worthy of consideration

----trinaryTestParens

21 =>  greater than 20
11 =>  greater than 10
6 =>  greater than 5
4 =>  not worthy of consideration
up
17
kapoor_rajiv at hotmail dot com
14 years ago
A quick way to do mysql bit comparison in php is to use the special character it stores . e.g
<?php
                                       
if ($AvailableRequests['OngoingService'] == '')
                                            echo
'<td>Yes</td>';
                                        else
                                            echo
'<td>No</td>';

?>
up
20
rshawiii at yahoo dot com
18 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
15
Jeremy Swinborne
11 years ago
Beware of the consequences of comparing strings to numbers.  You can disprove the laws of the universe.

echo ('X' == 0 && 'X' == true && 0 == false) ? 'true == false' : 'sanity prevails';

This will output 'true == false'.  This stems from the use of the UNIX function strtod() to convert strings to numbers before comparing.  Since 'X' or any other string without a number in it converts to 0 when compared to a number, 0 == 0 && 'X' == true && 0 == false
up
8
G
6 years ago
Do note, using the ternary operator shorthand (since 5.3), omitting the 2nd expression the first expression will only be called once.

Before 5.3 (or not using the shorthand)
<?php
$val
= f('x') ? f('x') : false;
// f('x') will be run twice
?>

After 5.3
<?php
$val
= f('x') ?: false;
// f('x') will be run once
?>
up
18
gondo
9 years ago
beware of the fact, that there is no `<==` nor `>==` therefore `false <= 0` will be `true`. php v. 5.4.27
up
16
Alex
17 years ago
I think everybody should read carefully what "jeronimo at DELETE_THIS dot transartmedia dot com" wrote. It's a great pitfall even for seasoned programmers and should be looked upon with a great attention.
For example, comparing passwords with == may result in a very large security hole.

I would add some more to it:

The workaround is to use strcmp() or ===.

Note on ===:

While the php documentation says that, basically,
($a===$b)  is the same as  ($a==$b && gettype($a) == gettype($b)),
this is not true.

The difference between == and === is that === never does any type conversion. So, while, according to documentation, ("+0.1" === ".1") should return true (because both are strings and == returns true), === actually returns false (which is good).
up
5
niall at maranelda dot org
6 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
adam at caucho dot com
17 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
17 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
13
Cuong Huy To
12 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
17
stepheneliotdewey at gmail [period] com
17 years ago
Note that typecasting will NOT prevent the default behavior for converting two numeric strings to numbers when comparing them.

e.g.:

<?php
if ((string) '0123' == (string) '123')
    print
'equals';
else
    print
'doesn\'t equal';
?>

Still prints 'equals'

As far as I can tell the only way to avoid this is to use the identity comparison operators (=== and !==).
up
1
itsacon at itsacon dot net
3 years ago
Be aware that the null coalesce operator (??) has a lower priority than most other operators, so parentheses are usually a good idea if the output is used in anything other than an assignment.

<?php
$var
= 1;
if (
$var ?? 0 == 2) {}  // will evaluate to true

if (2 == $undefinedVar ?? 0) {}  // will throw an error

if (($var ?? 0) == 2) {}  // will evaluate to false
?>

https://www.php.net/manual/en/language.operators.precedence.php
up
4
prezire at gmail dot com
8 years ago
Take note when grouping ternary operations that return either boolean or integer concatenated to a string:
<?php
 
echo 'hello ' . true ? 1 : 0, //Outputs 1
      
'hello ' . (true ? 1 : 0); //Outputs hello 1
?>
up
1
Sumon Mahmud
4 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
13
Anonymous
14 years ago
Note: The ternary shortcut currently seems to be of no use in dealing with unexisting keys in an array, as PHP will throw an error. Take the following example.

<?php
$_POST
['Unexisting'] = $_POST['Unexisting'] ?: false;
?>

PHP will throw an error that the "Unexisting" key does not exist. The @ operator does not work here to suppress this error.
up
11
bimal at sanjaal dot com
11 years ago
I came across peculiar outputs while I was attempting to debug a script

<?php
# Setup platform (pre conditions somewhere in a loop)
$index=1;
$tally = array();

# May work with warnings that $tally[$index] is not initialized
# Notice: Undefined offset: 1 in D:\htdocs\colors\ColorCompare\i.php on line #__
# It is an old fashioned way.
# $tally[$index] = $tally[$index] + 1;

# Does not work: Loops to attempt to change $index and values are aways unaffected
$tally[$index] = isset($tally[$index])?$tally[$index]:0+1;
$tally[$index] = isset($tally[$index])?$tally[$index]:0+1;
$tally[$index] = isset($tally[$index])?$tally[$index]:0+1;
/*
# These three lines output:
Array
(
    [1] => 1
)
*/

# Works: This is what I need/expect
# $tally[$index] = 1+(isset($tally[$index])?$tally[$index]:0);

print_r($tally);
?>

The second block obviously does not work what one expects.
Third part is good.
up
9
alan dot g at nospam dot net
13 years ago
a function to help settings default values, it returns its own first non-empty argument :

make your own eor combos !

<?php

/*
* Either Or
*
* usage:  $foo = eor(test1(),test2(),"default");
* usage:  $foo = eor($_GET['foo'], foogen(), $foo, "bar");
*/

function eor() {
   
$vars = func_get_args();
     while (!empty(
$vars) && empty($defval))   
        
$defval = array_shift($vars);         
     return
$defval;
}



?>
up
10
Hayley Watson
16 years ago
Note that the "ternary operator" is better described as the "conditional operator". The former name merely notes that it has three arguments without saying anything about what it does. Needless to say, if PHP picked up any more ternary operators, this will be a problem.

"Conditional Operator" is actually descriptive of the semantics, and is the name historically given to it in, e.g., C.
up
13
fernandoleal at dragoncs dot com
17 years ago
If you need nested ifs on I var its important to group the if so it works.
Example:
<?php
//Dont Works
//Parse error: parse error, unexpected ':'
$var='<option value="1" '.$status == "1" ? 'selected="selected"' :''.'>Value 1</option>';
//Works:
$var='<option value="1" '.($status == "1" ? 'selected="selected"' :'').'>Value 1</option>';

echo
$var;
?>
up
7
Mark Simon
12 years ago
The use of 5.3’s shortened ternary operator allows PHP to coalesce a null or empty value to an alternative:

$value = $planA ?: $planB;

My own server doesn’t yet run 5.3. A nice alternative is to use the “or” operator:

$value = $planA or $value = planB;
up
4
Marcin Kuzawiski
8 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
up
3
Romain
5 years ago
?? vs isset() with __isset() and __get()

<?php

class A
{
    public function
__get($id)
    {
        return
'a value';
    }
}

class
B
{
    public function
__isset($id)
    {
        return
false;
    }
   
    public function
__get($id)
    {
        return
'a value';
    }
}

class
c
{
    protected
$test = "a value";
   
    public function
__isset($id)
    {
        return
true;
    }
}

$a = new A();
$b = new B();
$c = new C();

echo isset(
$a->test) ? $a->test : 'nothing'; // "nothing"
echo $a->test ?? 'nothing'; // "a value", isset() is not called!

echo isset($b->test) ? $b->test : 'nothing'; // "nothing"
echo $b->test ?? 'nothing'; // "nothing", __isset() is called

echo isset($c->test) ? $c->test : 'nothing'; // throw an Exception
echo $c->test ?? 'nothing'; // "nothing"

?>
up
2
azz
4 years ago
Keep in mind that ?: operator is NOT fully equal to empty()

?: can't check non-existent array index (as describe here https://www.php.net/manual/ru/language.operators.comparison.php#92685) and vars

Check this:

<?php
ini_set
('error_reporting', E_ALL);

$t = [];

var_dump(!isset($t['z']) || $t['z'] == FALSE); // true, this that empty() do
var_dump(empty($t['z'])); // true
var_dump(isset($t['z'])); // false

$v1 = $t['z'] ?: false; // Notice:  Undefined index: z
$v2 = $t['z'] ?? false; // silent!

var_dump($v1); // false
var_dump($v2); // false

var_dump(!isset($non_existent_var) || $non_existent_var == FALSE); // true, this that empty() do
var_dump(empty($non_existent_var)); // true
var_dump(isset($non_existent_var)); // false

$v1 = $non_existent_var ?: false; // Notice:  Undefined variable: non_existent_var
$v2 = $non_existent_var ?? false; // silent!

var_dump($v1); // false
var_dump($v2); // false
up
6
j-a-n at gmx dot de
12 years ago
Please be careful when comparing strings with floats, especally when you are using the , as decimal.

<?php
var_dump
($alt);
var_dump($neu);
var_dump($alt == $neu);
?>

string(9) "590217,73"
float(590217,73)
bool(false)

not the float is cast to a string and then string-compared, but the string is cast to a float and then float-compared.

to compare as strings use strval!

<?php
var_dump
(strval($alt));
var_dump(strval($neu));
var_dump(strval($alt) == strval($neu));
?>

string(9) "590217,73"
string(9) "590217,73"
bool(true)
up
8
user@example
19 years ago
With Nested ternary Operators you have to set the logical  parentheses to get the correct result.

<?php
$test
=true;
$test2=true;

(
$test) ? "TEST1 true" :  ($test2) ? "TEST2 true" : "false";
?>
This will output: TEST2 true;

correct:

<?php
$test
=true;
$test2=true;

(
$test) ? "TEST1 true" : (($test2) ? "TEST2 true" : "false");
?>

Anyway don't nest them to much....!!
up
2
Ryan Mott
4 years ago
Searching for "double question mark" operator should find this page (and hopefully after this comment the crawlers will agree)
up
2
sgurukrupa at gmail dot com
9 years ago
With respect to using the ternary operator as a 'null-coalescing' operator: expr1 ?: expr2, note that expr1 is evaluated only once.
up
5
zak at minion dot net
12 years ago
be careful when trying to concatenate the result of a ternary operator to a string

<?php
print '<div>'.(FALSE) ? 'TRUE [bad ternary]' : 'FALSE [bad ternary]';
print
'<br><br>';
print
'<div>'.((FALSE) ? 'TRUE [good ternary]' : 'FALSE [good ternary]');
?>

yields:

TRUE [bad ternary]

FALSE [good ternary]

this is because the ternary evaluates '<div>'.(FALSE) not (FALSE) - so the end result is TRUE
up
4
taras dot bogach at gmail dot com
13 years ago
Boolean switch usege

<?php
class User_Exception extends Exception{}
class
User{
  public function
register($login,$pass,$passCheck)
    switch(
false){
      case(
strlen($pass) >= 5):
        throw new
User_Exception("Password must be at last 5 chars length");
      case(
$pass == $passCheck):
        throw new
User_Exception("Password is not confirmed!");
      case(
strlen($login) >= 5):
        throw new
User_Exception("Login must be at last 5 chars length");
     
//Do other checks
     
default:
       
//Do registration
       
return true;
    }
  }
 
//...
}
?>
up
1
damien dot launay dot mail at gmail dot com
10 years ago
I found a nice way to use of new "?:" operator:

$a = array();
$a['foo'] = 'oof';

$b = @ ($a['foo'] ?: 'No foo');
$c = @ ($a['bar'] ?: 'No bar');

var_dump($b, $c);

Output:

string(3) "oof"
string(6) "No bar"

No error is thrown and $c is set with correct value.

Benefit: no need to use isset.
up
1
halfhearted13 at gmail dot com
3 years ago
Both Null Coalescing ( ?? ) and Ternary ( ? : ) can work at a time.

<?php

$a
= "user name";
echo
$a = null ?? $a ? "sb" : "not found"; // it prints : sb
//as null coalescing has null on left it goes to 2nd expr $a. $a is defined so //output will be the 1st expr of Ternay operator.
?>

<?php

echo $x = "" ?? "" ? : "not found"; // it prints:  not found.
// null coalescing has empty value of its left. so it prints right expr which is //also empty. so the output will be the 2nd expr of ternary(written in short)

?>

<?php
echo $x = "" ?? "" ?? "" ? : false// prints nothing.
// if you add var_dump() you see bool(false)
?>
up
0
yiminrong at yahoo dot ca
3 years ago
The string equality operator has a big gotcha in that if both operators match the format /^0+[Ee][0-9]+$/, then the values will be considered equal. All these, which represent common use cases, will output true:

echo '0e56' == '0E31'; // comparing short hex strings
echo md5('240610708') == md5('QNKCDZO'); // comparing hashes - see comment by Ray Paseur in md5 function
echo '000e123' == '00e0123'; // permutation of a string

The reason is that strings in the format /^0+[Ee][0-9]+$/ are interpreted as a number in scientific notation and zero raised to any power is zero.

Unless it is certain that the string will not match the specific format, then === should be used instead of == for strings.
up
-1
Tahazzot
2 years 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
-1
Ireneusz Pachulski
3 years ago
Note that spaceship operator (<=>) is binary safe.

<?php
$a
= "Hello";
$b = "Hello\x00World";

echo (
$a <=> $b) . "<br>"; // -1
echo strcmp($a, $b) . "<br>"; // -6
echo strcoll($a, $b) . "<br>"; // 0 => not binary safe
?>
up
-2
instatiendaweb at gmail dot com
3 years ago
switch ("a") {
case 0:
    echo "0";
    break;
case "a": // nunca alcanzado debido a que "a" ya ha coincidido con 0
    echo "a";
    break;
}
In php 8.0 is echo "a";
up
-1
mail at markuszeller dot com
13 years ago
I prefer writing (!$a == 'hello') much more than ($a != 'hello'), but I wondered about the performance.

So I did a benchmark:
<?php
for($bench = 0; $bench < 3; $bench++)
{
   
$start = microtime(true);
   
$a = 1;
    for(
$i = 0; $i < 100000000; $i++)
  {
        if(!
$a == 'hello') $b++;
    }
   
$end = microtime(true);
    echo
"Used time: " . ($end-$start) . "\n";
}
?>
and it results with

# if($a != 'hello')
Used time: 12.552895069122
Used time: 12.548940896988
Used time: 12.470285177231

# if(!$a == 'hello')
Used time: 7.6532161235809
Used time: 7.6426539421082
Used time: 7.6452689170837
To Top