Variáveis, Mutabilidade e Shadowing

let cria vinculações. Imutabilidade é o padrão; mut opta pela reatribuição. Shadowing permite reutilizar um nome com um novo tipo ou valor sem tornar tudo mutável.

Receita

const MAX_RETRIES: u32 = 3;
 
fn main() {
    let input = "42";
    let input: u32 = input.parse().unwrap();
    let mut attempts = 0;
    attempts += 1;
    println!("parseado {input}, tentativa {attempts}, máximo {MAX_RETRIES}");
}

Quando usar isso: Sempre que precisar de estado local claro. Prefira vinculações let imutáveis e shadowing em vez de espalhar mut por toda parte.

Exemplo Funcional

const DEFAULT_PORT: u16 = 8080;
 
fn parse_port(raw: &str) -> u16 {
    let raw = raw.trim();
    let port: u16 = raw.parse().expect("porta deve ser um número");
    port
}
 
fn main() {
    let mut log_level = "info";
    log_level = "debug";
 
    let port = parse_port(" 3000 ");
    println!("porta={port}, log={log_level}, padrão={DEFAULT_PORT}");
}

O que isso demonstra:

• const para constantes de tempo de compilação com tipos explícitos
• Shadowing de raw após o trim sem mut
• mut apenas onde a reatribuição é necessária (log_level)
• Pipeline de análise que reatribui o mesmo nome com um novo tipo

Análise Detalhada

Como Funciona

• let introduz uma nova vinculação no escopo atual
• Vinculações imutáveis não podem ser reatribuídas (x = 1 falha)
• mut permite a reatribuição da própria vinculação
• Shadowing cria uma nova vinculação que oculta a anterior no mesmo escopo

let vs const vs static

const KB: u32 = 1024;
static APP_NAME: &str = "myapp";

Shadowing na Prática

Shadowing é comum em cadeias de análise:

let spaces = "   ";
let spaces = spaces.len(); // agora usize, não &str

Ao contrário de mut, shadowing pode mudar o tipo porque cada let é uma nova vinculação.

Notas do Rust

let (x, y) = (1, 2);
let [first, ..] = [10, 20, 30];

A desestruturação em vinculações let desempacota tuplas, arrays e structs em uma única etapa.

Armadilhas

• Usar mut quando shadowing é suficiente - Pipelines de análise se tornam mais difíceis de seguir. Correção: Use shadowing com let parsed = input.parse()? em vez de mutar um buffer de string.
• Confundir mutabilidade de vinculação com mutabilidade interna - let x = Rc::new(RefCell::new(0)) não precisa de mut em x para chamar borrow_mut. Correção: Entenda que mut é sobre a vinculação, não sobre o conteúdo do heap.
• Constantes em caminhos críticos com valores de tempo de execução - const não pode usar String::from em tempo de execução. Correção: Use const para literais; use static ou lazy_static/OnceLock para inicialização em tempo de execução.
• Shadowing oculta bugs - Reutilizar nomes agressivamente obscurece qual valor está ativo. Correção: Use shadowing apenas em pipelines curtos; use nomes distintos em funções longas.
• Vinculações de underscore descartam intencionalmente - let _ = expensive(); ainda executa a expressão. Correção: Prefira _ apenas quando o efeito colateral ou o descarte for intencional.

Alternativas

FAQs

Relacionados

• Rust Basics - primeira visão geral da linguagem
• Scalar & Compound Types - tipos por trás das vinculações
• The Type System & Inference - anotações e inferência
• Ownership Preview - como os movimentos interagem com let

Versões da Pilha: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4 e Polars 0.46+.