Operadores Lógicos/Matemáticos
Published: 2021-03-05 16:08:00

# Veja no Youtube:
[![VIDEO](http://img.youtube.com/vi/8bSgmKuZXrU/0.jpg)](https://youtu.be/8bSgmKuZXrU)

[![VIDEO](http://img.youtube.com/vi/6MLd4Jv9s5A/0.jpg)](https://youtu.be/6MLd4Jv9s5A)

# Objetivos

1. Aprender o que são operadores lógicos e como funcionam
2. Aprender o que são operadores matemáticos e como funcionam
3. Ver um pouco deles com trechos de código clicando no 👁

# Bora lá...

## Operadores Lógicos
![Operadores Lógicos](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ug94dhlffl41j1pfbo6h.png)
 
## Operadores Matemáticos
![Operadores Matemáticos](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/c0tcthl3syldsxob2ouv.png)
 

### Como são usados?

# >

Ex.: a > b
Nome: Maior que
Resultado: Verdadeiro se a for maior que b

Comumente usado para números, então vamos para exemplos numéricos, para tipo `string` vamos usado o `.length` para pegarmos a quantidade de caracteres que temos

### Usando if statement com números

```jsx
const a = 10
const b = 22

if( a > b){
// Verdadeiro
} else {
// Entrou aqui no Falso
}

console.log(a > b) // Output: false
```

### Usando if statement com textos

```jsx
const a = "Telles"
const b = "telles"

if( a.length > b.length){
// Verdadeiro
} else {
// Entrou aqui no Falso
}

console.log( a.length > b.length) // Output: false
```

O resultado é `false`, porque a não é maior que `b` e sim igual a ele

### Usando if statement com textos e números

```jsx
const a = 8
const b = "10"

if( a > b){
// Verdadeiro
} else {
// Entrou aqui no Falso
}

console.log(a > b) // Output: false
```

A saída desse exemplo é `false`, aqui temos uma pegadinha do JavaScript em que usando um número dentro de uma `string` (ou no formato de uma) para um calculo matemático ou verificação de maior ou menor ele ignora o fato de que é uma `string` e aceita que é um número pois não há validação de tipagem com exceção do operador de soma que faz interpolação de dados

# <

Ex.: a < b
Nome: Menor que
Resultado: Verdadeiro se a for menor que b

Comumente usado para números, então vamos para exemplos numéricos, para tipo `string` vamos usado o `.length` para pegarmos a quantidade de caracteres que temos

### Usando if statement com números

```jsx
const a = 10
const b = 22

if( a < b){
// Entrou aqui no Verdadeiro
}

console.log(a < b) // Output: true
```

### Usando if statement com textos

```jsx
const a = "Telles"
const b = "telles"

if( a.length < b.length){
// Verdadeiro
} else {
// Entrou aqui no Falso
}

console.log( a.length < b.length) // Output: false
```

O resultado é `false`, porque a não é menor que `b` e sim igual a ele

### Usando if statement com textos e números

```jsx
const a = 8
const b = "10"

if( a < b){
// Verdadeiro
}

console.log(a < b) // Output: true
```

A saída desse exemplo é `true`, aqui temos uma pegadinha do JavaScript em que usando um número dentro de uma `string` (ou no formato de uma) para um calculo matemático ou verificação de maior ou menor ele ignora o fato de que é uma `string` e aceita que é um número pois não há validação de tipagem com exceção do operador de soma que faz interpolação de dados

# ===

Ex.: a === b
Nome: Idêntico
Resultado: Verdadeiro se a for idêntico a b

### Usando if statement com números

```jsx
const a = 22
const b = 22

if( a === b){
// Entrou aqui no Verdadeiro
}

console.log(a === b) // Output: true
```

### Usando if statement com textos

```jsx
const a = "Telles"
const b = "telles"

if( a === b){
// Verdadeiro
} else {
// Entrou aqui no Falso
}

console.log(a === b) // Output: false
```

O resultado é `false` pois ele como eu havia dito ele é case-sensitive, ou seja, maiúsculas e minúsculas fazem a diferença.

### Usando if statement com textos e números

```jsx
const a = 10
const b = "10"

if( a === b){
// Verdadeiro
} else {
// Entrou aqui no Falso
}

console.log(a === b) // Output: false
```

A saída desse exemplo é `false` pois ele compara somente o valor atribuído e não a tipagem dos dados, sendo assim o 10 string é igual ao 10 number


# ==

Ex.: a == b
Nome: Igual
Resultado: Verdadeiro se a for igual a b

### Usando if statement com números

```jsx
const a = 22
const b = 22

if( a == b){
// Entrou aqui no Verdadeiro
}

console.log(a == b) // Output: true
```

### Usando if statement com textos

```jsx
const a = "Telles"
const b = "telles"

if( a == b){
// Verdadeiro
} else {
// Entrou aqui no Falso
}

console.log(a == b) // Output: false
```

O resultado é falso pois ele como eu havia dito ele é case-sensitive, ou seja, maiúsculas e minúsculas fazem a diferença.

### Usando if statement com textos e números

```jsx
const a = 10
const b = "10"

if( a == b){
// Verdadeiro
}

console.log(a == b) // Output: true
```

A saída desse exemplo é `true` pois ele compara somente o valor atribuído e não a tipagem dos dados

# <=

Ex.: a <= b
Nome: Menor ou igual
Resultado: Verdadeiro se a for menor ou igual a b

Comumente usado para números, então vamos para exemplos numéricos, para tipo `string` vamos usado o `.length` para pegarmos a quantidade de caracteres que temos

### Usando if statement com números

```jsx
const a = 10
const b = 22

if( a <= b){
// Entrou aqui no Verdadeiro
}

console.log(a <= b) // Output: true
```

### Usando if statement com textos

```jsx
const a = "Telles"
const b = "telles"

if( a.length <= b.length){
// Entrou aqui no Verdadeiro
} else {
// Falso
}

console.log( a.length <= b.length) // Output: true
```

O resultado é `true`, porque a não é menor que `b` e sim igual a ele.

### Usando if statement com textos e números

```jsx
const a = 8
const b = "10"

if( a <= b){
// Verdadeiro
}

console.log(a <= b) // Output: true
```

A saída desse exemplo é `true`, aqui temos uma pegadinha do JavaScript em que usando um número dentro de uma `string` (ou no formato de uma) para um calculo matemático ou verificação de maior ou menor ele ignora o fato de que é uma `string` e aceita que é um número pois não há validação de tipagem com exceção do operador de soma que faz interpolação de dados

# >=

Ex.: a >= b
Nome: Maior ou igual
Resultado: Verdadeiro se a for maior ou igual a b

Comumente usado para números, então vamos para exemplos numéricos, para tipo `string` vamos usado o `.length` para pegarmos a quantidade de caracteres que temos

### Usando if statement com números

```jsx
const a = 10
const b = 22

if( a >= b){
// Verdadeiro
} else {
// Entrou aqui no Falso
}

console.log(a >= b) // Output: false
```

### Usando if statement com textos

```jsx
const a = "Telles"
const b = "telles"

if( a.length >= b.length){
// Entrou aqui no Verdadeiro
} else {
// Falso
}

console.log( a.length >= b.length) // Output: true
```

O resultado é `true`, porque a não é menor que `b` e sim igual a ele.

### Usando if statement com textos e números

```jsx
const a = 8
const b = "10"

if( a >= b){
// Verdadeiro
}

console.log(a >= b) // Output: false
```

A saída desse exemplo é `true`, aqui temos uma pegadinha do JavaScript em que usando um número dentro de uma `string` (ou no formato de uma) para um calculo matemático ou verificação de maior ou menor ele ignora o fato de que é uma `string` e aceita que é um número pois não há validação de tipagem com exceção do operador de soma que faz interpolação de dados

# &&

Ex.: a && b
Nome: E
Resultado: Verdadeiro se existir a e b

### Usando if statement com números

```jsx
const a = 10
const b = 22

if( a && b){
// Entrou aqui no Verdadeiro
}

console.log(a <= b) // Output: true
```

### Usando if statement com textos

```jsx
const a = "Telles"
const b = ""

if( a && b){
// Verdadeiro
} else {
// Entrou aqui no Falso
}

console.log( a && b) // Output: false
```

O resultado é `false`, porque existe `a` e `b` é vazio .

### Usando if statement com textos e boolean

```jsx
const a = 8
const b = false

if( a && b){
// Verdadeiro
} else {
// Entrou aqui no Falso
}

console.log(a && b) // Output: false
```

A saída desse exemplo é `false`, porque a segunda condição é `false` por default e precisamos de dois `true` para ser `true`

# ||

Ex.: a || b
Nome: Ou
Resultado: Verdadeiro se existir a ou existir b

### Usando if statement com números

```jsx
const a = 10
const b = 22

if( a || b){
// Entrou aqui no Verdadeiro
}

console.log(a || b) // Output: true
```

### Usando if statement com textos

```jsx
const a = "Telles"
const b = ""

if( a || b){
// Entrou aqui no Verdadeiro
} else {
// Falso
}

console.log( a || b) // Output: true
```

O resultado é `true`, porque existe `a` e `b` é vazio, mas com o `ou` como operador precisamos somente de um deles para ser `true`.

### Usando if statement com textos e boolean

```jsx
const a = 8
const b = false

if( a || b){
// Entrou aqui no Verdadeiro
} else {
// Falso
}

console.log(a || b) // Output: true
```

A saída desse exemplo segue a mesma lógica do de cima.

# !==

Ex.: a !== b
Nome: Não Idêntico
Resultado: Verdadeiro se a não for igual a b ou eles não tiverem o mesmo tipo

### Usando if statement com números

```jsx
const a = 10
const b = 22

if( a !== b){
// Entrou aqui no Verdadeiro
}

console.log(a !== b) // Output: true
```

### Usando if statement com textos

```jsx
const a = "Telles"
const b = "telles"

if( a !== b){
// Entrou aqui no Verdadeiro
} else {
// Falso
}

console.log(a !== b) // Output: true
```

O resultado é `true` pois ele como eu havia dito ele é case-sensitive, ou seja, maiúsculas e minúsculas fazem a diferença.

### Usando if statement com textos e números

```jsx
const a = 10
const b = "10"

if( a != b){
// Verdadeiro
}

console.log(a !== b) // Output: true
```

A saída desse exemplo é `true` pois ele compara somente o valor atribuído e não a tipagem dos dados, sendo assim o 10 string **não é igual** ao 10 number

# !=

Ex.: a != b
Nome: Diferente
Resultado: Verdadeiro se a não for igual a b

### Usando if statement com números

```jsx
const a = 10
const b = 22

if( a != b){
// Entrou aqui no Verdadeiro
}

console.log(a != b) // Output: true
```

### Usando if statement com textos

```jsx
const a = "Telles"
const b = "telles"

if( a != b){
// Verdadeiro
} else {
// Entrou aqui no Falso
}

console.log(a != b) // Output: false
```

O resultado é `false` pois ele como eu havia dito ele é case-sensitive, ou seja, maiúsculas e minúsculas fazem a diferença.

### Usando if statement com textos e números

```jsx
const a = 10
const b = "10"

if( a != b){
// Verdadeiro
}

console.log(a != b) // Output: true
```

A saída desse exemplo é `false` pois ele compara somente o valor atribuído e não a tipagem dos dados, sendo assim o 10 string é igual ao 10 number

# !

Ex.: !a
Nome: Negação
Resultado: Negação, se o valor for verdadeiro vai transformar em falso e vice versa

> Negação, se o valor for verdadeiro vai transformar em falso e vice versa

### Usando if statement com boolean

```jsx
const a = true

if(!a){
// Verdadeiro
} else {
// Entrou aqui no Falso
}

console.log(!a) // Output: false
```

```jsx
const a = false

if(!a){
// Entrou aqui no Verdadeiro
} else {
// Falso
}

console.log(!a) // Output: true
```