Booleans e Operadores de Comparação
Published: 2021-03-10 23:52:17

Chegamos a mais um post da minha [saga de estudos](https://dev.to/inando85/bem-vindo-de-novo-javascript-1b48) 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.

```js
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`.

```js
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.

```js
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 `==`.

```js
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 `!=`.

```js
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 `>`.

```js
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 `<`.

```js
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 `>=`.

```js
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 `<=`.

```js
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`.

```js
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.

```js
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.

```js
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.

```js
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](https://developer.mozilla.org/en-US/docs/Glossary/Boolean).

________________________________________________________________

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:

[LinkedIn](https://linkedin.com/in/inando85)
[GIthub](https://github.com/inando85)
[Twitter](https://twitter.com/inando85)