PHP – Aula 012: Um Pouco Mais Sobre Operadores

Operador AND e &&

O operador lógico AND aceita dois operandos e retorna true se ambos os operandos forem true(ou verdadeiros); caso contrário, ele retorna falso.

and ou && são verdadeiros se ambas as expressões 1 e 2 forem verdadeiras

Expressão 01	Expressão 02	Expressão 01 and Expressão 01
true	true	true
true	false	false
false	true	false
false	false	false

PHP não diferencia maiúsculas de minúsculas, então escrever os operadores AND ou and funcionam da mesma forma. Por convenção, você deve usar o operador and no formato minúsculo.

Além do and também há o operador && que são praticamente iguais. A única diferença entre eles é a precedência. O operador and tem precedência maior que o operador &&.

$preco = 100;
$quantidade = 5;
$desconto = $quantidade > 3 && $preco > 99;    //desconto é verdadeiro 
                     //pois a expressão01($quantidade > 3) é verdadeira
                     // e  a expressão01($quantidade > 3) também

Na prática, usamos o operador lógico AND nas instruções if, if-else, if-elseif, while e do-while. Veremos em próximos artigos sopre essas instruções.

Quando o valor do primeiro operando é falso, o operador lógico AND sabe que o resultado também deve ser falso. Neste caso, não avalia o segundo operando. Esse processo é chamado de short-circuiting(curto-circuito).

$promocao = false;
$promocao && print('teste de operador no PHP');    //como promocao é falso 
                              //então print('...') nem é executado.      

Acima, print só é analisado e executado se $promocao for verdadeiro.

Lembre-se que and e && são iguais, diferenciam-se apenas na precedência.

Operadores OR ou ||

O operador lógico OR aceita dois operandos e retorna true se um dos operandos for true;

expressão 1	expressão 2	expressão 1 || expressão 2
true	true	true
true	false	true
false	true	true
false	false	false

Observe que or, Or e OR são iguais porque o PHP não diferencia maiúsculas de minúsculas. 

O || e or são praticamente iguais. A única diferença são suas precedências. O operador or tem precedência maior que o || operador.

Exemplos de or e ||

$expirado = true;
$lento = false;
$limpar_cache = $expirado || $lento; 

var_dump($limpar_cache);

                    //$limpar_cache é true pois uma das duas   
                     //variáveis é verdadeira

O resultado acima é true. Mesmo se alterarmos $expirado = false e $lento = true a variável $limpar_cache será verdadeira pois ainda existe um item true.

Assim como com and ou &&, aqui também temos short-circuiting.

Armadilha do OR em PHP:

Olha as linhas abaixo:

$resultado = false or true;

$resultado é false ou true? será false pois o operador = tem precedência sobre o or e por isso recebe primeiro o false.

A linha acima é equivalente a essa:

($resultado = false) or true;

para mudar esse comportamento precisamos usar parênteses

$resultado = (false or true);

ou podemos usar o operador ||

$resultado = false || true;

cada operador tem precedência. E o PHP avaliará os operadores com maior precedência antes daqueles com menor precedência.

Operador NOT(!)

O operador lógico NOT retorna true se o operando for false e retorna false se o operando for true.

O PHP usa a palavra-chave not e (!) para representar o operador lógico NOT.

Expressão	Expressão not
true	false
false	true

Exemplos:

$prioridade = 5;
var_dump( ! $prioridade < 5 );

Acima acontece o seguinte: como prioridade não é maior que 5, ele é igual, então o PHP o declarar como falso, porém como existe o operador not(!) ele acaba sendo invertido para true.

Mais um Pouco sobre Operador de Atribuição 

O PHP usa o = para representar o operador de atribuição.

O PHP avalia a expressão do lado direito primeiro e atribui o resultado à variável do lado esquerdo.

$x = 10;
$y = 20;
$total = $x + $y;    //examina primeiro $x + $y 
                     //depois atribui o resultado   para $total

Operadores de Atribuição com Cálculos Aritméticos

você pode usar vários operadores de atribuição em uma única instrução como esta:

$x = $y = 20;   //primeiro é avaliado $y = 20 e depois $x recebe 20.

Para aumentar uma variável com um valor específico:

$contador =  1;
$contador = $contador + 1;  // o resultado será 2

O código abaixo tem o mesmo significado que o de cima

$contador =  1;
$contador += 1;  // o resultado será 2

Veja mais exemplos:

+=	$x += $y	$x = $x + $y	Adição
-=	$x -= $y	$x = $x – $y	Subtração
*=	$x *= $y	$x = $x * $y	Multiplicação
/=	$x /= $y	$x = $x / $y	Divisão
%=	$x %= $y	$x = $x% $y	Módulo
**=	$z **= $y	$x = $x ** $y	Exponenciação

Operador de atribuição com concatenação

Vimos no artigo anterior que o ponto (.) é usado para concatenar(juntar) duas ou mais strings

$nome =  " maria ";
$cumprimento = " Seja Bem-vinda!";
$saudacao =  $maria . ", " . $cumprimento;
echo $saudacao;

O resultado será: maria, Seja bem-vinda!

O código acima pode ser assim:

 $nome = 'maria';
 $cumprimento = ",Seja bem-vida! ";
 $nome .= $cumprimento;  

 echo  $nome;

O resultado será o mesmo: maria, Seja bem-vinda!

Operadores de Comparação

Um operador de comparação permite comparar dois valores e retorna verdadeiro(true) se a comparação for verdadeira e falsa(false) em caso contrário.

==	Igualdade	Retorna true se ambos os operandos forem iguais, caso contrário retorna false.	A == B é falso, pois A é 10 e B 20.
===	Identidade	Retorne true se ambos os operandos tiverem o mesmo tipo de dados e igual, caso contrário, retorna false.	A === B é falso pois, mesmo ambos sendo inteiros, possuem valores diferentes.
!===	Não idênticos	Retorna true se ambos os operandos não forem iguais ou não tiverem o mesmo tipo de dados, caso contrário, retorna false.	A > B retorna falso pois A é menor que B, A é 10 e B é 20.
>	Maior que	Retorne true se o operando à esquerda for maior que o operando à direita, caso contrário, retorna false.	A > B retorna falso pois A é menor que B, A é 10 e B é 20.
>=	maior que ou igual a	Retorna true se o operando à esquerda for maior ou igual ao operando à direita, caso contrário, retorna false.	A >= B retorna falso pois A é menor que B, A é 10 e B é 20.
<	Menor que	Retorne true se o operando à esquerda for menor que o operando à direita, caso contrário, retorna false.	A > B retorna verdadeiro pois A é menor que B, A é 10 e B é 20.
<=	Menor ou igual	Retorna true se o operando à esquerda for menor ou igual ao operando à direita, caso contrário, retorna false.	A > B retorna falso pois A é menor que B, A é 10 e B é 20.

Operador de igualdade (==) retorna true se ambos os valores forem iguais;

<?php   
        $x = 10 ;
        $y = 10;
        var_dump($x == $y);     
?>

O resultado é: bool(true) pois $x e $y são iguais

<?php   
        $x = 20 ;
        $y = 10;
        var_dump($x == $y);     
?>

O resultado é: bool(false) pois $x e $y são diferentes

<?php   
        $x = '10' ;
        $y = 10;
        var_dump($x == $y);     
?>

O resultado é: bool(true) pois $x e $y são iguais. Aqui acontece o type juggling que falamos no artigo 010.

Se desejamos comparar dois valores considerando o tipo, ou seja, ignorando o type juggling então devemos usar o operador ===

<?php   
        $x = '10' ;
        $y = 10;
        var_dump($x === $y);     
?>

O resultado é: bool(false) pois $x e $y são de tipos diferentes(===)

Operador “Não Igual a” (!=, <>)

Tanto faz usarmos != ou <>

O operador diferente de (!=, <>) retornará true se o valor do lado esquerdo não for igual ao valor do lado direito;

<?php   
        $x = 10 ;
        $y = 10;
        var_dump($x != $y);     
?>

O resultado é: bool(false) pois $x e $y são iguais. Têm que ser diferentes.

Operador “igualdade com de tipos de dados” === e !==

O código abaixo será falso pois um dado é string e o outro é integer

<?php   
        $x = '10' ;
        $y = 10;
        var_dump($x === $y);     
?>

O código abaixo será verdadeiro pois os dados são diferentes, um string e o outro é integer, além disso os valores também diferem, 20 é diferente de 10 🙂

<?php   
        $x = '20' ;
        $y = 10;
        var_dump($x !== $y);     
?>

O operador não idêntico (!==) retorna verdadeiro se os valores não forem iguais ou não forem do mesmo tipo.

Operador Maior que (>), Maior ou igual a (>=), Menor que (<) e Menor ou igual a (<=)

<?php   
        $x = 20;
        $y = 10;
        var_dump($x > $y);     
?>

O resultado acima é: bool(true) pois $x é maior que $y

<?php   
        $x = 10;
        $y = 10;
        var_dump($x >= $y);     
?>

O resultado acima é: bool(true) pois $x é igual a $y

<?php   
        $x = 10;
        $y = 10;
        var_dump($x < $y);     
?>

O resultado acima é: bool(false) pois $x é igual a $y e não menor

<?php   
        $x = 10;
        $y = 10;
        var_dump($x <= $y);     
?>

O resultado acima é: bool(true) pois $x é igual a $y