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:

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.

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:

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:

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:

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:

cargo new variables
cd variables
code .

No arquivo main.rs vamos substituir o conteúdo existente por:

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:

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

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
Tour of Rust
CodeShow