Entendendo como funciona variáveis e mutabilidade no Rust.
Por padrão no Rust as variáveis declaradas são imutáveis, essa é uma das maneiras do rust trazer seguranças para o código mas não quer dizer que não pode ser mutáveis.
Vamos criar um projeto simples com o cargo, executando o simples comando:
$ cargo new bin medium
Vamos para o arquivo /src/main.rs e declaramos uma variável chamado saldo com o valor de 30 e após a impressão com o println! adicionaremos outro valor para que possamos vê se realmente irá mudar.
fn main() {
let saldo = 30;
println!("o saldo é : {}", saldo);
saldo = 36;
println!("o saldo é : {}", saldo);
}
/*
error[E0384]: cannot assign twice to immutable variable `saldo`
--> main.rs:21:5
|
19 | let saldo = 30;
| ----- first assignment to `saldo`
20 | println!("o saldo é : {}", saldo);
21 | saldo = 36;
| ^^^^^^^^^^ cannot assign twice to immutable variable
*/
Nesse simples experimento o compilador informa que a variável saldo não pode rescrever outro valor porque como o próprio compilador diz “cannot assign twice to immutable variable” não pode atribuir duas vezes a variável imutável.
Em Rust, o compilador garante que quando você declara uma variável por padrão será imutável caso queira que seja mutável coloque mut na frente da declaração.
fn main() {
let mut saldo = 30;
println!("o saldo é : {}", saldo);
saldo = 36;
println!("o saldo é : {}", saldo);
}
/*
o saldo é : 30
o saldo é : 36
*/
Temos uma diferença entre variáveis mutáveis e constantes, nas constantes não poderá usar o mut pois não são só imutáveis por padrão, constantes são sempre imutáveis. Para declarar uma variável constante basta usar const.
fn main() {
const mut saldo = 30;
println!("o saldo é : {}", saldo);
saldo = 36;
println!("o saldo é : {}", saldo);
}
/*
error: const globals cannot be mutable
--> main.rs:19:11
|
19 | const mut saldo = 30;
| ^^^
|
= help: did you mean to declare a static?
error: expected `:`, found `=`
--> main.rs:19:21
|
19 | const mut saldo = 30;
| ^ expected `:`
error: aborting due to 2 previous errors
*/
Uma outra diferença entre mut é shadowing que consiste em criar uma nova variável com o mesmo nome usando a palavra-chave let.
fn main() {
let saldo = 30;
let saldo = 1 + saldo;
let saldo = 2 + saldo;
println!("o saldo é: {}", saldo)
}
/*
o saldo é: 33
*/
Mas teremos um porém se atribuir uma valor sem o let irá acontecer o error em tempo de compilação pois o shadowing é bem diferente do que dizer que uma variável é mut.
fn main() {
let saldo = 30;
saldo = 1 + saldo;
let saldo = 2 + saldo;
println!("o saldo é: {}", saldo)
}
/*
error[E0384]: cannot assign twice to immutable variable `saldo`
--> main.rs:24:5
|
22 | let saldo = 30;
| ----- first assignment to `saldo`
23 |
24 | saldo = 1 + saldo;
| ^^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable
*/
Teremos o error no tempo de compilação “cannot assign twice to immutable variable” não pode atribuir duas vezes a variável imutável. Isso também vale para o tipo dela por exemplo.
fn main() {
let name = "Higor Diego";
name = 2;
}
/*
error[E0308]: mismatched types
--> main.rs:21:12
|
21 | name = 2;
| ^ expected &str, found integral variable
|
= note: expected type `&str`
found type `{integer}`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.
*/
O error informa que = note: expected type &str found type {integer} que a variável espera um string e não inteiro.
Então galera é isso, espero que tenham gostado até a próxima.