Tweet

Declaração e Atribuição de Variáveis em Rust

Variável é um local reservado na memória RAM do computador utilizado para armazenar de forma temporária os dados que são empregados pelo programa em execução.

Assim, as variáveis em Rust são elementos fundamentais da linguagem e permitem armazenar valores na memória do computador para uso posterior.

Ao contrário de algumas outras linguagens, o Rust possui um sistema de tipagem forte e estática, o que significa que o tipo de uma variável deve ser especificado durante a declaração e não pode ser alterado posteriormente.

Sintaxe

A declaração de variáveis em Rust é feita usando a palavra-chave let. Por exemplo:

let x = 5;
let y = 10;
let z = x + y;
println!("O valor de z é {}", z);

Este trecho código declara três variáveis x, y e z, onde x e y são atribuídos os valores 5 e 10, respectivamente. A variável z é inicializada com a soma de x e y.
O comando println!(“O valor de z é {}”, z); exibe o valor da variável z na saída padrão.

Variáveis mutáveis e imutáveis

Na verdade, existem duas formas básicas de declaração de variáveis em Rust: as variáveis podem ser mutáveis ou imutáveis. Variáveis imutáveis são declaradas usando a palavra-chave let, enquanto variáveis mutáveis são declaradas usando a expressão let mut.

Exemplos:

// declarar uma variável imutável x e atribuir o valor 10 a ela
let x = 10;
// declarar uma variável mutável y e atribuir o valor 5 a ela
let mut y = 5; 

Mas qual a diferença entre variáveis mutáveis e imutáveis? O que ocorre é que o valor atribuído a uma variável imutável não pode ser alterado após a atribuição, ao passo que o valor atribuído a uma variável mutável pode ser alterado a qualquer momento.

É importante notar que, em Rust, as variáveis são, por padrão, imutáveis. Isso significa que, se você tentar alterar o valor de uma variável imutável, o compilador emitirá um erro. Ou seja, se comportam como constantes. Por exemplo:

let z = 20; // z é uma variável imutável com valor 20
z = 25; // erro: tentativa de atribuir a uma variável imutável

Resumindo, variáveis mutáveis permitem que o valor de uma variável seja alterado durante a execução do programa, enquanto variáveis imutáveis não permitem que o valor atribuído seja modificado posteriormente. O uso adequado de variáveis mutáveis e imutáveis é importante para garantir a segurança e a confiabilidade do código Rust.

Escopo de Variáveis

O escopo de uma variável é o local no código da aplicação em que ela é válida e pode ser acessada. Em Rust, o escopo de uma variável é definido pelo local onde ela se encontra ou por um par de chaves { }.

Uma variável declarada dentro de um escopo interno só é válida e acessível dentro daquele escopo e em seus subescopos.

Exemplo:

fn main() {
  let x = 10;
  {
      let y = 5;
      println!("x + y = {}", x + y); // x e y são válidas apenas dentro desse escopo
  }
  println!("x = {}", x); // x é válida fora do escopo interno
  println!("y = {}", y); // y não é válida fora do escopo interno
}

Neste exemplo criamos duas variáveis, x e y, em dois escopos distintos. A variável x é criada com um escopo mais amplo (externo), ao passo que a variável y possui um escopo mais limitado por ter sido criada dentro de um bloco delimitado por chaves.

Por conta disso, as variáveis x e y podem ser acessadas e usadas dentro do escopo interno, pois são visíveis ali, mas a variável y não pode ser usada fora desse escopo, pois não é válida nesse local do código. Ou seja, será gerado o erro a seguir  ao tentar executar a última linha do código:

error[E0425] : cannot find value `y` in this scope

Que significa “não é possível encontrar o valor `y` neste escopo“.

Nas próximas lições vamos explorar operadores variados em Rust, empregados para realizar operações aritméticas, comparação de valores e operações lógicas, entre outras.