Lição 5 de 18 · 20 min
Tipos de dados
Inteiros, números com vírgula, bool, char, tuplas e arrays. Veja quando o Rust deduz o tipo, quando anotar e como converter com as e parse.
Ao terminar, você vai saber:
- Escolher o tipo inteiro adequado (i32, u8, usize e outros)
- Usar f64, bool e char
- Agrupar valores em tuplas e arrays
- Anotar o tipo quando o compilador não consegue deduzir
- Converter valores com as e com parse
Todo valor no Rust tem um tipo, e o compilador precisa saber qual é antes de rodar o programa. Na maioria das vezes ele descobre sozinho, olhando o valor. Isso se chama inferência de tipo. Quando ele não consegue, você escreve o tipo depois de dois-pontos:
fn main() {
let idade = 30; // o compilador deduz: i32
let altura: f64 = 1.75; // tipo escrito por você
let ativo: bool = true;
println!("{idade} {altura} {ativo}");
}
Vamos conhecer os tipos básicos, os chamados tipos escalares (um valor só) e depois os compostos (vários valores juntos).
Inteiros
Números sem casa decimal. O nome do tipo diz duas coisas: se aceita negativo e quantos bits ocupa.
i= com sinal (aceita negativo):i8,i16,i32,i64,i128u= sem sinal (só zero e positivos):u8,u16,u32,u64,u128
Quanto mais bits, maior o número que cabe. Alguns exemplos:
u8: de 0 a 255. Bom para um componente de cor ou a idade de uma pessoa.i32: de cerca de menos 2 bilhões a mais 2 bilhões. É o padrão quando você não diz nada.u64: até um número enorme, com 20 dígitos. Serve para contar visualizações de um vídeo viral.
Existem ainda isize e usize, cujo tamanho depende do computador (64 bits na maioria das máquinas de hoje). O usize é o tipo usado para posições e tamanhos de listas. Você vai vê-lo bastante.
fn main() {
let temperatura: i8 = -5;
let nota: u8 = 9;
let habitantes_sp: u32 = 11_450_000;
let posicao: usize = 2;
println!("{temperatura} {nota} {habitantes_sp} {posicao}");
}
E se o número não couber? O compilador avisa:
fn main() {
let idade: u8 = 300;
println!("{idade}");
}
error: literal out of range for `u8`
|
2 | let idade: u8 = 300;
| ^^^
|
= note: the literal `300` does not fit into the type `u8` whose range is `0..=255`
O valor 300 não cabe num u8, que vai até 255.
Números com vírgula: f32 e f64
Para números com casas decimais, use f64 (padrão) ou f32. Atenção: no código, a casa decimal é separada por ponto, como em inglês.
fn main() {
let preco_cafe = 6.5; // f64
let desconto: f32 = 0.1;
let total = preco_cafe * 3.0;
println!("Três cafés: R$ {total:.2}");
println!("Desconto: {desconto}");
}
Um detalhe importante: o Rust não mistura tipos sozinho. preco_cafe * 3 não compila, porque 3 é inteiro e preco_cafe é f64. Por isso escrevemos 3.0.
Operações
As de sempre: +, -, *, / e % (resto da divisão). Divisão entre inteiros descarta a parte decimal:
fn main() {
let pizza = 8;
let pessoas = 3;
println!("Cada um come {} pedaços", pizza / pessoas); // 2
println!("Sobram {} pedaços", pizza % pessoas); // 2
println!("Divisão exata: {}", 8.0 / 3.0); // 2.6666666666666665
}
Booleano: bool
Só dois valores possíveis: true ou false. Aparece muito em comparações:
fn main() {
let idade = 17;
let pode_votar = idade >= 16;
let pode_dirigir = idade >= 18;
println!("Vota? {pode_votar}. Dirige? {pode_dirigir}.");
}
Caractere: char
Um char guarda um caractere, escrito entre aspas simples. Ele aceita qualquer caractere Unicode: letras com acento, ç, letras de outros alfabetos.
fn main() {
let letra = 'ç';
let nota = 'A';
let simbolo = '$';
println!("{letra} {nota} {simbolo}");
}
Aspas simples são para char; aspas duplas são para texto. 'a' é um caractere, "a" é um texto com um caractere. Texto é assunto do módulo de ownership, onde você vai conhecer String e &str.
Tuplas
Uma tupla junta valores de tipos diferentes num pacote só, com tamanho fixo. Pense numa linha de planilha: nome, idade e cidade.
fn main() {
let pessoa: (&str, u8, &str) = ("Rafaela", 27, "Curitiba");
// Acessando pela posição, começando do zero
println!("Nome: {}", pessoa.0);
println!("Idade: {}", pessoa.1);
// Desmontando em variáveis separadas
let (nome, idade, cidade) = pessoa;
println!("{nome}, {idade} anos, mora em {cidade}.");
}
A forma let (nome, idade, cidade) = pessoa; se chama desestruturação. É bem prática.
Arrays
Um array guarda vários valores do mesmo tipo, com tamanho fixo. O tipo é escrito [tipo; tamanho]:
fn main() {
let meses: [&str; 3] = ["janeiro", "fevereiro", "março"];
let notas = [8, 7, 10, 9];
let zeros = [0; 5]; // cinco zeros: [0, 0, 0, 0, 0]
println!("Primeiro mês: {}", meses[0]);
println!("Quantidade de notas: {}", notas.len());
println!("{zeros:?}");
}
Os índices começam em zero. E se você pedir uma posição que não existe? Se o índice for conhecido na compilação, o compilador já barra. Se só for descoberto com o programa rodando, o Rust interrompe o programa com um panic em vez de ler uma memória que não é dele. Em C, esse erro poderia ler lixo silenciosamente.
Para listas que crescem e diminuem, existe o Vec, que você vai ver mais adiante.
Convertendo entre números: as
O Rust nunca converte um tipo numérico em outro por conta própria. Você pede, com as:
fn main() {
let itens: i32 = 7;
let preco: f64 = 2.5;
let total = itens as f64 * preco;
println!("Total: {total}");
let nota_final = 8.9_f64;
let arredondada = nota_final as i32; // corta a parte decimal
println!("{arredondada}"); // 8
}
Cuidado: as corta sem perguntar. Converter 8.9 para inteiro dá 8, não 9. Se quiser arredondar, use nota_final.round() as i32.
Convertendo texto em número: parse
Quando o usuário digita um número, ele chega como texto. Para converter, use parse. Como o compilador não tem como saber qual número você quer, é preciso anotar o tipo:
fn main() {
let digitado = "42";
let numero: i32 = digitado.parse().unwrap();
println!("O dobro é {}", numero * 2);
}
O parse pode falhar (e se a pessoa digitar “banana”?). Por isso ele devolve um Result, que é ok ou erro. O .unwrap() diz: “se der certo, me dá o valor; se der errado, encerra o programa”. Serve para começar. No módulo de dados você aprende a tratar o erro com calma.
Sem a anotação, o compilador reclama:
fn main() {
let numero = "42".parse().unwrap();
println!("{numero}");
}
error[E0284]: type annotations needed
|
2 | let numero = "42".parse().unwrap();
| ^^^^^^ ----- type must be known at this point
|
help: consider giving `numero` an explicit type
|
2 | let numero: /* Type */ = "42".parse().unwrap();
| ++++++++++++
Ele pede para você dizer o tipo. Dá para escrever let numero: i32 = ... ou "42".parse::<i32>(). As duas formas funcionam.
Resumo
- O Rust deduz o tipo quase sempre; quando não consegue, você anota com
: tipo. - Inteiros:
iaceita negativo,unão;i32é o padrão eusizeaparece em tamanhos e posições. f64para decimais,boolpara verdadeiro ou falso,charpara um caractere.- Tuplas misturam tipos; arrays têm tipo único e tamanho fixo.
asconverte números;parseconverte texto em número.
Desafio
Você recebeu como texto o valor de uma conta de restaurante ("187.60") e o número de pessoas ("4"). Converta os dois com parse, calcule quanto cada um paga com 10% de serviço e imprima com duas casas decimais. Guarde o resultado numa tupla (pessoas, valor_por_pessoa) e imprima a tupla com {:?}.
Ver uma resposta
fn main() {
let conta_texto = "187.60";
let pessoas_texto = "4";
let conta: f64 = conta_texto.parse().unwrap();
let pessoas: u32 = pessoas_texto.parse().unwrap();
let com_servico = conta * 1.10;
let por_pessoa = com_servico / pessoas as f64;
println!("Cada um paga R$ {por_pessoa:.2}");
let resultado = (pessoas, por_pessoa);
println!("{resultado:?}");
}