Bases numéricas e Medidas de armazenamento
Tags: go, beginners, tutorial
Published: 2020-05-19 21:27:13

**AVISO**⚠️
*Esse é um post mais teórico, mas o conteúdo é importante para entender os tipos numéricos. Assunto de amanhã.*   

O post passado foi sobre os tipos primitivos. *Se você não viu, dá um pulinho lá! Vai facilitar o entendimento sobre o assunto de hoje* 👇

 {% link https://dev.to/linivecristine/tipos-primitivos-e-tipos-compostos-em-golang-37hf %}

Eu disse que existiam detalhes por trás de cada tipo primitivo. Bem, hoje vamos fazer uma introdução, criar uma base para em seguida entender esses detalhes mencionados. 

**Antes de mais nada, precisamos conhecer as bases numéricas**. Calma que não é nenhum bicho de sete cabeças! 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/d6jbpwooxc1kpppsi1ep.jpg)

- **Decimal**

O decimal já conhecemos bem, é nosso companheiro desde o jardim de infância.

**A base decimal vai de 0 a 9**. Sim, de 0 a 9, não é de 0 a 10.
``0, 1, 2, 3, 4, 5, 6, 7, 8, 9``  

Se chama decimal porque possui 10 números, o zero conta, e não porque vai até 10. 


- **Octal**

O nome parece estranho, mas ele não é muito diferente do decimal. **A base octal vai de 0 a 7**. 
``0, 1, 2, 3, 4, 5, 6, 7``

E o nome octal segue a mesma lógica do decimal, são 8 números contando com o zero. 

- **Hexadecimal**

Esse aqui é mais utilizado no mundo da programação. Ele **possui 10 números**, igual ao decimal, e **6 letras**. Juntando as duas informações, fica hexadecimal.
``0, 1, 2, 3, 4, 5, 6, 7, 9`` e ``a, b, c, d, e, f``

Ele é utilizado pois permite representar números muito grandes de forma mais suscita. Exemplo 

```golang

num := 198056 //decimal

fmt.Printf("num em octal: %#o", numero) // resultado: num em octal: 0602650
fmt.Printf("num em hexadecimal: %#X", numero) // resultado: num em hexadecimal: 0X305A8 
``` 

Outro detalhe importante. Utilizamos um **``0X``** antes do número para indicar que ele é hexadecimal e um **``0``** para indicar que é octal, assim não confundimos eles.

O resutado foi ``0X305A8``, mas o número real é apenas ``305A8``.

Vocês lembram dos formt verbs? ``%#o`` é o format verb para octal e ``%#X`` é para hexadecimal.  

- **Binário**

Possivelmente é a base mais importante para nós. 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/1cx9qhnddj7iak3rcslo.jpeg)

Binário trabalha apenas com dois números `` 0`` e ``1``. E o **computador trabalha apenas com números binários**, ou seja, um computador entende apenas `` 0`` e ``1``. 

**Tudo que fazemos em nossos computadores é traduzido para número binário.**

Um digito binário (0 ou 1), ou binary digit, é mais conhecido como bit. E o bit é a menor unidade de informação que pode ser armazenada ou transmitida, usada na computação. Ou seja, não existe nada menor que um bit. 

```golang

num := 198056 //decimal

fmt.Printf("num em binario: %b", numero) // resultado: num em binario: 110000010110101000
``` 

Existe muito assunto a ser estudado sobre bases numéricas. É possível converter uma base em outra com cálculos feitos a mão, *com código é fácil demais, para nossa alegria*. Também é possível fazer operações matemática com cada uma das bases. É importante salientar que todo conhecimento é válido, mas esses detalhes não serão tão utilizados no dia a dia. 

Já conhecemos as bases, sabemos o que é um bit e descobrimos que um computador trabalha apenas com eles. 

**O que falta para entrarmos nos detalhes dos tipos primitivos?**

Temos que conhecer as **medidas de armazenamento**.   

```golang

bit < byte < kilobyte < megabyte < gigabyte < terabyte 
``` 

- **Bit**
  
Já conhecemos esse carinha. É a menor unidade de armazenamento.

- **Byte**

Ele é composto por 8 bits. 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/j6ledzudyl8isn6kjaqt.png)

8 bits é igual a 1 byte. Eles são a mesma coisa

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/k8cbm05ea2wxtatlktgo.jpg)

- **Kilobyte**

Composto por 1024 bytes

- **Megabytes**

Composto por 1024 kilobytes

- **Gigabytes**

Esse aqui muita gente já conhece, é o mais utilizado para se referir a armazenamento de memória. 

Composto por 1024 megabytes

- **Tera**

Composto por 1024 gigabytes. 

*Pesquisas indicam que pessoas que possuem armazenamento em terabytes são mais felizes e menos estressadas. Fonte: Linive* 


 ![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/fqihekhni2yzjx3x0um0.png)

*Finalizamos as bases numéricas e as medidas de armazenamento. Agora vocês devem está se perguntando: Qual a ligação disso com os tipos numéricos?*

Lembram das variações de int? int8, int32, in64, uint8 ...

**Esses números depois do int são bits**, olha só que surpresa. Eles vão ser fundamentais na hora do armazenamento de uma variável. Agora que sabemos a base, será muito mais fácil entender os tipos numéricos e suas diferenças.

Espero que vocês estejam se sentindo bem durante a quarentena. 

**Se quiser ocupar a cabeça e ainda aprender uma coisa incrível, vem pro lado [programador](https://www.youtube.com/watch?v=WiGU_ZB-u0w&list=PLCKpcjBB_VlBsxJ9IseNxFllf-UFEXOdg) da força**.

Até amanhã!


![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/digx3bxstq1z5jm18lay.jpg)