Para escrever nossos programas na linguagem go, precisamos saber como declarar variáveis e constantes que vão armazenar os dados processados. Nesta parte do tutorial vamos aprender sobre o assunto.

Os conceitos sobre variáveis, constantes e escopo também foram vistos em Tutorial Portugol: Variáveis e Tutorial C: Variáveis.

A linguagem Rust, utiliza a palavra reservada let para reconhecer a declaração de uma variáveis.

Sintaxe 1

let nome_variavel tipo_dado;

Sintaxe 2

let nome_variavel tipo_dado = <valor>;

Sintaxe 3

let nome_variavel = <valor>;

Exemplo 1

let variavel1:u8;
let variavel2:u8 = 10;
let variavel3 = "valor inferido";

Saída

-

A linguagem Rust possui, assim como Lua, Python e JS, possui a característica de inferência de tipo. Isso significa que quanto declaramos uma variável iniciada não precisamos declarar seu tipo. A inferência é feita pelo compilador que decide qual é o tipo de dado baseando-se no valor atribuído.

Sintaxe

let nome_variavel = <valor>;

Exemplo 2

let nome1 = "string"

Saída

-

Diferente de muitas linguagens, variáveis criadas em Rust, assim como as criadas acima, são imutáveis por padrão. Na tentativa de atribuir um novo valor após uma primeira atribuição o compilador irá retornar um erro como abaixo:

Exemplo 3

fn main() {
    let variavel:i8;
    variavel = 10;
    variavel = 11; //Linha 4
}

Saída

(...)
 3 |     variavel = 10;
   |     ------------- first assignment to `variavel`
 4 |     variavel = 11;
   |     ^^^^^^^^^^^^^ cannot assign twice to immutable variable

Na linha 4 de nossa main, o compilador está nos informando que não podemos realizar duas atribuições a uma variável imutável chamada "variavel".

Para tornar nossas variáveis mutáveis de forma a que possamos manipulá-las, às declaramos fazendo uso da palavra reservada mut:

Sintaxe

let mut nome_variavel tipo_de_dado
let mut nome_variavel tipo_de_dado = <valor>
let mut nome_variavel = <valor>;

Exemplo 4

fn main() {
    let variavel:i8;
    variavel = 10;
    variavel = 11; //Linha 4
}

Saída

warning: unused variable: `variavel`
(...)

Caso seja necessário declarar uma variável não usada no momento, mas que seja desejada a sua declaração por algum motivo, Rust suporta o uso de underscore(_) como prefixo do nome da variável. Assim, o aviso warning "unused variable" é ignorado.

Exemplo 5

fn main() {
    let _var:u8=2;   
}

Saída

-

A linguagem Rust não nos permite criar variáveis globais com let ou let mut apenas. Um erro de compilação será gerado como pode ser visto no exemplo a seguir.

Exemplo 6

let VALOR:i8 = 2;
fn main() {
    //…omitido
}

Saída

1 | let VALOR:i8 = 2;
  | ^^^ consider using `const` or `static` instead of `let` for global variables

Para declarar uma variável global, utilizamos as palavras reservadas static mut como pode ser visto no exemplo abaixo:

Exemplo 6

static mut VALOR1:i8 = 2; //variavel

fn main() {
    unsafe { VALOR1+=1; }
}

Saída

-

Para declarar constantes em Rust utilizamos a palavra reservada const. comum em linguagens estilo-C, que informada que uma vez uma constante iniciada, não seja possível uma alteração posterior.

Sintaxe

const NOME_CONSTANTE tipo_dado = <valor>;

Exemplo 7

const valor:i8 = 2;

fn main() {
    let variavel= 2*valor;
}

Saída

1 | const valor:i8 = 2;
  |           ^^^^^ help: convert the identifier to upper case: `VALOR`

Como boa prática, o compilador irá emitir um aviso para utilizar constante com nomes em maiúsculas. Vamos seguir essa boa prática para uma melhor distinção entre variáveis e constantes.

Exemplo 8

const VALOR:i8 = 2;

fn main() {
    let variavel= 2*VALOR;
}

Saída

-

Utilizando nosso primeiro programa HelloWorld, podemos entender como funciona o escopo de variáveis e constantes locais e globais em Rust.

Todas variáveis e/ou constantes declaradas fora da função main são vistas como variáveis/constantes globais.

Exemplo 9

static mut VALOR1:i8 = 2; 
const VALOR2:i8 = 2;

fn main() {
    //omitiddo
}

Saída

-

As variáveis/constantes declaradas dentro de uma função ou dentro de um bloco de declaração são vistas como locais e são acessadas apenas internamente à função ou bloco de declaração.

Exemplo 10

fn main() {
 	let mut VALOR1:i8 = 2; 
const VALOR2:i8 = 2;
}

Saída

-

Um bloco de código em um escopo mais externo não pode acessar variáveis de um escopo mais interno.

Exemplo 11

fn main() {
    //escopo mais externo
    let variavel1:u8= 2;
    {
        //escopo mais interno
        let mut _variavel:u8;
        let variavel2:u8 = 10*variavel1; //acessando escopo mais externo
    }
}

Saída

-

Blocos de código em um escopo mais interno podem acessar variáveis de um escopo mais externo.

Exemplo 12

fn main() {
    //escopo mais externo
    let variavel1:u8 = 2;
    let variavel2:u8= _variavel;
    {
        //escopo mais interno
        let mut _variavel:i8;
        let _variavel = 10*variavel1; //acessando escopo mais externo
    }
}

Saída

4 |     let variavel2:u8= _variavel;
  |                       ^^^^^^^^^ help: a local variable with a similar name exists: `variavel1`

Agora que já estudamos o básico sobre tipos de dados e como declarar variáveis em Rust, vamos ver mais alguns exemplos de declarações de variáveis:

Exemplo 15

//inteiro
let mut valor1 i8 = 10;
let mut valor2 i16 = 10;
let mut valor3 i32 = 10

//float
let mut valor4 f32 = 10.10;
let mut valor1 i64 = 10.11;

//string literal
let mut _string1:&str = "uma string qualquer";  //imutável
let mut _string2 = "outra string qualquer";  //imutável
let mut _string3:&str;  //imutável
   
//char 
let mut _char1 = 'Z';
let mut _char2:char;

//bool
let valor:bool = false
let mut valor2:bool = true

//ARRAY
let mut _array1:[i8;5] = [1,2,3,4,5];

//string
let mut _array4:[&str;5] = ["um","dois","tres","quatro","cinco"];
let _array5 = ["um","dois","tres","quatro","cinco"];
let mut _array6:[&str;5];

//char
let _array6:[char; 5] = ['h', 'e', 'l', 'l', 'o'];

//matriz
let matriz1: [[i8; 2]; 3] = [[-1, 0], [0, 1],[1, 0]]; //integer
let matriz4: [[char; 2]; 3] = [['A','B'],['C','D'],['E','F']]; //char

//vector
let mut _vector1 = Vec::new();
let vector2 = vec![1,2,3]

//hashmap
let mut _hashMap = HashMap::new();

//hashSet
let mut _hashSet = HashSet::new();

A linguagem Rust, assim como todas as linguagens de programação, possue um conjunto de palavras reservadas que têm um significado único para a linguagem e não podem ser utilizadas na criação de variáveis, constantes e outros identificadores.

Tab. 1: Palavras reservadas

as	async	await	break
const	continue	crate	dyn
else	enum	extern	false
for	if	impl	in
let	loop	match	mod
mut	pub	ref	return
Self	self	static	struct
super	trait	true	union
unsafe	use	where	while
abstract	become	box	do
final	macro	override	try
typeof	unsized	virtual	yield

1. 12/11/2025 - versão inicial