operadores relacionais
Os operadores relacionais são sinais que identificam uma relação entre dois valores.
Uma relação de comparação pode ser de igual, maior ou menor valor.
Igualdade (==)
A relação de igualdade serve para testar se os valores testados são iguais. Para escrever uma relação de igualdade se utiliza dois sinais de igual (==), um seguido do outro. Exemplo:
echo 'teste' == 'teste';
?>
Como resultado, diferentemente do que já visto aqui, será impresso o resultado do teste, e não as strings escritas no comando: "1".
Entenda: Como o sinal de igualdade (==) foi encontrado na instrução echo, indica que o que deve ser impresso é o resultado do teste. O teste acima é a relação de igualdade entre as strings 'teste' e 'teste'. Sim, elas são iguais, portanto, o resultado desse teste é true (1). O php é case-sensitive, o que significa que letras maiúsculas são diferentes de letras minúsculas, portanto, 'teste' não é igual a 'TESTE'.
Também é possível testar se um texto é igual a um número:
echo '10' == 10;
?>
E como resultado obteremos 1 novamente. Mas tome muito cuidado com esse tipo de teste. Isso, porque o PHP tenta transformar a string em integer, para depois fazer a conparação com o outro inteiro. As vezes, tal conversão não resulta no valor esperado. Portanto, não é recomendado esse tipo de teste.
Identidade ou idêntico (===)
O tipo de de relação identidade, ou idêntico, indica se os dois valores são iguais e se são do mesmo tipo. Se as duas cláusulas forem satisfeitas, então os valores são idênticos. O conjunto de sinais que estabelece a relação de identidade são três sinais de igual (===), um após o outro. Veja:
echo 10 === 10;
?>
O resultado do código acima visualizado no navegador será 1. Pois, os dois valores são iguais (10) e do mesmo tipo (integer). Um exemplo de valores não indênticos pode ser demonstrado no código abaixo:
echo '10' === 10;
?>
O resultado acima visualizado no navegador é considerado como falso. Isso porque a string '10' é igual ao integer 10, porém, um é string e o outro é integer. Tipos diferentes, não idênticos. Esse tipo de teste é muito importante para assegurar que os valores informados são relamente o que se espera.
Diferente ou não igual (!=)
A relação diferente ou não igual pode ser definida de duas maneiras, a primeira utilizando os sinais de exclamação seguido pelo sinal de igual (!=) ou pelo sinal de menor seguido do sinal de maio (<>). Exemplo:
echo '11' != 10;
?>
O teste acima resultará no número 1 no nosso navegador. O mesmo resultado será apresentado se no lugar do != utilizar <>. Experimente.
Não idêntico(!==)
A relação não idêntico é estabelecida pelo sinal de exclamação seguido de dois sinais de igual (!==). Essa relação é verdadeira quando os valores testados são de tipos diferentes ou valores diferentes, Exemplo:
echo '10' !== 10;
?>
O teste acima retornará 1, pois, apesar de serem o mesmo valor, são de tipos diferentes.
Maior (>)
A relação de maior é exposta quando utilizada o sinal de maior (>) para saber se o valor a esquerda do sinal é maior que o valor a direita do sinal. Exemplo:
echo 4 > 3;
?>
O teste informado acima resultará em 1, afinal, 4 é maior que 3.
Menor (<)
A relação de menor é exposta quando utilizada o sinal de maior (<) para saber se o valor a esquerda do sinal é menor que o valor a direita do sinal. Exemplo:
echo 4 < 5;
?>
O teste informado acima resultará em 1, afinal, 4 é menor que 5.
Maior ou igual (>=)
A relação de maior ou igual é estabelecida quando indicado o sinal de maior seguido do sinal de igual (>=). A relação é verdadeira quando o valor á esquerda dos sinais é maior, ou igual, ao valor á direita dos sinais. Exemplo:
echo 4 >= 4;
?>
O código acima retorna 1, considerando 4 igual a 4.
Menor ou igual (<=)
A relação de menor ou igual é estabelecida quando indicado o sinal de menor seguido do sinal de igual (>=). A relação é verdadeira quando o valor á esquerda dos sinais é menor, ou igual, ao valor á direita dos sinais. Exemplo:
echo 4 <= 4;
?>
O código acima retorna 1, considerando 4 igual a 4.
Concluindo
Esses são os operadores relacionais que estabelecem relações entre os valores, para serem utilizados em estruturas de decisão.
Os operadores lógicos são utilizados para unir um ou mais resultados lógicos, ou transformar um resultado em outro. Existem os operadores binários, que necessitam de dois ou mais testes lógicos, e o operador unário, que necessita de pelo menos um teste.
! - not
O operador not (!) é um operador unário, que só precisa de um teste lógico. Sua função é inverter o valor do teste lógico, ou seja, se um teste lógico retornar true, o operador not transforma-o em false, e se um teste lógico retornar false, o operador not transforma-o em true. Veja:
$nota = 10;
if ($nota >= 8) {
echo 'Muito boa';
} else {
echo 'Precisa melhorar';
}
?>
No código acima, a variável $nota é maior que 8, portanto o teste lógico retorna o valor true, e será impresso a frase "Nota Boa!".
Para usar o operador not (!), invertendo o resultado do teste, é só escrevê-lo antes do teste:
$nota = 10;
if (!$nota >= 8) {
echo 'Muito boa';
} else {
echo 'Precisa melhorar';
}
?>
Veja que a única alteração foi o ponto de exclamação dentro do if e antes do teste, e como resultado obteremos a frase "Precisa Melhorar!". O teste e os valores não modificaram. O teste ainda continua retornando true, porém, o operador not antes do teste, inverte esse valor para false, o que faz que os comandos do else sejam executados.
|| - or
O operador OR (||) é um operador binário, que necessita de dois testes lógicos. Esse operador retorna true se pelo menos um dos testes retornar true. E só retorna false se os dois testes juntos retornarem falso. Veja:
$nota1 = 10;
$nota2 = 10;
if ($nota1 >= 8 || $nota2 >= 8) {
echo 'Passou de ano';
} else {
echo 'Precisa melhorar';
}
?>
No código acima, misturamos dois testes em um mesmo if. Para isso, utilizamos o operador ||. Nesse caso, o resultado vai ser "Passou de ano". Pois, o primeiro teste retorna true. Como já dito, o operador or retorna true se pelo menos um dos valores retornar true, sendo o primeiro teste verdadeiro, não há necessidade de efetuar os demais testes. Se você alterar a $nota1 para 5, o primeiro teste do if será falso, então o operador or vai realizar o segundo teste, que retorna true, portanto, o or também retorna true. Se você alterar o valor da $nota1 para 5 e o valor da $nota2 para 4, o primeiro teste retornará false, então o or executará o segundo teste que também retornará false, e então ele retorna false para o if, o que resulta na execução do else com a frase "Precisa melhorar".
Obs.: O sinal de OR é o símbolo pipe (|) escrito duas vezes.
&& - and
O operador AND (&&) é um operador binário que necessita de dois testes lógicos. Esse operador só retorna true se os dois testes retornarem true. Se um dos testes realizados retornarem false, o operaor AND retorna false. Veja:
$nota1 = 10;
$nota2 = 10;
if ($nota1 >= 8 && $nota2 >= 8) {
echo 'Passou de ano';
} else {
echo 'Precisa melhorar';
}
?>
No código acima será impresso a frase "Passou de ano", pois, os dois testes retornam true. Se você alterar o valor de $nota1 para 7, o primeiro teste retornará false e o operador and retornará false também, fazendo o PHP executar o else, imprimindo a frase "Precisa melhorar". O mesmo acontece se você alterar o valor de $nota2 para 6.
Na próxima aula darei continuidade na explicação dos operadores lógicos.
Na aula de Operadores lógicos - Parte 1 foram apresentados os operadores mais utilizados nas operações lógicas.
Nesta aula o assunto continua, apresentando o operador xor e sua tabela verdade, o uso dos parênteses e a precedência de operadores, e para finalizar o uso dos operadores and e or ao invés de && e ||.
Xor
O operadore lógico xor é um operador binário que retorna true se um dos testes realizados retornarem true e o outro teste obrigatoriamente retornar false, não importando a ordem. Se os dois testes retornarem false, o operador retornará false. Se os dois testes retornarem true, o operador também retorna false. Esse operador também é conhecido como "or exclusivo". Veja na prática:
$carro = 'sim';
$casa = 'sim';
if ($carro == 'sim' xor $casa == 'sim') {
echo 'Você ganhou o prêmio';
} else {
echo 'Você não ganhou o prêmio';
}
?>
No código acima existe dois testes e uma ligação pelo operador xor. Imagine a cena em que você foi sorteado e você tem que escolher ou uma casa ou um carro. No código acima você não iria ganhar nenhum prêmio, pois, o primeiro teste é verdadeiro, e o segundo também, porém, o xor só retorna verdadeiro se apenas um deles for verdadeiro. Para você ganhar a casa o primeiro teste teria que ser verdadeiro e o segundo falso. Para você ganhar o carro o primeiro teste teria que ser falso e o segundo verdadeiro. E se os dois testes dorem falsos você também não leva nenhum prêmio para casa.
Parênteses
Os parênteses, assim como em uma expressão aritmética, altera a ordem que os testes são realizados. A precendência normal de execução dos testes são:
1. ! - not
2. && - and
3. || - or
4. xor - xor
Essa listagem reflete a ordem de execução de testes. Primeiro o not, depois o and, depois o or e por último o xor. Porém, se existir um parênteses no teste, e dentro dele existir um or, esse or será executado antes de qualquer outro teste.
and e or
Novamente and e or? Não. No post Operadores lógicos - Parte 1, os operadores utilizadas na relação and e or na verdade eram os símbolos && e || respectivamente. O funcionamento daqueles operadores e esses são realmente iguais, a única diferença é a precedência. Esses são executados após os outros, ou seja, tem menor precedência. Então a orderm de precedência é alterada para:
1. ! - not
2. && - and
3. || - or
4. and - and
5. xor - xor
6. or - or
Esses são os operadores lógicos que são utilizados principalmente nos testes lógicos. É muito importante memorizar a precedência dos operadores, pois, alguns erros de lógicas podem resultar em execuções inesperadas.
referências:
Dados encontrados em :https://www.itmnetworks.com.br/suporte/manuais/php/language.expressions.html