Aprendendo Rust: 03 - Variáveis
Tags: rust, tutorial
Published: 2020-07-17 11:00:02

E aee jovens, tudo bem com vocês?

Nesta postagem iremos entender um pouco sobre variáveis, como cria-las e usa-las, mutabilidade e imutabilidade, constantes e _shadowing_.

Então, lets'go!!!

## Variáveis, Mutabilidade e Imutabilidade

Variáveis são espaços na memória do computador destinadas a guardar um determinado dado. Podemos exemplificar como se fossem "caixas" para guardar algum item.

Para declararmos uma variável usamos a palavra reservada `let` vamos ver uns exemplos:

```rust
let x = 5;

let explicit_type: i32 = 32;

let y: f64;
y = 3.17;
```

`let x = 5;` -> onde "x" é o nome da variável e "= 5" atribuição do valor 5 em "x". _Rust_ é uma linguagem fortemente e estaticamente tipada, ou seja, toda e qualquer variável criada tem que possuir um tipo, nesta linha não estamos adicionando um tipo pois _Rust_ pode o inferir de acordo com o dado atribuído, isso ocorre em aproximadamente 99% dos casos, veremos em outra postagem casos que a _Rust_ não infere o tipo.

`let explicit_type: i32 = 32;` -> Mesmo sabendo que o tipo pode ser inferido automaticamente, temos a opção de explicitar o seu tipo desta forma. Mas por padronização na maioria dos casos não vamos fazer deste modo.

`let y: f64;`  `y = 3.17;` -> Temos a opção de declarar primeiro e inicializar depois, mas é muito incomum usar assim. Se a variável for declarada e não for inicializada e tentarmos utiliza-la teremos um erro de compilação, pois _Rust_ não permite que uma variável não tenha valor.

Como padronização os nomes de variáveis que possuírem nomes compostos vão ser escritas em _snake_case_, como por exemplo `explicit_type`.

Por padrão a _Rust_ utiliza as variáveis imutáveis, isso quer dizer que após inicializarmos não é possível modificar o seu valor. Essa é uma forma de manter seu código seguro e estabilizar a concorrência. No caso abaixo seria apresentado um erro.

```rust
let x = 5;
x = 7;
```

Porém temos a opção de tornar uma variável mutável, para isso adicionaremos a palavra chave `mut` desta forma:

```rust
let mut x = 5;
x = 7;
```

Assim podemos realizar alterações nesta variável.

Para imprimir o valor de uma determinada variável podemos fazer:

```rust
println!("O valor de x é {}", x);
```

Onde o _"{}"_ é um _curinga_, um _placeholder_ que substituímos pelo valor da variável que vem após a virgula.

## Constantes

Além das variáveis podemos criar constantes, elas sempre serão imutáveis, para criarmos constantes usamos a palavra chave `const` em vez de `let`, e o tipo precisa ser especificado. Veremos alguns tipos na próxima postagem.

Outra diferença nas constantes é que elas podem ser declaradas em qualquer escopo, incluindo o escopo global. Elas não podem ser resultados de funções ou algum valor que só poderia ser calculado em tempo execução.

Vamos ver um exemplo:

```rust
const PI: f64 = 3.14159;
```

Como padronização os nomes de constantes vão ser escritas em _SCREAMING_SNAKE_CASE_, como por exemplo `NOME_DE_CONSTANTE`.

## Shadowing

Na _Rust_ é possível declarar uma nova variável utilizando o mesmo nome que já foi usado antes, e esta nova sombreia a variável anterior, podendo mudar até mesmo o seu tipo. Vamos criar um projeto para exemplificar, entrar no diretório e executar o VS Code:

```bash
cargo new variables
cd variables
code .
```

No arquivo _main.rs_ vamos substituir o conteúdo existente por:

```rust
const PI: f64 = 3.14159;

fn  main() {
    let  mut x = 5;
    println!("O valor de x é {}", x);

    x = 7;
    println!("O valor de x é {}", x);

    let x = "Teste";
    println!("O valor de x é {}", x);

    println!("O valor da constante PI é {}", PI);
}
```

Como podemos ver, criamos uma variável chamada `x` e atribuímos a ela o valor `5`, isso quer dizer que ela é do tipo `i32`. Ela foi criada com a palavra `mut` isso quer dizer que ela é mutável, então pudemos alterar o valor desta variável atribuindo o valor `7` para ela. Mais abaixo declaramos uma variável com o mesmo nome, porem adicionamos um texto pra ela, isso quer dizer que o valor foi alterado e o tipo também. Poderíamos ter utilizado _shadowing_ mesmo se ela não fosse mutável. Vamos executar este projeto com o comando: `cargo run`. A saída será parecida com:

```bash
Compiling variables v0.1.0 (/home/pehdepano/dev/workspace/rust/learning_rust/03 - Variables/variables)
Finished dev [unoptimized + debuginfo] target(s) in 0.21s
Running `target/debug/variables`
O valor de x é 5
O valor de x é 7
O valor de x é Teste
O valor da constante PI é 3.14159
```

Como podemos começar a ver, _Rust_ tem um controle muito bom sobre como contornar alguns erros que são bem comuns na maioria das linguagens, forçando a inicialização da variável ela não permite por exemplo um _Null Pointer_ tão conhecido em linguagens como _Java_, _C#_, etc.

Vou adicionar o fonte desta postagem no _Github_, segue o link: [Aprendendo Rust](https://github.com/RichardJd/aprendendo-rust)

Quaisquer dúvidas ou sugestões para que eu melhore nas postagens deixe um comentário, e continue acompanhando os próximos posts.

# Referencias

[O livro de Rust](https://doc.rust-lang.org/book/)
[Tour of Rust](https://tourofrust.com/)
[CodeShow](https://www.twitch.tv/codeshow)