Quais são os tipos primitivos em Javascript
Tags: javascript, webdev, beginners, programming
Published: 2022-11-24 23:23:03

Antes de começar a aprender qualquer conteúdo novo é muito importante que conceitos básicos estejam fixados em nossa mente, desse modo, a solução de eventuais problemas serão muito mais simples de se resolver.

Assim como em qualquer linguagem de programação, estamos totalmente e inevitavelmente dispostos a manipular e ler dados, sendo assim, nada mais justo que começar aprendendo quais tipos de dados teremos de manipular e ler eventualmente.

Primeiramente é importante saber que todo dado em Javascript ou é um objeto ou é um tipo primitivo, uma descrição sobre objeto pode ficar para outro momento, hoje iremos lidar apenas com o entendimento dos **tipos primitivos**.

Em Javascript temos 6 tipos primitivos ``undefined``, ``null``, ``number``, ``string``, ``boolean`` e ``symbol``.

Nós podemos verificar o tipo de um variável utilizando a função ``typeof`` no javascript.

```
console.log(typeof 'Hello') //String
console.log(typeof 12) //Numer
console.log(typeof true) //Boolean
console.log(typeof false) //Boolean
console.log(typeof NaN) //Number
console.log(typeof 0.1) //Number
console.log(typeof '1') //String
```

Vamos dar uma olhada em cada tipo primitivo e exemplificar cada caso.

## Undefined

Quando uma variável é declarada mas não é inicializada ela recebe o valor undefined por padrão.


```
const element
console.log(typeof element) //undefined
```

O valor undefined também é atribuido a variáveis que nem mesmo foram declaradas:

```
console.log(typeof value) //undefined
```

uma função também retornará undefined caso ela não retorne nenhum valor:

```
const metodo = () => {
return
}

metodo() //undefined
```

## Null

O Null é um tipo primitivo que pode ser utilizado para representar o nada, ele contém apenas um valor, o próprio null. O JavaScript define que null é um objeto vazio. Sendo assim, podemos atribuir null a um objeto vazio.

```
const a = null
console.log(typeof a) //object
```

## Number

O tipo number é um dos tipos que o Javascript usa para se referir a números, sejam eles inteiros ou decimais. Diferente de outras linguagens fortemente tipadas como Java, o número 1.5 e o número 10 são do tipo number, sem a divisão de tipos entre números decimais ou inteiros.

```
const age = 14
const value = 14.23
console.log(typeof age) //number
console.log(typeof value) //number
```

Além destes, javascript contém seu próprio método para tratar números infinitos, sendo +Infinity para números infinitos positivos e -Infinity para números infinitos negativos.

Além desses, javascript contém um valor que se refere a um número inválido, o NaN (Not a Number). Como por exemplo a divisão 0/0

```
const a = 0
const b = 0
console.log(a/b) //NaN
```


## String

Strings são caracteres entre aspas. Qualquer valor entre aspas nao convertido é uma string.

```
const name = 'José'
const age = '15'
const value = 'false'

console.log(typeof name) //string
console.log(typeof age) //string
console.log(typeof value) //string
```

é importante lembrar que pode-se utilizar aspas simples '' ou duplas "" para criar strings, então deve-se ter muito cuidado com strings que contém aspas dentro dela, ela pode ser fechada antes do desejado.

```
const english = 'What's your name' //string incorreta
const english = "What's your name" //string correta
```

As strings são valores imutáveis, sendo assim, não conseguimos alterar uma string após criarmos.

É possível concatenarmos strings utilizando o sinal de +. Neste caso o Javascript une duas strings e cria uma nova.

```
const firstName = 'José'
const lastName = 'Lázaro'
const fullName = firstName + " " + lastName
console.log(fullName) //José Lázaro
```

## Boolean

O boolean é um tipo primitivo que contém apenas dois valores possíveis, **true** ou **false**, ou seja, o boolean armazena a informação se algo é verdadeiro ou falso. Basicamente o boolean nos permitirá trabalhar com condições dentro do nosso código.

```
const condicao = true
console.log(condicao) //boolean
```

A seguir podemos ver como o javascript lida com o tipo dos valores quando os convertemos para outros tipos.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d9v6yd0y4rh59qli2bgt.png)

## Symbol
O tipo primitivo Symbol foi adicionado na versão do ECMAScript 6. Os valores de tipo Symbol podem ser usados para fazer propriedades de objetos anônimos. 

para declarar um symbol usamos a seguinte lógica

```
const mySymbol = Symbol();
```



### Nota acerca de criação de valores primitivos

Os tipos primitivos ``boolean``, ``string``, ``number`` podem ser encapsulados por suas contrapartes de objeto gerando assim objetos de retorno, entretanto seus valores reais são os tipos primitivos. Mas o que isso quer dizer? 

Basicamente, especificamente esses tipos podem ser gerados a partir de funções e os valores dessas funções retornam tipos primitivos. Você pode ver os exemplos a seguir:

```
typeof false; //boolean
typeof Boolean(false); //boolean
typeof new Boolean(false); //object
typeof (new Boolean(false)).valueOf(); //boolean
 
typeof "a"; //string
typeof String("a"); //string
typeof new String("a"); //object
typeof (new String("a")).valueOf(); //string
 
typeof 1; //number
typeof Number(1); //number
typeof new Number(1); //object
typeof (new Number(113)).valueOf(); //number
```

##Referências

[Tipos de dados primitivos em Javascript - Guilherme Alves - Medium](https://medium.com/@alves.guilherme1357/tipos-de-dados-primitivos-em-javascript-d7380564933c)
[Tipos de dados Javascript - Ricardo Reis](https://ricardo-reis.medium.com/tipos-de-dados-javascript-a1f6f498a7d4)
[ECMAScript® 2023 Language Specification](https://tc39.es/ecma262/#sec-null-value)
[Symbol() Developer Mozilla](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Symbol)