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

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(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": // nunca alcanzado debido a que "a" ya ha coincidido con 0
    echo "a";
    break;
}
?>

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 en 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)
array	cualquiera	array es siempre mayor
object	cualquiera	object es siempre mayor

Ejemplo #1 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 #2 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 sentencia, y que no evalúa a una variable, pero si al resultado de una sentencia. 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 #3 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. ?>