Lição 4 de 18 · 15 min
Variáveis e mutabilidade
Entenda let, por que as variáveis do Rust são imutáveis por padrão, quando usar mut e const e como funciona o shadowing.
Ao terminar, você vai saber:
- Declarar variáveis com let
- Explicar por que as variáveis são imutáveis por padrão
- Usar mut quando um valor precisa mudar
- Diferenciar variável imutável de const
- Usar shadowing para reaproveitar um nome
Variável é um nome que aponta para um valor. No Rust, você cria uma com let:
fn main() {
let nome = "Lucas";
let idade = 31;
println!("{nome} tem {idade} anos.");
}
Até aqui, nada diferente de outras linguagens. A surpresa vem quando você tenta mudar o valor.
Imutável por padrão
Tente compilar isto:
fn main() {
let saldo = 100;
println!("Saldo: {saldo}");
saldo = 80;
println!("Saldo: {saldo}");
}
O compilador recusa:
error[E0384]: cannot assign twice to immutable variable `saldo`
|
2 | let saldo = 100;
| ----- first assignment to `saldo`
...
5 | saldo = 80;
| ^^^^^^^^^^ cannot assign twice to immutable variable
|
help: consider making this binding mutable
|
2 | let mut saldo = 100;
| +++
Traduzindo: “não dá para atribuir duas vezes a uma variável imutável”. E repare na parte help: o compilador já mostra a correção, com sinais de + indicando o que acrescentar.
No Rust, toda variável nasce imutável: depois de receber um valor, ela não muda. Por quê? Porque grande parte dos bugs vem de valores que mudam quando a gente não esperava. Se uma variável não pode mudar, você lê o código com tranquilidade: o valor que ela recebeu lá em cima é o mesmo aqui embaixo.
É como um documento assinado e registrado em cartório. Se precisa mudar, tem que deixar isso explícito.
Quando precisa mudar: mut
Para permitir a mudança, escreva mut depois do let:
fn main() {
let mut saldo = 100;
println!("Saldo inicial: {saldo}");
saldo = saldo - 20; // pagou um lanche
println!("Depois do lanche: {saldo}");
saldo += 50; // recebeu um Pix
println!("Depois do Pix: {saldo}");
}
Saída:
Saldo inicial: 100
Depois do lanche: 80
Depois do Pix: 130
O mut funciona como um aviso para quem lê o código: “atenção, esse valor vai mudar”. Use quando fizer sentido, e só quando fizer sentido.
Se você colocar mut e nunca mudar a variável, o compilador dá um aviso (warning) dizendo que o mut é desnecessário. Aviso não impede de compilar, mas vale a pena atender.
O tipo não muda
Mesmo com mut, a variável continua com o mesmo tipo. Se ela começou como número, não pode virar texto:
fn main() {
let mut quantidade = 3;
quantidade = "três";
println!("{quantidade}");
}
error[E0308]: mismatched types
|
2 | let mut quantidade = 3;
| - expected due to this value
3 | quantidade = "três";
| ^^^^^^ expected integer, found `&str`
O compilador esperava um número inteiro (integer) e encontrou um texto (&str). Você vai conhecer esses tipos na próxima lição.
Constantes: const
Existem valores que nunca mudam, em lugar nenhum do programa: o número de dias da semana, o limite de caracteres de um campo, a taxa de um serviço. Para eles, use const:
const DIAS_DA_SEMANA: u32 = 7;
const LIMITE_DE_PARCELAS: u32 = 12;
fn main() {
let semanas = 4;
println!("{semanas} semanas têm {} dias.", semanas * DIAS_DA_SEMANA);
println!("Parcelamos em até {LIMITE_DE_PARCELAS}x.");
}
Diferenças entre const e uma variável com let:
constexige o tipo escrito (o: u32). O compilador não adivinha.constnunca pode termut.- O valor precisa ser conhecido na hora de compilar. Não dá para usar algo que o usuário digita.
constpode ficar fora de qualquer função, valendo para o arquivo todo.- Por convenção, o nome vai em letras maiúsculas com
_separando as palavras.
Shadowing: reaproveitando o nome
O Rust deixa você declarar de novo uma variável com o mesmo nome, usando let outra vez. A nova esconde a antiga. Isso se chama shadowing (sombreamento):
fn main() {
let preco = 50;
let preco = preco + 10; // acrescenta o frete
let preco = preco * 2; // comprou dois
println!("Total: {preco}");
}
Saída:
Total: 120
Parece com mut, mas é diferente. Com shadowing, cada let cria uma variável nova. Duas consequências:
- Depois das transformações, a variável final continua imutável.
- A nova variável pode ter outro tipo.
O segundo ponto é muito útil. Imagine que você recebeu um texto com espaços e quer guardar só quantas letras ele tem:
fn main() {
let espacos = " ";
let espacos = espacos.len(); // agora é um número
println!("São {espacos} espaços.");
}
Sem shadowing, você teria que inventar dois nomes, tipo espacos_texto e espacos_numero. Com mut, isso nem compilaria, porque o tipo não pode mudar.
Shadowing dentro de um bloco
O sombreamento vale só dentro do bloco onde foi feito. Quando o bloco termina, a variável de fora volta a aparecer:
fn main() {
let x = 5;
{
let x = x * 2;
println!("Dentro do bloco: {x}");
}
println!("Fora do bloco: {x}");
}
Saída:
Dentro do bloco: 10
Fora do bloco: 5
Quando usar cada um
let: o padrão. Comece sempre por aqui.let mut: o valor precisa mudar ao longo do tempo, como um contador ou um saldo.const: valor fixo do programa inteiro, conhecido na compilação.- shadowing: você transforma um valor em etapas, ou converte de um tipo para outro, e o nome antigo não interessa mais.
Resumo
- Variáveis são criadas com
lete são imutáveis por padrão. mutpermite mudar o valor, mas não o tipo.constexige tipo, nome em maiúsculas e valor conhecido na compilação.- Shadowing cria uma variável nova com o mesmo nome, podendo mudar o tipo.
- Quando algo dá errado, leia o
helpdo compilador: ele costuma mostrar a correção.
Desafio
Escreva um programa que comece com uma meta de passos por dia em uma const (por exemplo, 8000). Crie uma variável mutável com os passos dados, some três caminhadas a ela e imprima o total e quantos passos faltam para a meta. Depois, use shadowing para transformar o total em um texto como "meta batida" ou "continue andando", e imprima.
Ver uma resposta
const META_DE_PASSOS: u32 = 8000;
fn main() {
let mut passos = 0;
passos += 2500; // ida ao trabalho
passos += 1800; // almoço
passos += 2900; // volta para casa
println!("Passos hoje: {passos}");
println!("Faltam: {}", META_DE_PASSOS.saturating_sub(passos));
// Shadowing: o nome continua, o tipo muda
let passos = if passos >= META_DE_PASSOS {
"meta batida"
} else {
"continue andando"
};
println!("Situação: {passos}");
}
O saturating_sub subtrai sem passar de zero, porque u32 não aceita números negativos. Você vai ver o if usado assim, como valor, na lição de controle de fluxo.