Tipos Javasript
Tags: javascript, webdev, beginners, codenewbie
Published: 2021-10-01 17:34:17

# Javascript Types

Meu primeiro post aqui e gostaria de começar explicando algo bem básico, os tipos primitivos e os tipos referência. O conceito serve para qualquer linguagem, mas aqui quis forcar em `Javascript`.

## Primitive Types

Os `Primitive Types` são aqueles que já "vem com a linguagem", o básico do básico e que usamos diariamente.

Abaixo seguem **alguns exemplos**, ou seja, **existem outros além desses**:

```javascript
typeof("Tipos Javascript") output: string
typeof(0) output: number
typeof(null) output: object
typeof(undefined) output: undefined
typeof(true) output: boolean
```

Quando usamos tipos primitivos estamos passando o valor "cru" daquela variável e não a variável em si. 

Por exemplo:

```javascript
var tipoPrimitivoNumber = 5

function alterarNumero(tipoPrimitivoNumber) {
    console.log("tipoPrimitivoNumber - Antes", tipoPrimitivoNumber)
    //output: tipoPrimitivoNumber - Antes 5

    tipoPrimitivoNumber = tipoPrimitivoNumber + 5

    console.log("tipoPrimitivoNumber - Depois", tipoPrimitivoNumber)
    //output: tipoPrimitivoNumber - Depois 10
}

alterarNumero(tipoPrimitivoNumber)
console.log(tipoPrimitivoNumber)
//output: 5
```

Quando fazemos a chamada a função `alterarNumero`, passamos como parâmetro o `tipoPrimitivoNumber` que tem valor 5. Dentro desta função logamos o valor antes da somatória (5) e após a somatória (10), mas no final após rodarmos a função o programa loga para a mesma variável o numero 5! 

Por que quando logamos a variável após executar a função o seu valor continua o mesmo?!

É simples, quando trabalhamos com `tipos primitivos`, estamos trabalhando com o VALOR daquela variável e não com a variável em si. 

Então, quando passamos para a função `alterarNumero` um parâmetro do `tipo primitivo`, o programa substitui o valor do parâmetro da função pelo valor da variável e não pela variável em si.

Seria a mesma coisa que fazer desta forma e esperar que o resultado final mudasse:

```javascript
alterarNumero(5)
```

A diferença desta forma, para a chamada com a variável é que o programa substitui a `variável` quando a função é chamada e aqui estamos passando diretamente o valor.

> *Caso ainda não tenha entendido, leia até o final que com a explicação dos `Reference Types` vai ficar mais claro.*

## Reference Types

Os `Reference Types` são os `objetos`, ou `object`, com exceção do tipo primitivo `null` que quando utilizamos o `typeof(null)` nos devolve que é um `object`, mas, na verdade isso foi um bug introduzido no começo do `Javascript` que não foi corrigido até hoje.

Acredito que você já tenha ouvido falar que uma variável é um espacinho salvo na memória para um dado. Certo? Caso não tenha ouvido, agora você já sabe.

O que diferencia os dois tipos é que os `Reference Types` quando são utilizados, o valor deles é passado por referência a esse espacinho salvo em memória, ou seja, o que estamos utilizando é a variável em si e não o seu valor "cru". 

Exemplo:

```javascript
let objetoA = { objeto1: 2 }

function alterarValor(objB) {
    objB.objeto1 = 4; output: 4
}

alterarValor(objetoA);
console.log(objetoA) output: 4
```

Neste caso, quando passamos o parâmetro `objetoA` para a função `somarValor` não estamos passando o seu valor e sim o objeto salvo lá na memória do computador então toda alteração que for feita neste parâmetro afeta diretamente a raiz.

Termino por aqui esse post e peço que qualquer dúvida/erro/sugestão me informem para que eu ajuste!

Abs,
GC.


Bônus1:

undefined x null

`undefined` significa que nenhum valor foi atribuído aquela variável e o `null` uma ausência de valor intencional.

```javascript
let inicializandoVariavel = null;

if(inicializandoVariavelComNomeErrado) {}
// Uncaught ReferenceError: inicializandoVariavelComNomeErrado is not defined (undefined)
```

Bônus2:

Neste trecho de código utilizamos na função o parâmetro com nome `objB` intencionalmente, para indicar que não importa o nome que você da ao parâmetro da sua função, pois o valor que irá valer é sempre o que for passado na invocação.

```javascript
let objetoA = { objeto1: 2 }

function alterarValor(objB) {
    objB.objeto1 = 4; output: 4
}

alterarValor(objetoA);
console.log(objetoA) output: 4
```

Chamamos a função `somarValor(objetoA)` passando o `objetoA` como parâmetro e o programa automaticamente substitui o parâmetro objB pelo `objetoA` e apenas dentro do `escopo` desta função o `objetoA` se chamará objB como um apelido para aquela variável, válido apenas dentro daquela função.