O que representa um operador de comparação

Criado em: 09/04/2010

Como foi dito no artigo de operadores no PHP quando chegássemos a estruturas de controle no PHP voltaríamos a abordar alguns novos operadores, pois são diretamente ligados as estruturas de controle. Então primeiro veremos dois novos operadores e em seguida entraremos nas estruturas de controle.

Operadores de comparação

Operadores de comparação como o próprio nome já diz compara dois valores retornando verdadeiro (TRUE) ou falso (FALSE).

Veja uma tabela com os operadores de comparação.

Operador Nome Exemplo Resultado
== Igual $a == $b Verdadeiro se $a for igual a $b
!= Diferente $a != $b Verdadeiro se $a não for igual a $b
<> Diferente $a <> $b Verdadeiro se $a não for igual a $b
=== Idêntico $a === $b Verdadeiro se $a for igual a $b e for do mesmo tipo
!== Não idêntico $a !== $b Verdadeiro se $a não for igual a $b, ou eles não são do mesmo tipo
< Menor que $a < $b Verdadeiro se $a for menor que $b
> Maior que $a > $b Verdadeiro se $a for maior que $b
<= Menor ou igual $a <= $b Verdadeiro se $a for menor ou igual a $b.
>= Maior ou igual $a >= $b Verdadeiro se $a for maior ou igual a $b.

Veja um exemplo com cada um dos operadores, utilizaremos a função var_dump(), para retornar o resultado.

<?php /** * Igual */ var_dump( 7 == 7 ); // TRUE, são iguais var_dump( 7 == 6 ); // FALSE, são diferentes /** * Diferente */ var_dump( 7 != 7 ); // FALSE, pois não são diferentes var_dump( 7 != 6 ); // TRUE, pois são diferentes // Segundo operador diferente var_dump( 7 <> 7 ); // FALSE, pois não são diferentes var_dump( 7 <> 6 ); // TRUE, pois são diferentes /** * Idêntico */ var_dump( 7 === 7 ); // TRUE, pois são iguais e do mesmo tipo, inteiros var_dump( 7 === 7.0 ); // FALSE, pois não são do mesmo tipo /** * Não idêntico */ var_dump( 7 !== 7 ); // FALSE, pois são iguais e do mesmo tipo, inteiros var_dump( 7 !== 7.0 ); // TRUE, pois não são do mesmo tipo /** * Menor que */ var_dump( 7 < 8 ); // TRUE, 7 é menor que 8 var_dump( 7 < 6 ); // FALSE, 7 não é menor que 6 /** * Maior que */ var_dump( 7 > 6 ); // TRUE, 7 é maior que 6 var_dump( 7 > 8 ); // FALSE, 7 não é maior que 8 /** * Menor ou igual */ var_dump( 7 <= 7 ); // TRUE, 7 é igual a 7 var_dump( 7 <= 6 ); // FALSE, 7 não é menor nem igual a 6 var_dump( 3 <= 7 ); // TRUE, 3 é menor que 7 /** * Maior ou igual */ var_dump( 7 >= 7 ); // TRUE, 7 é igual a 7 var_dump( 7 >= 8 ); // FALSE, 7 não é maior nem igual a 8 var_dump( 10 >= 7 ); // TRUE, 10 é maior que 7 ?>

Observe que não definimos variáveis por questões didáticas comparamos valores diretos mais não se esqueça que você pode comparar variável com variável e variável com valores fixos ou ainda como fizemos para exemplificar apenas os valores, resumindo qualquer tipo de dado pode ser comparado. E como foi dito anteriormente o resultado sempre será verdadeiro ou falso, neste ponto pode parecer inútil mais daqui a pouco fará mais sentido o retorno destes resultados. E não se esqueça que as conversões de dados são válidas aqui os valores são convertidos automaticamente quando comparados.

Operadores lógicos

Os operadores lógicos realizam comparação entre expressões, exceto o ! que compara apenas um valor, e como os operadores de comparação retornam verdadeiro (TRUE) ou falso (FALSE).

Observe a tabela com os operadores lógicos.

Operador Nome Exemplo Resultado
AND E ( 10 > 7 ) AND ( 9 == 9 ) Verdadeiro se 10 for maior que 7 e 9 for igual a 9
OR Ou ( 10 > 7 ) OR ( 9 == 9 ) Verdadeiro se 10 for maior que 7 ou 9 for igual a 9
XOR Ou exclusivo ( 10 > 7 ) XOR ( 9 == 9 ) Verdadeiro se 10 for maior que 7 ou 9 for igual a 9, mais não se ambos forem verdadeiro
! Negação ! ( 10 > 7 ) Verdadeiro se 10 for menor que 7
&& E ( 10 > 7 ) && ( 9 == 9 ) Verdadeiro se 10 for maior que 7 e 9 for igual a 9
|| Ou ( 10 > 7 ) || ( 9 == 9 ) Verdadeiro se 10 for maior que 7 ou 9 for igual a 9

Veja um exemplo com cada um dos operadores, e como nos operadores de comparação utilizaremos a função var_dump(), para retornar o resultado.

<?php /** * AND */ var_dump( 7 == 7 AND 9 > 7 ); // TRUE, ambas as expressões são verdadeiras var_dump( 7 == 7 AND 9 < 7 ); // FALSE, apenas a primeira expressão é verdadeira /** * OR */ var_dump( 7 == 7 OR 9 > 7 ); // TRUE, ambas as expressões são verdadeiras var_dump( 7 != 7 OR 9 > 7 ); // TRUE, a segunda expressão é verdadeira var_dump( 7 != 7 OR 9 < 7 ); // FALSE, ambas as expressões são falsas /** * XOR */ var_dump( 7 == 7 XOR 9 > 7 ); // FALSE, ambas as expressões são verdadeiras var_dump( 7 == 7 XOR 9 < 7 ); // TRUE, a primeira expressão é verdadeira var_dump( 7 < 7 XOR 9 > 7 ); // TRUE, a segunda expressão é verdadeira /** * ! */ var_dump( ! 9 < 7 ); // TRUE, 9 NÃO é menor que 7 var_dump( ! 9 > 7 ); // FALSE, 9 é maior que 7 /** * && */ var_dump( 7 == 7 && 9 > 7 ); // TRUE, ambas as expressões são verdadeiras var_dump( 7 == 7 && 9 < 7 ); // FALSE, apenas a primeira expressão é verdadeira /** * || */ var_dump( 7 == 7 || 9 > 7 ); // TRUE, ambas as expressões são verdadeiras var_dump( 7 != 7 || 9 > 7 ); // TRUE, a segunda expressão é verdadeira var_dump( 7 != 7 || 9 < 7 ); // FALSE, ambas as expressões são falsas ?>

Novamente não utilizamos variáveis por questões didáticas, as mesmas regras dos tipos de dados em operadores de comparação são validas aqui. Experimente agora que já sabe utilizar variáveis, ao invés de valores como inserirmos experimente substituir por variáveis.

Precedência de operadores no PHP

Agora você já conhece uma boa quantidade de operadores no PHP temos que conhecer a precedência, ou seja, quem é mais importante qual operador é avaliado primeiro e qual é avaliado em seguida. Observe o seguinte exemplo:

<?php echo 5 + 2 * 3; ?>

O resultado será 11, pois o operador * tem maior precedência em relação ao operador +. Caso desejar realizar a operação com o operador + para só em seguida realizar a operação com o operador *. Observe o exemplo:

<?php echo (5 + 2) * 3; ?>

Observe que utilizamos os parênteses para determinarmos quem deve ser executado primeiro, assim alterando o resultado para 21.

A tabela seguinte mostra a precedência dos operadores, da maior precedência no começo para os de menor precedência.

Operador Descrição
- ! ++ -- Negativo, negação, incremento e decremento
* / % Multiplicação, divisão e resto da divisão
+ - . Adição, subtração e concatenação
> < >= <= Maior que, menor que, maior ou igual e menor ou igual
== != <> Igual e diferente
&& E
|| Ou
= += -= *= /= %= Operadores de atribuição
AND E com menor prioridade
XOR Ou exclusivo
OR Ou com menor prioridade

É importante lembrar que primeiro o PHP executará todas as operações que estiverem entre parênteses, se dentro dos parênteses houver diversas operações a precedência dos operadores será utilizada para definir a ordem, após resolver todas as operações dos parentes, o PHP volta a resolver o que esta fora dos parênteses baseando-se na tabela de precedência de operadores, havendo operadores de mesma prioridade o PHP resolverá a operação da esquerda para direita. Uma tabela mais completa, pois aqui exibimos apenas dos operadores que aprendemos, pode ser encontrada diretamente no manual do PHP.

Abordamos os operadores de comparação e lógicos além da precedência dos operadores neste artigo, no artigo seguinte sobre estruturas de controle serão bastante utilizados os temas abordados neste artigo por isso sempre que houver necessidade volte para tirar duvida sobre algo.

Estão disponíveis os operadores de comparação habituais, conforme mostrado na Tabela 9-1.

Tabela 9-1. Operadores de comparação

Operador Descrição
< menor
> maior
<= menor ou igual
>= maior ou igual
= igual
<> ou != diferente

Nota: O operador != é convertido em <> no estágio de análise. Não é possível implementar os operadores != e <> realizando operações diferentes.

Os operadores de comparação estão disponíveis para todos os tipos de dado onde fazem sentido. Todos os operadores de comparação são operadores binários, que retornam valores do tipo boolean; expressões como 1 < 2 < 3 não são válidas (porque não existe o operador < para comparar um valor booleano com 3).

Além dos operadores de comparação, está disponível a construção especial BETWEEN.

a BETWEEN x AND y

equivale a

a >= x AND a <= y

Analogamente,

a NOT BETWEEN x AND y

equivale a

a < x OR a > y

Não existe diferença entre as duas formas, além dos ciclos de CPU necessários para reescrever a primeira forma na segunda internamente.

Para verificar se um valor é nulo ou não, são usadas as construções

expressão IS NULL expressão IS NOT NULL

ou às construções equivalentes, mas fora do padrão,

expressão ISNULL expressão NOTNULL

Não deve ser escrito expressão = NULL, porque NULL não é "igual a" NULL (O valor nulo representa um valor desconhecido, e não se pode saber se dois valores desconhecidos são iguais). Este comportamento está de acordo com o padrão SQL.

Dica: Alguns aplicativos podem (incorretamente) esperar que expressão = NULL retorne verdade se o resultado da expressão for o valor nulo. É altamente recomendado que estes aplicativos sejam modificadas para ficarem em conformidade com o padrão SQL. Entretanto, se isto não puder ser feito, está disponível a variável de configuração transform_null_equals. Quando transform_null_equals está ativado, o PostgreSQL converte as cláusulas x = NULL em x IS NULL. Este foi o comportamento padrão do PostgreSQL nas versões de 6.5 a 7.1.

O resultado dos operadores de comparação comuns é nulo (significando "desconhecido"), quando algum dos operandos é nulo. Outra forma de fazer comparação é com a construção IS DISTINCT FROM:

expressão IS DISTINCT FROM expressão

Para expressões não-nulas é o mesmo que o operador <>. Entretanto, quando as duas expressões são nulas retorna falso, e quando apenas uma expressão é nula retorna verdade. Portanto, atua efetivamente como se nulo fosse um valor de dado normal, em vez de "desconhecido".

Os valores booleanos também podem ser testados utilizando as construções

expressão IS TRUE expressão IS NOT TRUE expressão IS FALSE expressão IS NOT FALSE expressão IS UNKNOWN expressão IS NOT UNKNOWN

Estas formas sempre retornam verdade ou falso, e nunca o valor nulo, mesmo quando o operando é nulo. A entrada nula é tratada como o valor lógico "desconhecido". Deve ser observado que IS UNKNOWN e IS NOT UNKNOWN são efetivamente o mesmo que IS NULL e IS NOT NULL, respectivamente, exceto que a expressão de entrada deve ser do tipo booleana.