Learn Rust Coding · Aula

let e mutabilidade

Vinculações e mutabilidade

let e mutabilidade é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 1 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.

Vinculando valores com let

No Rust, você cria uma variável com a palavra-chave let. Isso vincula um nome a um valor.

Por padrão, toda vinculação é imutável — depois que você atribui um valor a ela, não pode alterá-lo.

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
}

Imutável por padrão

Rust torna as variáveis imutáveis de propósito. Isso evita alterações acidentais e facilita a compreensão do código.

Tentar atribuir um novo valor a uma vinculação imutável causa um erro de compilação, não uma falha durante a execução.

let x = 5; seguido de x = 6; não será compilado.

fn main() {
    let x = 5;
    // x = 6; // this would cause a compile error
    println!("x stays {}", x);
}

Tornando variáveis mutáveis

Quando precisar alterar um valor, adicione a palavra-chave mut. Isso marca a vinculação como mutável.

Agora você pode atribuir novos valores a ela quantas vezes quiser.

fn main() {
    let mut count = 0;
    count = count + 1;
    count += 1;
    println!("count is {}", count);
}

Inferência de tipos

Rust geralmente descobre o tipo de uma variável a partir do valor dela. Isso é chamado de inferência de tipos.

let x = 5; atribui automaticamente a x o tipo i32.

fn main() {
    let n = 42;      // inferred as i32
    let pi = 3.14;   // inferred as f64
    println!("{} and {}", n, pi);
}

Anotações de tipo

Você também pode declarar o tipo explicitamente usando dois-pontos e um nome de tipo. Isso é uma anotação de tipo.

As anotações são úteis quando o compilador não consegue inferir o tipo ou quando você quer deixar o código mais claro.

fn main() {
    let age: u32 = 30;
    let price: f64 = 9.99;
    println!("age {} price {}", age, price);
}

Constantes

Uma const é sempre imutável e deve ter uma anotação de tipo. Seu valor precisa ser conhecido durante a compilação.

Por convenção, as constantes usam SCREAMING_SNAKE_CASE.

fn main() {
    const MAX_POINTS: u32 = 100_000;
    println!("Max is {}", MAX_POINTS);
}

const vs let

Principais diferenças entre const e let:

const nunca pode ser mut.
const exige uma anotação de tipo.
const deve ser uma expressão constante em tempo de compilação.
Os valores de let podem ser calculados durante a execução.

fn main() {
    const SECONDS_PER_HOUR: u32 = 60 * 60;
    let hours = 3;
    println!("{} seconds", SECONDS_PER_HOUR * hours);
}

Alterando valores em um loop

Variáveis mutáveis são comuns em loops nos quais um valor se acumula ao longo do tempo.

Aqui somamos números usando um acumulador mut.

fn main() {
    let mut total = 0;
    for i in 1..=5 {
        total += i;
    }
    println!("Sum is {}", total);
}

Sublinhado para valores não utilizados

Se você vincular um valor, mas nunca o usar, Rust emitirá um aviso. Prefixe o nome com um sublinhado para silenciar o aviso.

let _unused = 10; informa ao compilador que isso é intencional.

fn main() {
    let _temp = 99;
    let used = 1;
    println!("{}", used);
}

Várias vinculações

Você pode declarar várias variáveis em linhas separadas, cada uma com seu próprio let.

Cada vinculação é independente e imutável, a menos que seja marcada com mut.

fn main() {
    let name = "Rust";
    let year = 2010;
    let mut version = 1;
    version += 1;
    println!("{} born {} v{}", name, year, version);
}

Por que a imutabilidade ajuda

A imutabilidade é um recurso de segurança. Quando o compilador sabe que um valor não pode mudar, ele pode oferecer garantias mais fortes e evitar classes inteiras de erros.

Opte pela alteração com mut somente quando realmente precisar dela.

fn main() {
    let config = "production";
    // config is guaranteed not to change
    println!("Running in {}", config);
}

Verificação rápida

Qual palavra-chave torna uma variável do Rust alterável?

Recapitulação

Você aprendeu os conceitos básicos das vinculações no Rust:

let vincula um nome a um valor, sendo imutável por padrão.
mut torna uma vinculação mutável.
Rust infere os tipos, mas você pode adicionar anotações com :.
const é avaliada durante a compilação, é sempre imutável e precisa de um tipo.

fn main() {
    let mut score: u32 = 0;
    const BONUS: u32 = 10;
    score += BONUS;
    println!("Final score: {}", score);
}

Perguntas Frequentes

A aula “let e mutabilidade” é grátis?

Sim — o texto completo de “let e mutabilidade” é 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 “let e mutabilidade”?

Vinculações e mutabilidade 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 1 de 4.

Quanto tempo leva a aula “let e mutabilidade”?

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