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.
Top comments (0)