Operadores de comparação, como os seus nomes implicam, permitem que você compare dois valores. Você pode se interessar em ver as tabelas de comparação de tipos, que tem exemplo das várias comparações entre tipos relacionadas.
| Exemplo | Nome | Resultado |
|---|---|---|
| $a == $b | Igual | Verdadeiro (TRUE) se $a é igual a $b. |
| $a === $b | Idêntico |
Verdadeiro (TRUE) se $a é igual a $b, e eles são do mesmo
tipo.
|
| $a != $b | Diferente | Verdadeiro se $a não é igual a $b. |
| $a <> $b | Diferente | Verdadeiro se $a não é igual a $b. |
| $a !== $b | Não idêntico | Verdadeiro de $a não é igual a $b, ou eles não são do mesmo tipo (introduzido no PHP4). |
| $a < $b | Menor que | Verdadeiro se $a é estritamente menor que $b. |
| $a > $b | Maior que | Verdadeiro se $a é estritamente maior que $b. |
| $a <= $b | Menor ou igual | Verdadeiro se $a é menor ou igual a $b. |
| $a >= $b | Maior ou igual | Verdadeiro se $a é maior ou igual a $b. |
| $a <=> $b | Spaceship (nave espacial) | Um integer menor que, igual a ou maior que zero quando $a é, respectivamente, menor que, igual a ou maior que $b. Disponível a partir do PHP 7. |
| $a ?? $b ?? $c | Null coalescing |
O primeiro operando da esquerda para direita que exista e não for NULL.
Retorna NULL se nenhum valor estiver definifo ou se todos nulos NULL. Disponível desde o PHP 7.
|
Se comparar um número com uma string ou com strings numéricas, cada string é convertido para um número e então a comparação é realizada numericamente. Essas regras também se aplicam a instrução switch. As conversões de tipo não são realizadas quando a comparação utilizada é === ou !== por esse tipo de comparação envolver valores e tipos.
<?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 é alcançado porque "a" já foi combinado com 0
echo "a";
break;
}
?>
<?php
// Integers
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 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 [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
// 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 vários tipos, comparações são feitas de acordo com a seguinte tabela (em ordem).
| Tipo do 1º operando | Tipo do 2º operando | Resultado |
|---|---|---|
| null ou string | string | Converte NULL para "", numérico ou comparação léxica |
| bool or null | qualquer | Converte para bool, FALSE < TRUE |
| object | object | Classes nativas podem definir como são comparadas, classes diferentes são incomparáveis, mesma classe - compara propriedades igual faz arrays (PHP 4), PHP 5 tem sua explicação |
| string, resource ou number | string, resource ou number | Transforma strings e resources para números |
| array | array | Array com menos membros é menor, se a chave do operando 1 não é encontrada no operando 2, então os arrays são incomparáveis, caso contrário - compara valor por valor (veja o seguinte exemplo) |
| object | qualquer | object é sempre maior |
| array | qualquer | array é sempre maior |
Exemplo #1 Comparações de boolean e null
<?php
// Bool e null são sempre comparados como booleanos
var_dump(1 == TRUE); // TRUE - same as (bool)1 == TRUE
var_dump(0 == 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, -10, NULL, 10, 100)); // NULL - (bool)NULL < (bool)-100 is FALSE < TRUE
?>
Exemplo #2 Transcrição do padrão de comparação de array
<?php
// Arrays são comparados assim quando utilizando-se os operadores padrão
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
}
?>
Veja também strcasecmp(), strcmp(), operadores de array, e a seção do manual sobre Tipos.
Por conta da forma que floats são representados internamente não se deve testar dois floats com o comparador de igualdade.
Veja a documentação de float para mais detalhes.
Outro operador condicional é o operador "?:" (ou ternário).
Exemplo #3 Atribuindo um valor padrão
<?php
// Example usage for: Ternary Operator
$action = (empty($_POST['action'])) ? 'default' : $_POST['action'];
// The above is identical to this if/else statement
if (empty($_POST['action'])) {
$action = 'default';
} else {
$action = $_POST['action'];
}
?>
TRUE, ou
expr3 se
expr1 é avaliada como FALSE.
Desde o PHP 5.3 é possível deixar vazia a parte central do operador
ternário. A expressão expr1 ?: expr3 retorna
expr1 se expr1
verdade TRUE e expr3 do contrário.
Nota: Note que o operador ternário é uma expressão, e ele não é avaliado para uma variável, mas para o resultado do comando. Isto é importante saber se você quer retornar uma variável por referência. O comando return $var == 42 ? $a : $b; em uma função que retorna por referência conseqüêntemente não irá funcionar e será avisado nas últimas versões do PHP.
Nota:
É recomendado para evitar "stacking" de expressões ternárias. O comportamento do PHP quando usando mais de um operador ternário no único comando não é óbvio:
Exemplo #4 Comportamento não óbvio do ternário
<?php
// o seguinte aparenta imprimir 'true'
echo (true?'true':false?'t':'f');
// conteudo, a saída acima é 't'
// isto por causa da expressão ternário se avaliada da esquerda pra direita
// o seguinte é a versão mais óbvia do mesmo código acima
echo ((true ? 'true' : 'false') ? 't' : 'f');
// aqui, você pode ver que a primeira expressão é avaliada para 'true', que
// por sua vez avalia para (bool)true, assim retornando a parte true da
// segunda expressão ternária.
?>