Variáveis em Rust

Uma variável é só um nome que você dá a um valor para poder usá-lo depois. Pense nela como uma caixa com etiqueta: você coloca algo dentro da caixa, escreve um nome nela e passa a usar esse nome em vez de repetir o valor em todo lugar.

Criando uma variável

Em Rust, você cria uma variável com a palavra-chave let:

fn main() {
    let age = 30;
    println!("Minha idade é {age}");
}

Saída:

Minha idade é 30

▶ Experimente você mesmo

Vamos destrinchar essa linha:

• let: avisa ao Rust “estou criando uma variável nova”.
• age: o nome que escolhemos.
• =: atribui o valor da direita ao nome da esquerda.
• 30: o valor que estamos guardando.

O {age} dentro do println! imprime o valor da variável. Isso se chama interpolação de strings: o Rust troca {age} pelo que estiver guardado em age.

O Rust descobre o tipo para você

Todo valor em Rust tem um tipo (um número inteiro, um texto, true/false e assim por diante). Talvez você espere ter que declarar esse tipo, mas normalmente não precisa: o Rust olha o valor e deduz sozinho. Isso se chama inferência de tipos.

fn main() {
    let score = 95;        // o Rust deduz que é um inteiro
    let name = "Ferris";   // o Rust deduz que é texto
    let is_active = true;  // o Rust deduz que é um booleano
    println!("{name}: {score}, ativo = {is_active}");
}

Saída:

Ferris: 95, ativo = true

▶ Experimente você mesmo

Se quiser deixar explícito, escreva o tipo depois de dois-pontos:

let score: i32 = 95; // i32 = um inteiro de 32 bits

Nota

i32 quer dizer só “um número inteiro que cabe em 32 bits”. Não se preocupe com os tipos exatos ainda: vamos ver todos eles em Tipos de dados. Por enquanto, deixar o Rust deduzir está ótimo.

Variáveis são imutáveis por padrão

Esta é a parte que surpreende quem vem de outras linguagens: em Rust, depois que você define uma variável, por padrão não dá para mudá-la. “Imutável” quer dizer simplesmente que não pode ser alterado.

Este código não compila:

fn main() {
    let count = 1;
    count = 2; // ❌ erro: não é possível atribuir duas vezes a uma variável imutável
    println!("{count}");
}

O compilador barra você com uma mensagem clara (em inglês, como todas as mensagens do rustc):

error[E0384]: cannot assign twice to immutable variable `count`

Ela diz que não é possível atribuir um valor duas vezes à variável imutável count. Por que uma linguagem faria isso de propósito? Porque muitos bugs vêm de valores que mudam quando você não esperava. Ao deixar tudo inalterável, a não ser que você peça para mudar, o Rust deixa seu código mais previsível. É um recurso, não uma limitação.

Permitindo mudanças com mut

Quando você realmente precisa que um valor mude, adicione a palavra-chave mut (abreviação de mutable, mutável, ou seja, que pode mudar):

fn main() {
    let mut count = 1;
    println!("Antes: {count}");

    count = 2; // ✅ agora pode, por causa do `mut`
    println!("Depois: {count}");
}

Saída:

Antes: 1
Depois: 2

▶ Experimente você mesmo

Dica

Um bom hábito: comece sem mut. Só adicione quando o compilador reclamar que você está tentando mudar um valor. Assim suas variáveis continuam imutáveis, a não ser que realmente precisem mudar.

Shadowing: reaproveitando o mesmo nome

O Rust deixa você declarar uma variável nova com o mesmo nome de uma antiga. Isso se chama shadowing (sombreamento): a nova “faz sombra” sobre a antiga:

fn main() {
    let x = 5;
    let x = x + 1;   // um novo x, baseado no x antigo -> 6
    let x = x * 2;   // mais um novo x -> 12
    println!("x vale {x}");
}

Saída:

x vale 12

▶ Experimente você mesmo

Parece com o mut, mas é diferente:

• mut muda o valor da mesma variável.
• Shadowing cria uma variável totalmente nova que só reaproveita o nome, e ela pode até ter outro tipo.

O shadowing é útil quando você quer transformar um valor, mas continuar usando o mesmo nome:

fn main() {
    let spaces = "   ";        // texto
    let spaces = spaces.len(); // agora é um número (quantos espaços)
    println!("Número de espaços: {spaces}");
}

Saída:

Número de espaços: 3

▶ Experimente você mesmo

Constantes

Uma constante é um valor que nunca muda e é definido em tempo de compilação. Você a declara com const em vez de let, e precisa escrever o tipo:

const MAX_SCORE: u32 = 100;

fn main() {
    println!("A pontuação máxima é {MAX_SCORE}");
}

Saída:

A pontuação máxima é 100

▶ Experimente você mesmo

Por convenção, constantes são escritas em UPPER_SNAKE_CASE. Veja como elas se comparam com as variáveis comuns:

	Variável let	Constante const
Pode mudar?	Só com mut	Nunca
Tipo obrigatório?	Opcional (inferido)	Obrigatório
Estilo do nome	snake_case	UPPER_SNAKE_CASE
Onde pode ficar	Dentro de funções	Em qualquer lugar, até fora de funções

Use constantes para valores que são realmente fixos, como o número de segundos em um minuto ou um limite máximo.

Regras de nomes

• Use snake_case: palavras em minúsculas separadas por sublinhado, como user_name e total_price.
• Nomes podem ter letras, números e sublinhados, mas não podem começar com número.
• Escolha nomes descritivos: age é melhor do que a.

Erros comuns

• Esquecer o mut quando você precisa mudar um valor → cannot assign twice to immutable variable.
• Usar uma variável antes de criá-la → o let precisa vir primeiro.
• Variáveis não usadas geram um aviso (warning). Se for de propósito, coloque um sublinhado no começo do nome: let _unused = 5;.

Prática

1. Subindo de nível

Crie uma variável level que começa em 1. Imprima o valor, aumente em 1 duas vezes e imprima depois de cada mudança, para obter Nível 1, Nível 2, Nível 3. Dica: um valor que muda precisa de mut, e level = level + 1; soma um.

Ver solução

fn main() {
    let mut level = 1;
    println!("Nível {level}");

    level = level + 1;
    println!("Nível {level}");

    level = level + 1;
    println!("Nível {level}");
}

Saída:

Nível 1
Nível 2
Nível 3

▶ Experimente você mesmo

2. Minutos em segundos

Declare uma constante SECONDS_PER_MINUTE com o valor 60. Comece com let time = 5; (em minutos), depois faça shadowing de time para que ela guarde a mesma duração em segundos, e imprima Isso dá 300 segundos. Dica: o novo time pode ser construído a partir do antigo: let time = time * ...;.

Ver solução

const SECONDS_PER_MINUTE: u32 = 60;

fn main() {
    let time = 5; // minutos
    let time = time * SECONDS_PER_MINUTE; // um novo `time`, agora em segundos
    println!("Isso dá {time} segundos");
}

Saída:

Isso dá 300 segundos

▶ Experimente você mesmo

Não precisa de mut: o segundo let cria uma variável totalmente nova que reaproveita o nome. O Rust também deduz que time é um u32 aqui, porque ele é multiplicado pela constante u32.

Resumo

• Crie variáveis com let; normalmente o Rust deduz o tipo para você.
• Variáveis são imutáveis por padrão. Adicione mut para permitir mudanças.
• Shadowing declara de novo um nome com let, criando uma variável nova (que pode ter outro tipo).
• Constantes (const) nunca mudam, sempre precisam de tipo e usam UPPER_SNAKE_CASE.

Teste o que aprendeu

Teste o que aprendeu

1. Por padrão, dá para atribuir um novo valor a uma variável let em Rust?

Sim, sempre Não, a não ser que ela seja declarada com mut Só se for um número

2. O que é shadowing em Rust?

Declarar uma nova variável com let reaproveitando um nome que já existe Esconder uma variável de outras funções Tornar uma variável privada

3. Segundo esta página, qual convenção de nomes as variáveis em Rust usam?

camelCase PascalCase snake_case

Pontuação: 0 / 3

Para saber mais

• Variables and Mutability — The Rust Book (em inglês): o capítulo oficial sobre let, mut, constantes e por que a imutabilidade é o padrão.
• Shadowing — The Rust Book (em inglês): mais sobre a diferença entre shadowing e mut, incluindo a troca do tipo de um valor.
• Variable Bindings — Rust by Example (em inglês): exemplos curtos que você pode rodar, com continuações sobre mutabilidade e escopo e shadowing.
• Constants — Rust by Example (em inglês): const (e seu primo static) em um programa pequeno.
• Palavra-chave let — documentação da biblioteca padrão (em inglês): tudo o que o let pode fazer, para quando você quiser o quadro completo.