Operadores de comparación

Los operadores de comparación, como su nombre lo indica, permiten comparar dos valores. Puede también estar interesado en ver las tablas de comparación de tipos, ya que muestran ejemplos de las varias comparaciones relacionadas con tipos.

Operadores de comparación
Ejemplo Nombre Resultado
$a == $b Igual true si $a es igual a $b después de la manipulación de tipos.
$a === $b Idéntico true si $a es igual a $b, y son del mismo tipo.
$a != $b Diferente true si $a no es igual a $b después de la manipulación de tipos.
$a <> $b Diferente true si $a no es igual a $b después de la manipulación de tipos.
$a !== $b No idéntico true si $a no es igual a $b, o si no son del mismo tipo.
$a < $b Menor que true si $a es estrictamente menor que $b.
$a > $b Mayor que true si $a es estrictamente mayor que $b.
$a <= $b Menor o igual que true si $a es menor o igual que $b.
$a >= $b Mayor o igual que true si $a es mayor o igual que $b.
$a <=> $b Nave espacial Un integer menor que, igual a, o mayor que cero cuando $a es respectivamente menor que, igual a, o mayor que $b. Disponible a partir de PHP 7.
$a ?? $b ?? $c Fusión de null El primer operando de izquierda a derecha que exista y no sea null. null si no hay valores definidos y no son null. Disponible a partir de PHP 7.

Si se compara un número con un string o la comparación implica strings numéricos, entonces cada string es convertido en un número y la comparación realizada numéricamente. Estas reglas también se aplican a la sentencia switch. La conversión de tipo no tiene lugar cuando la comparación es === o !== ya que esto involucra comparar el tipo así como el valor.

<?php
var_dump
(== "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"// nunca alcanzado debido a que "a" ya ha coincidido con 0
    
echo "a";
    break;
}
?>
<?php
// Integers
echo <=> 1// 0
echo <=> 2// -1
echo <=> 1// 1

// Floats
echo 1.5 <=> 1.5// 0
echo 1.5 <=> 2.5// -1
echo 2.5 <=> 1.5// 1

// Strings
echo "a" <=> "a"// 0
echo "a" <=> "b"// -1
echo "b" <=> "a"// 1

echo "a" <=> "aa"// -1
echo "zz" <=> "aa"// 1

// Arrays
echo [] <=> []; // 0
echo [123] <=> [123]; // 0
echo [123] <=> []; // 1
echo [123] <=> [121]; // 1
echo [123] <=> [124]; // -1

// Objects
$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

// only values are compared
$a = (object) ["a" => "b"];
$b = (object) ["b" => "b"];
echo 
$a <=> $b// 1

?>

Para varios tipos, la comparación se realiza de acuerdo a la siguiente tabla (en orden).

La comparación con varios tipos
Tipo de operando 1 Tipo de operando 2 Resultado
null o string string Convierte null en "", comparación numérica o léxica
bool o null cualquiera Convierte ambos lados a bool, false < true
object object Las clases internas pueden definir su propia comparación, diferentes clases son incomparables, la misma clase - comparan propiedades en la misma forma que los arrays (PHP 4), PHP 5 tiene su propia explicación
string, resource o number string, resource o number Traducir las cadenas y recursos a números, matemática usual
array array Un array con menos elementos es menor, si una clave del operando 1 no se encuentra en el operando 2 entonces los arrays son incomparables, de otra forma - compara valor por valor (ver el siguiente ejemplo)
object cualquiera object es siempre mayor
array cualquiera array es siempre mayor

Ejemplo #1 Comparación boolean/null

<?php
// Booleanos y null son comparados siempre coomo bool
var_dump(== TRUE);  // TRUE - same as (bool)1 == TRUE
var_dump(== FALSE); // TRUE - same as (bool)0 == FALSE
var_dump(100 TRUE); // FALSE - same as (bool)100 < TRUE
var_dump(-10 FALSE);// FALSE - same as (bool)-10 < FALSE
var_dump(min(-100, -10NULL10100)); // NULL - (bool)NULL < (bool)-100 is FALSE < TRUE
?>

Ejemplo #2 Transcripción de la comparación estándar de arrays

<?php
// Arrays son comparados de esta forma con los operadores de comparación estándar
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// uncomparable
        
} elseif ($val $op2[$key]) {
            return -
1;
        } elseif (
$val $op2[$key]) {
            return 
1;
        }
    }
    return 
0// $op1 == $op2
}
?>

Ver también strcasecmp(), strcmp(), operadores de array, y la sección del manual sobre tipos.

Advertencia

Comparación de números de punto flotante

Debido a la forma en que son representados internamente los floats, no se deben probar por igualdad dos floats.

Ver la documentación de float para más información.

Operador ternario

Otro operador condicional es el operador "?:" (o ternario).

Ejemplo #3 Asignación de un valor predeterminado

<?php
// Ejemplo de uso para: Operador Ternario
$action = (empty($_POST['action'])) ? 'default' $_POST['action'];

// Lo anterior es idéntico a esta sentencia if/else
if (empty($_POST['action'])) {
    
$action 'default';
} else {
    
$action $_POST['action'];
}

?>
La expresión (expr1) ? (expr2) : (expr3) evalúa a expr2 si expr1 se evalúa como true y a expr3 si expr1 se evalúa como false.

A partir de PHP 5.3, es posible dejar de lado la parte media del operador ternario. La expresión expr1 ?: expr3 retorna expr1 si expr1 se evalúa como true y expr3 si es de otra manera.

Nota: Por favor note que el operador ternario es una expresión, y que no evalúa a una variable, sino al resultado de una expresión. Esto es importante saberlo si se desea retornar una variable por referencia. La sentencia return $var == 42 ? $a : $b; en una función con retorno-por-referencia no funcionará por lo que se ha mencionado y una advertencia es generada en versiones posteriores de PHP.

Nota:

Es recomendable evitar el "apilamiento" expresiones ternarias. El comportamiento de PHP al utilizar más de un operador ternario en una única sentencia no es evidente:

Ejemplo #4 Comportamiento Ternario poco obvio

<?php
// a primera vista, lo siguiente parece tener la salida de 'true'
echo (true?'true':false?'t':'f');

// sin embargo, la salida real de lo anterior es 't'
// esto se debe a que las expresiones ternarias se evalúan de izquierda a derecha

// la siguiente es una versión más obvia del mismo código anterior
echo ((true 'true' false) ? 't' 'f');

// aquí, se puede ver que la primera expresión es evaluada como 'true', que
// a su vez se evalúa como (bool)true, retornando así la rama verdadera de la
// segunda expresión ternaria.
?>

Null Coalescing Operator

Further exists the "??" (or null coalescing) operator.

Ejemplo #5 Assigning a default value

<?php
// Example usage for: Null Coalesce Operator
$action $_POST['action'] ?? 'default';

// The above is identical to this if/else statement
if (isset($_POST['action'])) {
    
$action $_POST['action'];
} else {
    
$action 'default';
}

?>
The expression (expr1) ?? (expr2) evaluates to expr2 if expr1 is null, and expr1 otherwise.

In particular, this operator does not emit a notice or warning if the left-hand side value does not exist, just like isset(). This is especially useful on array keys.

Nota: Please note that the null coalescing operator is an expression, and that it doesn't evaluate to a variable, but to the result of an expression. This is important to know if you want to return a variable by reference. The statement return $foo ?? $bar; in a return-by-reference function will therefore not work and a warning is issued.

Nota:

Please note that the null coalescing operator allows for simple nesting:

Ejemplo #6 Nesting null coalescing operator

<?php

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

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

?>

add a note 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
14
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
9
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
6 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