Conversões de tipos Javascript
Tags: javascript, tutorial, programming
Published: 2022-12-29 12:38:04

Na maioria das vezes, operadores e funções convertem automaticamente os valores dados a eles para o tipo correto. 

Por exemplo, a função `alert()` converte automatricamente qualquer valor em uma string para mostrá-lo. As operações matemáticas convertem valores em números. Também há casos em que precisamos converter explicitamente um valor para o tipo esperado.

## Conversão de String

A conversão de string acontece quando precisamos que um valor tenha o formato string. Por exemplo, `alert(value)` faz isso para mostrar um valor. 

Também podemos chamar a função String(value) para converter um valor em uma string:

```jsx
let value = true;
alert(typeof value) // boolean

value = String(value) // agora o valor é uma string "true"
alert(typeof value) // string
```
A conversão de strings é mais óbvia. O `false` torna-se `"false"`, `null` torna-se `"null"`, etc.

## Conversão Numérica

A conversão numérica ocorre em funções e expressões matemáticas automaticamente. 

Por exemplo, quando a divisão `/` é aplicada a não números:

```jsx
alert('6' / '2') // 3, strings são convertidas em números
```
Podemos usar a função `Number(value)` para converter explicitamente um valor em um número:

```jsx
let str = '123'
alert(typeof str) // string

let num = Number(str) // torna-se um número 123

alert(typeof num) // number
```
A conversão explícita geralmente é necessária, quando lemos um valor de uma fonte baseada em string, como um formulário de texto, mas esperamos que um número seja inserido.

Se a tring não for um número válido, o resultado dessa conversão será `NaN`. Por exemplo:

```jsx
let age = Number("uma string arbitrária em vez de um número");

alert(age); // NaN, conversion failed
```

Regras de conversão numérica:

| Valor |Torna-se |
| --- | ----------- |
| undefined | NaN |
| null | 0 |
| true e false | 1 e 0 |
| string | Os espaços em branco (inclui espaços, tabulações \t, novas linhas, \n, etc.) Do início ao fim, são removidos. Se a string restante estiver vazia, o resultado será 0. Caso contrário, o número é "lido" da string. Dá um erro NaN. |

Exemplos: 

```jsx
alert( Number("   123   ") ); // 123
alert( Number("123z") );      // NaN (error reading a number at "z")
alert( Number(true) );        // 1
alert( Number(false) );       // 0
```
Observe que `null` e `undefined` se comportam de maneira diferente: `null` torna=se zero, enquanto `undefined` torn-se `NaN`.

## Conversão Booleana

A conversão booleana é a mais simples. Isso acontece em operações lógicas, mas também pode ser executado explicitamente com uma chamada para `Boolean(value)`.

A regra de conversão:

- Valores que tornam-se false: string vazia, 0, null, undefined e NaN.

- Outros valores tornam-se true.

Por exemplo:

```jsx
alert(Boolean(1)) // true
alert(Boolean(0)) //  false

alert(Boolean('hello')) // true
alert(Boolean('')) // false
```

> Observação: uma string com zero "0" é true, algumas linguagens (ou seja, PHP), tratam "0" como arquivos `false`. Mas em JavaScript, uma string não vazia é sempre `true`. Exemplo:

```jsx
alert( Boolean('0') ); // true
alert( Boolean(' ') ); // false
```

## Resumo

As três conversões de tipo mais usadas, são strings, number e boolean. 

Conversão de String: ocorre quando produzimos algo. Pode ser executado com `String(value)`. A conversão para string geralmente é óbvia para valores primitivos.

Conversão Numérica: ocorre em operações matemáticas. Pode ser executado com `Number(value)`. 

Conversão booleana: ocorre em operações lógicas. Pode ser executado com `Boolean(value)`. As regras são:

| Valor |Torna-se |
| --- | ----------- |
| 0, null, undefined, NaN, '' | false |
| qualquer outro valor | true |

Espero que tenha gostado do tutorial, caso tenha alguma dúvida, comente aqui.