CÓDIGOS E AFINS

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.
01    
02    /**
03     * Igual
04     */
05    var_dump( 7 == 7 ); // TRUE, são iguais
06    
07    var_dump( 7 == 6 ); // FALSE, são diferentes
08    
09    /**
10     * Diferente
11     */
12    var_dump( 7 != 7 ); // FALSE, pois não são diferentes
13    
14    var_dump( 7 != 6 ); // TRUE, pois são diferentes
15    
16    // Segundo operador diferente
17    var_dump( 7 <> 7 ); // FALSE, pois não são diferentes
18    
19    var_dump( 7 <> 6 ); // TRUE, pois são diferentes
20    
21    /**
22     * Idêntico
23     */
24    var_dump( 7 === 7 ); // TRUE, pois são iguais e do mesmo tipo, inteiros
25    
26    var_dump( 7 === 7.0 ); // FALSE, pois não são do mesmo tipo
27    
28    /**
29     * Não idêntico
30     */
31    var_dump( 7 !== 7 ); // FALSE, pois são iguais e do mesmo tipo, inteiros
32    
33    var_dump( 7 !== 7.0 ); // TRUE, pois não são do mesmo tipo
34    
35    /**
36     * Menor que
37     */
38    var_dump( 7 < 8 ); // TRUE, 7 é menor que 8
39    
40    var_dump( 7 < 6 ); // FALSE, 7 não é menor que 6
41    
42    /**
43     * Maior que
44     */
45    var_dump( 7 > 6 ); // TRUE, 7 é maior que 6
46    
47    var_dump( 7 > 8 ); // FALSE, 7 não é maior que 8
48    
49    /**
50     * Menor ou igual
51     */
52    var_dump( 7 <= 7 ); // TRUE, 7 é igual a 7
53    
54    var_dump( 7 <= 6 ); // FALSE, 7 não é menor nem igual a 6
55    
56    var_dump( 3 <= 7 ); // TRUE, 3 é menor que 7
57    
58    /**
59     * Maior ou igual
60     */
61    var_dump( 7 >= 7 ); // TRUE, 7 é igual a 7
62    
63    var_dump( 7 >= 8 ); // FALSE, 7 não é maior nem igual a 8
64    
65    var_dump( 10 >= 7 ); // TRUE, 10 é maior que 7
66    
67    ?>

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.
01    
02    /**
03     * AND
04     */
05    var_dump(  7 == 7  AND 9 > 7  ); // TRUE, ambas as expressões são verdadeiras
06    
07    var_dump(  7 == 7  AND 9 < 7  ); // FALSE, apenas a primeira expressão é verdadeira
08    
09    /**
10     *  OR
11     */
12    var_dump(  7 == 7  OR 9 > 7  ); // TRUE, ambas as expressões são verdadeiras
13    
14    var_dump(  7 != 7  OR 9 > 7  ); // TRUE, a segunda expressão é verdadeira
15    
16    var_dump(  7 != 7  OR 9 < 7  ); // FALSE, ambas as expressões são falsas
17    
18    /**
19     * XOR
20     */
21    var_dump(  7 == 7  XOR 9 > 7  ); // FALSE, ambas as expressões são verdadeiras
22    
23    var_dump(  7 == 7  XOR 9 < 7  ); // TRUE, a primeira expressão é verdadeira
24    
25    var_dump(  7 < 7  XOR 9 > 7  ); // TRUE, a segunda expressão é verdadeira
26    
27    /**
28     * !
29     */
30    var_dump(  ! 9 < 7  ); // TRUE, 9 NÃO é menor que 7
31    
32    var_dump(  ! 9 > 7  ); // FALSE, 9 é maior que 7
33    
34    /**
35     * &&
36     */
37    var_dump(  7 == 7  && 9 > 7  ); // TRUE, ambas as expressões são verdadeiras
38    
39    var_dump(  7 == 7  && 9 < 7  ); // FALSE, apenas a primeira expressão é verdadeira
40    
41    /**
42     *  ||
43     */
44    var_dump(  7 == 7  || 9 > 7  ); // TRUE, ambas as expressões são verdadeiras
45    
46    var_dump(  7 != 7  || 9 > 7  ); // TRUE, a segunda expressão é verdadeira
47    
48    var_dump(  7 != 7  || 9 < 7  ); // FALSE, ambas as expressões são falsas
49    
50    ?>

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:
1    
2    
3    echo 5 + 2 * 3;
4    
5    ?>

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:
1    
2    
3    echo (5 + 2) * 3;
4    
5    ?>

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



Fonte: http://aprenderphp.com.br/artigo/operadores-de-comparacao-operadores-logicos-e-a-precedencia-dos-operadores-no-php/

  • 16-12-2016
  • Postado por Admin