Pular para o conteúdo
Rust em Português

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:

  • const exige o tipo escrito (o : u32). O compilador não adivinha.
  • const nunca pode ter mut.
  • O valor precisa ser conhecido na hora de compilar. Não dá para usar algo que o usuário digita.
  • const pode 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:

  1. Depois das transformações, a variável final continua imutável.
  2. 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 let e são imutáveis por padrão.
  • mut permite mudar o valor, mas não o tipo.
  • const exige 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 help do 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.

Salvo só neste navegador.