Pular para o conteúdo principal
Módulo 1 · Lição 1 de 21/14 no curso~10 min
Lições do módulo (1/2)

Variáveis e Mutabilidade

No Rust, o gerenciamento de variáveis ​​e memória é guiado por dois princípios fundamentais: segurança e controle. Por esse motivo, diferentemente de muitas outras linguagens de programação, as variáveis ​​em Rust são imutáveis ​​por padrão.

Isso significa que uma vez atribuído um valor a uma variável, ele não pode ser alterado. Se você tentar modificá-lo, o compilador gerará um erro.

Variáveis ​​imutáveis ​​e a palavra-chave mut

Para declarar uma variável, usamos a palavra-chave let:

Rust
let x = 5; // Immutable by default
// x = 6; // ERROR! The compiler will refuse to build this code.

Se precisar modificar o valor de uma variável, você deve torná-la explicitamente mutável usando a palavra-chave mut logo após let:

Rust
let mut y = 10; // Mutable
println!("Il valore di y e: {}", y);
y = 15; // Valid!
println!("Il valore modificato di y e: {}", y);

O uso do prefixo mut comunica claramente ao compilador e a qualquer pessoa que esteja lendo o código que o valor será alterado durante a execução.

Sombreamento

Rust também permite o conceito de shadowing, que é a redeclaração de uma variável com o mesmo nome usando a palavra-chave let novamente. A nova variável "sombra" (ou cobre) a anterior:

Rust
let x = 5;
let x = x + 1; // Shadowing: x is now 6
let x = x * 2; // Shadowing: x is now 12

Ao contrário de mut, o sombreamento permite:

  1. Altere o tipo de dados de uma variável mantendo o mesmo nome.
  2. Manter a imutabilidade da variável após as transformações.
Rust
let spaces = "   "; // Type: &str (string)
let spaces = spaces.len(); // Type: usize (number)

Utilidade de sombreamento e escopos

O sombreamento não está limitado ao mesmo bloco; ele pode ser usado em blocos aninhados ({}) para substituir temporariamente um valor. Quando o bloco interno termina, a variável original fica visível novamente:

Rust
let x = 5;
{
    let x = x * 2; // Shadowing valid only inside the block
    println!("Value in the inner block: {}", x); // Prints 10
}
println!("Value in the outer block: {}", x); // Prints 5

Este mecanismo é extremamente seguro e eficiente porque ocorre inteiramente em tempo de compilação, garantindo segurança de tipo sem qualquer sobrecarga de desempenho em tempo de execução.

Experimente você mesmo

Exercício#rust.m1.l1.e1
Tentativas: 0Carregando…

Declare uma variável mutável chamada x com um valor inicial de 5. Em seguida, adicione 10 a x e imprima-o na tela usando o comando println! macro.

Carregando editor…
Mostrar dica

Declare a variável com `let mut x = 5;`, depois incremente-a com `x += 10;` (ou `x = x + 10;`) e finalmente imprima-a com `println!('{}', x);`.

Solução disponível após 3 tentativas

Exercício#rust.m1.l1.e2
Tentativas: 0Carregando…

Declare uma variável imutável y com um valor de 10. Shadow y declarando-o novamente com let para multiplicar seu valor anterior por 2 e, finalmente, imprima-o usando println!.

Carregando editor…
Mostrar dica

Use `let y = 10;`, then shadow it by declaring it again with `let y = y * 2;` and finally use `println!` to display it.

Solução disponível após 3 tentativas

Exercício#rust.m1.l1.e3
Tentativas: 0Carregando…

Declare an immutable variable named input containing the string value "42". Shadow input by declaring it as an integer of type i32, converting the original value via input.parse::<i32>().unwrap(). Finally, print it using the println! macro.

Carregando editor…
Mostrar dica

Declare `let input = "42";`, then shadow it with `let input: i32 = input.parse().unwrap();` and print it using `println!("{}", input);`.

Solução disponível após 3 tentativas