Learn Rust Coding · Aula

Sombreamento

Vinculação novamente de variáveis

Sombreamento é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

O que é ocultação?

Ocultação significa declarar uma nova variável com o mesmo nome de uma anterior. A nova vinculação “oculta” a antiga.

Para fazer isso, repita let com o mesmo nome.

fn main() {
    let x = 5;
    let x = x + 1;
    let x = x * 2;
    println!("x is {}", x);
}

Ocultação não é mutação

A ocultação cria uma variável totalmente nova. Isso é diferente de mut, que reutiliza a mesma variável.

Como cada let é uma nova vinculação, os valores podem até ter tipos diferentes.

fn main() {
    let y = 10;        // immutable
    let y = y + 5;     // new binding, also immutable
    println!("y is {}", y);
}

Alterando tipos com ocultação

Um uso poderoso da ocultação é reutilizar um nome enquanto o tipo é alterado.

Aqui, uma cadeia de texto é convertida em um número sob o mesmo nome.

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();
    println!("count is {}", spaces);
}

Por que mut não pode alterar o tipo

Com mut, você pode alterar o valor, mas não o tipo.

Isto falharia na compilação:

let mut spaces = " ";
spaces = spaces.len(); — erro de incompatibilidade de tipos.

A ocultação evita isso porque cria uma nova variável.

fn main() {
    let mut count = 3;
    count = 4; // ok, same type
    println!("{}", count);
}

Ocultação em escopos internos

Uma variável pode ser ocultada dentro de um bloco interno. Quando o bloco termina, a vinculação externa volta a ficar visível.

fn main() {
    let n = 1;
    {
        let n = n * 10;
        println!("inner {}", n);
    }
    println!("outer {}", n);
}

Transformando passo a passo

A ocultação permite transformar um valor em várias etapas mantendo um único nome claro.

fn main() {
    let input = "42";
    let input: i32 = input.trim().parse().unwrap();
    let input = input * 2;
    println!("result {}", input);
}

A ocultação mantém a imutabilidade

Cada vinculação ocultada continua imutável. Após uma transformação, você mantém a segurança da imutabilidade sem criar nomes como x2 ou x_temp.

fn main() {
    let price = 100;
    let price = price - 20;   // discount applied
    let price = price + 5;    // shipping added
    println!("final price {}", price);
}

Ocultação com lógica diferente

Você pode calcular o novo valor da maneira que quiser, inclusive usando chamadas de função ou expressões.

fn main() {
    let text = "hello";
    let text = text.to_uppercase();
    println!("{}", text);
}

Evitando confusão

A ocultação é útil, mas usá-la em excesso pode confundir os leitores. Use-a quando cada etapa for uma transformação clara do mesmo conceito, e não apenas para reciclar nomes aleatoriamente.

fn main() {
    let raw = "  Rust  ";
    let raw = raw.trim();      // clean version
    println!("[{}]", raw);
}

Resumo: ocultação versus reatribuição

Duas formas de dar um novo valor a um nome:

Ocultação: let x = ...; novamente — nova variável, pode alterar o tipo e continua imutável.
Reatribuição: x = ...; com mut — mesma variável, exigindo o mesmo tipo.

fn main() {
    let val = "7";
    let val: i32 = val.parse().unwrap(); // shadow + type change
    let mut val = val;
    val += 1;                            // reassign, same type
    println!("{}", val);
}

Um exemplo prático

Ler e converter dados do usuário é um caso clássico de ocultação: mantenha o nome significativo age enquanto o tipo muda de texto para número.

fn main() {
    let age = "25";
    let age: u32 = age.parse().unwrap();
    let age = age + 1; // next birthday
    println!("next year you will be {}", age);
}

Verificação rápida

Determine o que diferencia a ocultação do uso de mut.

Recapitulação

Ocultação no Rust:

Repita let com o mesmo nome para criar uma nova vinculação.
A nova vinculação pode ter um tipo diferente.
Cada valor ocultado continua imutável.
Ela é diferente de mut, que altera a mesma variável e mantém seu tipo.

fn main() {
    let data = "100";
    let data: i32 = data.parse().unwrap();
    let data = data / 4;
    println!("final {}", data);
}

Perguntas Frequentes

A aula “Sombreamento” é grátis?

Sim — o texto completo de “Sombreamento” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Sombreamento”?

Vinculação novamente de variáveis Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Sombreamento”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding