Neste tutorial, você aprenderá sobre os operadores de comparação e operadores lógicos com a ajuda de exemplos.
Operadores de comparação de JavaScript
Os operadores de comparação comparam dois valores e retornam um valor booleano: trueou false. Operadores de comparação são usados na tomada de decisões e loops.
| Operador | Descrição | Exemplo |
|---|---|---|
== | Igual a : truese os operandos forem iguais | 5==5; //true |
!= | Diferente de : truese os operandos não forem iguais | 5!=5; //false |
=== | Estrito igual a : truese os operandos são iguais e do mesmo tipo | 5==='5'; //false |
!== | Estrito diferente de : truese os operandos são iguais, mas de tipo diferente ou não são iguais | 5!=='5'; //true |
> | Maior que : truese o operando esquerdo for maior que o operando direito | 3>2; //true |
>= | Maior ou igual a : truese o operando esquerdo for maior ou igual ao operando direito | 3>=3; //true |
< | Menor que : truese o operando esquerdo for menor que o operando direito | 3<2; //false |
<= | Menor ou igual a : truese o operando esquerdo for menor ou igual ao operando direito | 2<=2; //true |
Exemplo 1: Igual ao Operador
const a = 5, b = 2, c = 'hello'; // equal to operator console.log(a == 5); // true console.log(b == '2'); // true console.log(c == 'Hello'); // false
==avalia truese os operandos são iguais.
Nota : Em JavaScript, ==é um operador de comparação, enquanto =é um operador de atribuição. Se você usar por engano em =vez de ==, poderá obter resultados indesejados.
Exemplo 2: Diferente do Operador
const a = 3, b = 'hello'; // not equal operator console.log(a != 2); // true console.log(b != 'Hello'); // true
!=avalia truese os operandos não são iguais.
Exemplo 3: Estrito igual ao operador
const a = 2; // strict equal operator console.log(a === 2); // true console.log(a === '2'); // false
===avalia truese os operandos são iguais e do mesmo tipo. Aqui, 2 e '2' são os mesmos números, mas o tipo de dados é diferente. E ===também verifica o tipo de dados durante a comparação.
Observação : a diferença entre ==e ===é que:
==avalia truese os operandos são iguais, no entanto, ===avalia truese os operandos são iguais e do mesmo tipo
Exemplo 4: Estrito diferente do operador
const a = 2, b = 'hello'; // strict not equal operator console.log(a !== 2); // false console.log(a !== '2'); // true console.log(b !== 'Hello'); // true
!==avalia truese os operandos são estritamente diferentes. É o oposto completo de estritamente igual ===.
No exemplo acima, 2 != '2'dá true. É porque seus tipos são diferentes, embora tenham o mesmo valor.
Exemplo 5: maior que o operador
const a = 3; // greater than operator console.log(a> 2); // true
>avalia truese o operando esquerdo é maior que o operando direito.
Exemplo 6: Maior que ou igual ao operador
const a = 3; // greater than or equal operator console.log(a>= 3); //true
>=avalia truese o operando esquerdo é maior ou igual ao operando direito.
Exemplo 7: Menor que Operador
const a = 3, b = 2; // less than operator console.log(a < 2); // false console.log(b < 3); // true
<avalia truese o operando esquerdo é menor que o operando direito.
Exemplo 8: Menor ou igual ao operador
const a = 2; // less than or equal operator console.log(a <= 3) // true console.log(a <= 2); // true
<=avalia truese o operando esquerdo é menor ou igual ao operando direito.
Operadores lógicos de JavaScript
Os operadores lógicos realizam operações lógicas: AND , OR e NOT .
| Operador | Descrição | Exemplo |
|---|---|---|
&& | E lógico : truese ambos os operandos / valores booleanos forem verdadeiros, senão avaliafalse | true && false; // false |
|| | OU lógico : truese algum dos operandos / valores booleanos for true. avalia falsese ambos sãofalse | true || false; // true |
! | NOT lógico : truese o operando for falsee vice-versa. | !true; // false |
Exemplo 9: Operador E lógico
const a = true, b = false; const c = 4; // logical AND console.log(a && a); // true console.log(a && b); // false console.log((c> 2) && (c < 2)); // false
&&avalia truese ambos os operandos são true, senão avalia como false.
Nota: Você também pode usar operadores lógicos com números. Em JavaScript, 0 é falsee todos os valores diferentes de zero são true.
Exemplo 10: Operador OR lógico
const a = true, b = false, c = 4; // logical OR console.log(a || b); // true console.log(b || b); // false console.log((c>2) || (c<2)); // true
||avalia truese algum dos operandos é true. Se ambos os operandos forem false, o resultado será false.
Exemplo 11: Operador NOT lógico
const a = true, b = false; // logical NOT console.log(!a); // false console.log(!b); // true
!avalia truese o operando é falsee vice-versa.
