Chegamos a mais um post da minha saga de estudos em JavaScript.
No post de hoje irei falar sobre o tipo de dados boolean e a realizar comparações entre valores e tipos de dados.
Boolean
O tipo de dado boolean, representa dois valores especiais no JavaScript, verdadeiro true ou falso false.
Geralmente os booleans são usados quando precisamos verificar alguma condição no nosso código, pois em determinados momentos, será precisa verificar se algo é verdadeiro ou falso dentro da aplicação.
console.log(true) // true
console.log(false) // false
Existem métodos que retornam a resposta como um dado booleano, ou seja, ele irá retornar true ou false.
Como exemplo, irei utilizar o método includes, que irá verificar se o valor passado por argumento existe ou não dentro da string verificada. Caso seja encontrado, o retorno do includes será true, caso não seja, o retorno será false.
const email = 'fernando@email.com'
const includesAt = email.includes('@')
const includesHash= email .includes('#')
const includesNando = email.includes('nando')
console.log(includesAt) // true
console.log(includesHash) // false
console.log(includesNando) // true
Quando utilizamos o método includes em array, ele tentará dar um match no valor passado por argumento e algum dos itens dentro do array.
const names = ['Dominic', 'Stuart', 'Eddie']
const arrayIncludesEdgard = names.includes('Edgard')
const arrayIncludesStuart = names.includes('Stuart')
console.log(arrayIncludesEdgard) // false
console.log(arrayIncludesStuart) // true
Operadores de Comparação
Abaixo iremos ver vários exemplos de operadores de comparação, e o retorno dessas comparações serão um boolean true ou false.
No JavaScript para verificarmos se uma coisa é igual a outra, utilizamos dois sinais de igual ==.
const age = 31
console.log(age == 31) // true
console.log(age == 35) // false
Para verificarmos se uma coisa é diferente da outra, utilizaremos o operador diferente !=.
const age = 31
console.log(age != 35) // true
console.log(age != 31) // false
Para compararmos se algo é maior que alguma coisa usaremos o sinal de maior >.
const age = 31
console.log(age > 30) // true
console.log(age > 31) // false
Para compararmos se algo é menor que alguma coisa usaremos o sinal de menor <.
const age = 31
console.log(age < 30) // false
console.log(age < 31) // false
console.log(age < 35) // true
Para compararmos se algo é maior OU igual a alguma coisa usaremos o sinal de menor >=.
const age = 31
console.log(age >= 35) // false
console.log(age >= 31) // true
console.log(age >= 28) // true
Para compararmos se algo é menor OU igual a alguma coisa usaremos o sinal de menor <=.
const age = 31
console.log(age <= 35) // true
console.log(age <= 31) // true
console.log(age <= 28) // false
Comparando Strings
Como o JavaScript é case sensitive, ele diferencia letras minúsculas de letras maiúsculas, portando JavaScript é diferente de javascript.
const name = 'fernando'
console.log(name == 'fernando') // true
console.log(name == 'Fernando') // false
No alfabeto a letra f vem depois da letra b, com isso, a string fernando é maior que a string belinha.
Portanto, é possível afirmar que para o JavaScript, as últimas letras do alfabeto são maiores que as primeiras.
Outro ponto, no JavaScript, a ordem de interpretação alfabética, leva em consideração que uma letra minúscula é maior que uma letra maiúscula.
console.log(name > 'belinha') // true
console.log(name > 'Fernando') // true
Comparadores Estritos
Existe uma forma de verificação estrita, que leva em consideração não só o valor, mas também o tipo dos dados verificados.
Essa verificação estrita é usada para evitar que uma verificação de tipos diferentes resultem em true.
Para este tipo de verificação, utilizaremos 3 sinais de igual ===, para verificarmos a igualdade dos valores e dos tipos, e para verificarmos se o valor e o tipo são diferentes, utilizaremos o sinal !==.
Abaixo segue exemplo de como era feito com os sinais == e !=, sem verificar o tipo do dado.
const age = 31
console.log(age == 31) // true
console.log(age == '31') // true
console.log(age != 31) // false
console.log(age != '31') // false
Nos exemplos acima, podemos verificar que mesmo comparando o number 31 com a string 31, retorna em true.
Isso ocorre, porque quando utilizamos o duplo sinal de igual == ou o sinal de diferente !=, rola uma conversão de valores.
O JavaScript, por baixo dos panos, converte a string 31 para number 31 e por isso, retorna true.
Abaixo vou exemplificar com a utilização dos comparadores estritos, e veremos que é muito mais preciso, pois leva em consideração os tipos de dados verificados.
const age = 31
console.log(age === 31) // true
console.log(age === '31') // false
console.log(age !== 31) // false
console.log(age !== '31') // true
Diante disso, fica evidente que o melhor a se fazer quando for comparar algo, é sempre utilizar os comparadores estritos, de igualdade === e de diferenciação !==.
Deixo aqui o link para a documentação da MDN sobre booleans.
Esse foi mais um post da minha saga de estudos em JavaScript Vanilla. Espero que estejam gostando!
Qualquer dúvida ou sugestão, vocês me encontram nas minhas redes sociais:
Top comments (0)