Rust - Tipos de dados
Tags: rust, types, introduction, developer
Published: 2021-09-26 17:36:56


![alt text](https://cdn-images-1.medium.com/max/1600/1*wL9FvRCwlO8X0ysJ8348kw.png)

Uma coisa que temos que ter em mente é que, essa linguagem é de tipagem *estática e forte*.

*Tipagem Estática* é a capacidade de uma linguagem ajudar na segurança de tipos. No momento que determina o tipo de uma variável esse tipo não pode ser alterado durante a compilação

*Tipagem forte* é capacidade de verificação de tipos em todas as operações em tempo de execução ou compilação.

No Rust existe quatro tipos escalar, que representa um único valor, que são inteiros, ponte flutuante, booleanos e caracteres. Esses tipos você deve recordar de outras linguagem.

### Tipo Inteiro

Os tipos inteiros é aquele que não possuem parte fracionada. No rust os tipos de declaração indica o valor associado. A baixo você tem a tabela de associados com base no seu tamanho.

![alt text](https://cdn-images-1.medium.com/max/1600/1*uM1WAdXCgE_bVAcCuLTDrQ.png)

O numero inteiro tem o seu sinal do tipo " i " se pegarmos o i32 como exemplo podemos identificar que é um inteiro que ocupa espaço de 32bits.

Na tabela temos uma coluna que se chama Unsigned ele representa a possibilidade de números negativos ou positivos com o Signed.

Se temos um numero que é duzentos e trinta negativo (-230) podemos informar que é um tipo Signed. Esse tipo é quando o numero necessita que o sinal venha com ele, caso contrario será um Unsigned.


### Tipos Flutuante

Ao contrario dos inteiros o tipo flutuante tem casas decimais. O rust tem dois tipos primitivos para o ponto flutuante que são o f32 e f64 com base na sua nomenclatura são de tamanhos 32bits e 64 bits de espaço.

Podemos analisar com o seguinte exemplo:

```rust
fn main() {

  let valor1 = 5.0 / f64
  let valor2:f32  = 3.0 / f32 

}
```

Na linha 2 do código podemos identificar que não foi declarado o tipo e o mesmo veio como f64. Isso acontece quando não declaramos ele vem por padrão.


### Tipo Booleano

Como toda a linguagem tem o seu booleano aqui no rust não é diferente o mesmo possui dois valores que é o *true* ou *false*.

Podemos declarar ele sem o tipo explícito ou não.

```rust
fn main() {

  let veradade = true
  let falso:bool = false

}
```

### Tipo Caractere

O tipo caractere é composto como *char* esse tipo é o mais primitivo da linguagem ele é composto por aspa simples.

```rust
fn main() {

  let z = 'z'

}
```


### Tipo Composto

Esse tipo pode agrupar vários tipos em um único tipo. Na linguagem temos dois primitivos composto que são *tuplas* e *vetores*.


#### Tuplas

Tuplas é uma forma de agrupar vários valores de tipos diferentes em uma só variável.

Podemos vê a *tupla* com valores múltiplos no exemplo abaixo:


```rust
fn main() {

  let tuplas: (f32, f64, u8) = (30.0, 3.5, 1)
  let (a, b, c) = tupla
  println!("o valor do a: {}", a)
  println!("o valor do b: {}", b)
  println!("o valor do c: {}", c)

}
```

*Na linha 6* retiramos cada valor que correspondia a sua tupla para a, b e c, transformando eles em valores separados.


#### Matriz
É uma forma de ter vários valores em uma coleção com um único tipo, diferente da tupla a matriz tem que ter os seus valores do mesmo tipo.

Podemos vê um caso de uma matriz abaixo.
```rust
fn main() {

  let matriz = [1, 2, 3, 4, 5]
  println!("matriz: {}", matriz[0])

}
```

*Na linha 6* acesso o index 0 da matriz, para imprimir o valor resultante que é 1.

Então galera é isso, espero que tenham gostado até a próxima.