Tipos de dados em Rust

Todo valor em Rust tem um tipo: um rótulo que diz ao compilador que tipo de dado é aquele (um número inteiro, um decimal, um texto, verdadeiro/falso e assim por diante). Conhecer o tipo permite que o Rust confira seu código em busca de erros antes de ele rodar.

Como você viu em variáveis, normalmente o Rust consegue deduzir o tipo para você. Mas vale a pena conhecer os tipos principais pelo nome, porque eles aparecem em mensagens de erro e em assinaturas de funções.

Inteiros (números inteiros)

Inteiros são números sem casa decimal, como 42 ou -7. O Rust tem vários tipos de inteiro, que mudam de acordo com o tamanho e com a possibilidade de aceitar números negativos:

Tipo	Com sinal?	Uso típico
i32	Sim (pode ser negativo)	O padrão: use este, a não ser que tenha um motivo para não usar
u32	Não (de 0 para cima)	Contagens, tamanhos, coisas que não podem ser negativas
i64 / u64	Sim / Não	Números muito grandes
usize	Não	Índices de coleções

fn main() {
    let temperature = -5;      // i32 por padrão
    let count: u32 = 100;      // sem sinal, de forma explícita
    println!("{temperature} graus, a contagem é {count}");
}

Saída:

-5 graus, a contagem é 100

▶ Experimente você mesmo

Nota

“Com sinal” (signed) quer dizer que o número pode ser negativo; “sem sinal” (unsigned, os tipos com u) quer dizer só zero ou positivo. Se estiver em dúvida, i32 é um padrão seguro.

Números de ponto flutuante (decimais)

Para números com casa decimal, use os tipos de ponto flutuante (floats). São dois: f64 (o padrão, com precisão dupla) e f32.

fn main() {
    let pi = 3.14159;      // f64 por padrão
    let price: f32 = 9.99;
    println!("Pi é {pi}, o preço é {price}");
}

Saída:

Pi é 3.14159, o preço é 9.99

▶ Experimente você mesmo

Fique com o f64, a não ser que você precise especificamente do f32, que é menor. O f64 é mais preciso e, nos computadores modernos, é tão rápido quanto o f32.

Booleanos

Um booleano (bool) é o tipo mais simples de todos: ele é true (verdadeiro) ou false (falso). Você vai usar booleanos o tempo todo em if e em condições.

fn main() {
    let is_logged_in = true;
    let has_permission: bool = false;
    println!("logado: {is_logged_in}, permissão: {has_permission}");
}

Saída:

logado: true, permissão: false

▶ Experimente você mesmo

Caracteres

Um char guarda um único caractere, escrito entre aspas simples ' '. Um char em Rust pode ser qualquer valor escalar Unicode, o que cobre a maioria dos emojis. Alguns mais complexos (como bandeiras ou emojis formados por vários caracteres juntos) não cabem em um só.

fn main() {
    let letter = 'R';
    let symbol = '$';
    let crab = '🦀';
    println!("{letter} {symbol} {crab}");
}

Saída:

R $ 🦀

▶ Experimente você mesmo

Cuidado

Aspas simples ('R') são para um único char. Aspas duplas ("R") são para texto (strings). Confundir as duas é um erro comum no começo.

Strings (texto)

Texto em Rust é escrito entre aspas duplas. Existem dois tipos de string que você vai encontrar:

• &str: um string slice (fatia de string), normalmente um texto escrito direto no código (um “literal de string”).
• String: um texto que pertence à variável, pode crescer e pode ser alterado e montado aos poucos.

fn main() {
    let greeting = "Olá";              // &str
    let mut name = String::from("Ferris"); // String
    name.push_str(", o caranguejo");     // uma String pode crescer
    println!("{greeting}, {name}!");
}

Saída:

Olá, Ferris, o caranguejo!

▶ Experimente você mesmo

Não se preocupe ainda com a diferença entre &str e String: ela tem a ver com ownership (posse), que você vai aprender em breve. Por enquanto: use "..." para texto e recorra a String quando precisar montar ou modificar o texto.

Anotações de tipo

Na maioria das vezes, o Rust deduz o tipo. Mas às vezes ele precisa de uma dica, por exemplo quando você converte um texto em número (você vai ver isso na página de Conversão de tipos). Você adiciona o tipo com dois-pontos:

let x: i32 = 42;
let y: f64 = 3.5;
let active: bool = true;

Referência rápida

Tipo	O que guarda	Exemplo
i32	Número inteiro (padrão)	let n = 42;
u32	Número inteiro não negativo	let n: u32 = 42;
f64	Número decimal (padrão)	let pi = 3.14;
bool	true ou false	let ok = true;
char	Um caractere	let c = 'A';
&str	Texto literal	let s = "hi";
String	Texto que pode crescer	let s = String::from("hi");

Prática

1. O perfil de um jogador

Descreva um personagem de jogo com uma variável de cada tipo: um nome (&str), um nível (i32), uma porcentagem de vida (f64), uma flag is_online (bool) e uma letra de categoria (char). Imprima tudo em uma linha. Dica: um char usa aspas simples, texto usa aspas duplas.

Ver solução

fn main() {
    let name = "Ferris";   // &str
    let level = 7;         // i32
    let health = 82.5;     // f64
    let is_online = true;  // bool
    let rank = 'A';        // char

    println!("{name} | nível {level} | {health}% | online: {is_online} | categoria {rank}");
}

Saída:

Ferris | nível 7 | 82.5% | online: true | categoria A

▶ Experimente você mesmo

2. Monte uma frase

Comece com String::from("Rust"), depois adicione " é rápido" e " e seguro" a ela e imprima o resultado. Dica: a String precisa ser declarada com mut antes que o push_str possa alterá-la.

Ver solução

fn main() {
    let mut sentence = String::from("Rust");
    sentence.push_str(" é rápido");
    sentence.push_str(" e seguro");
    println!("{sentence}");
}

Saída:

Rust é rápido e seguro

▶ Experimente você mesmo

Resumo

• Todo valor tem um tipo, e normalmente o Rust o deduz.
• Números inteiros → i32 (padrão). Decimais → f64 (padrão).
• bool é true/false; char é um único caractere entre aspas simples.
• Texto vai entre aspas duplas: &str para literais, String para texto que pode crescer.

Teste o que aprendeu

Teste o que aprendeu

1. Qual é o tipo inteiro padrão em Rust quando você não especifica nenhum?

u32 i32 i64

2. Como o Rust diferencia um literal char de um literal de string?

Não há diferença, os dois são escritos do mesmo jeito Literais char usam aspas simples, literais de string usam aspas duplas Literais char usam aspas duplas, literais de string usam aspas simples

3. Qual tipo é um texto que pertence à variável, pode crescer e pode ser modificado?

&str String char

4. Qual é o tipo de ponto flutuante padrão em Rust?

f32 f64 f128

5. Qual tipo o Rust deduz para let greeting = "Olá";?

String &str char

Pontuação: 0 / 5

Para saber mais

• Data Types — The Rust Book (em inglês): todos os tipos escalares com tamanho e faixa de valores, além de overflow de inteiros e dos tipos compostos (tuplas e arrays).
• Primitives — Rust by Example (em inglês): exemplos que você pode rodar de cada tipo básico, com uma continuação sobre literais como 1_000 e 0x80.
• i32 — documentação da biblioteca padrão (em inglês): o menor e o maior valor (i32::MIN, i32::MAX) e os muitos métodos que os números têm.
• char — documentação da biblioteca padrão (em inglês): o que é um valor escalar Unicode, e por que um char sempre ocupa 4 bytes.
• String — documentação da biblioteca padrão (em inglês): como String se relaciona com &str, e todos os métodos para montar e alterar texto.