Guia rápido de Rust

Uma página de consulta rápida para o que você vai querer conferir sem reler uma lição inteira. Cada seção tem um link para a página que explica o assunto direito.

Palavras-chave

Palavra-chave	Significado
`let`	Declara uma variável (Variáveis)
`mut`	Torna uma variável ou referência mutável (Variáveis)
`const`	Declara uma constante (Variáveis)
`fn`	Declara uma função (Funções)
`struct`	Declara um struct (estrutura) (Structs)
`enum`	Declara um enum (enumeração) (Enums)
`impl`	Adiciona métodos a um tipo (Structs, Traits)
`trait`	Declara um trait (Traits)
`match`	Faz pattern matching (casamento de padrões) em um valor (Match)
`if let` / `while let`	Compara com um único padrão (If Let / While Let)
`loop` / `while` / `for`	Os três tipos de loop (Loops, While, For)
`break` / `continue`	Controlam um loop (Break/Continue)
`mod`	Declara um módulo (Módulos)
`pub`	Torna um item público fora do seu módulo (Módulos)
`use`	Traz um caminho para o escopo (Módulos)
`unsafe`	Libera ponteiros brutos e outras operações que você mesmo garante (Unsafe)
`move`	Obriga uma closure a assumir o ownership (posse) dos valores capturados (Concorrência)
`&` / `&mut`	Pega um valor emprestado / emprestado de forma mutável (Borrowing)

Métodos comuns de String

Método	O que faz
`.len()`	Tamanho em bytes
`.trim()`	Remove espaços em branco do início e do fim
`.to_uppercase()` / `.to_lowercase()`	Converte para maiúsculas / minúsculas
`.contains(pat)`	Verifica se um trecho/padrão aparece no texto
`.replace(from, to)`	Substitui todas as ocorrências
`.push_str(s)`	Acrescenta um `&str` no fim
`.push(c)`	Acrescenta um único `char` no fim
`.chars()`	Percorre o texto caractere por caractere
`.split(pat)`	Divide em um iterador de pedaços
`.parse::<T>()`	Converte texto em outro tipo (retorna `Result`)

Veja a página Strings para detalhes e exemplos.

Métodos comuns de Vec

Método	O que faz
`.push(x)`	Adiciona no fim
`.pop()`	Remove e retorna o último item (`Option`)
`.remove(i)`	Remove o item no índice `i`
`.len()`	Quantidade de itens
`.is_empty()`	Verifica se o vetor está vazio
`.get(i)`	Acesso seguro por índice (`Option`, não causa panic)
`.iter()`	Percorre por referência
`.contains(&x)`	Verifica se um valor está presente
`.sort()`	Ordena no próprio vetor
`.sort_by_key(\|x\| ...)`	Ordena por um campo ou por uma chave calculada
`.dedup()`	Remove duplicatas seguidas (ordene antes)

Veja as páginas Vetores, Ordenação e busca e Iteradores para detalhes e exemplos.

Qual coleção devo usar?

Tipo	Use quando você precisa de…
`Vec<T>`	Uma lista ordenada que pode crescer
`HashMap<K, V>`	Buscar rápido um valor pela chave
`HashSet<T>`	Itens únicos e verificações rápidas de “isso está aqui?”
`BTreeMap<K, V>`	Pares chave-valor mantidos em ordem de chave
`VecDeque<T>`	Uma fila — colocar e tirar itens nas duas pontas

Veja as páginas HashMap e HashSet e BTreeMap para detalhes e exemplos.

Option e Result

Método	Funciona em	O que faz
`.unwrap()`	Ambos	Pega o valor; causa panic se for `None`/`Err`
`.expect("msg")`	Ambos	Igual a `.unwrap()`, com uma mensagem de panic personalizada
`.unwrap_or(default)`	Ambos	Pega o valor, ou um valor alternativo
`.is_some()` / `.is_none()`	`Option`	Verifica qual é a variante
`.is_ok()` / `.is_err()`	`Result`	Verifica qual é a variante
`?`	Ambos	Retorna antes da hora em caso de `None`/`Err`

Veja as páginas Option e Result para detalhes e exemplos.

Especificadores de formato (println!, format!)

Especificador	O que mostra
`{}`	Exibição normal (precisa do trait `Display`)
`{:?}`	Formato de depuração (`Debug`)
`{:#?}`	Formato de depuração bem formatado, em várias linhas
`{:.2}`	2 casas decimais
`{:5}`	Preenche até a largura de 5
`{name}`	Insere direto uma variável chamada `name`

Veja a página Saída em Rust para detalhes e exemplos.

Comandos do Cargo

Comando	O que faz
`cargo new name`	Cria um projeto novo
`cargo run`	Compila e executa
`cargo check`	Procura erros rapidamente, sem gerar o executável
`cargo test`	Roda os seus testes
`cargo add crate`	Adiciona uma dependência
`cargo fmt`	Formata o seu código
`cargo clippy`	Analisa o seu código em busca de erros comuns
`cargo build --release`	Gera um executável otimizado

Veja a página Cargo e crates para detalhes e exemplos.

Sintaxe de intervalos (ranges)

Sintaxe	Significado
`1..5`	De 1 até 5, sem incluir o 5
`1..=5`	De 1 até 5, incluindo o 5
`..3`	Do início até 3, sem incluir o 3
`2..`	Do 2 até o fim
`..`	Tudo

Veja as páginas For e Slices para detalhes e exemplos.

Crates populares

Você precisa de…	Crate	Lição
JSON (e outros formatos)	`serde` + `serde_json`	JSON com Serde
Código assíncrono, timers, rede	`tokio`	Async/Await
Uma interface de linha de comando	`clap`	CLI com clap
Tratamento de erros sem complicação	`anyhow`, `thiserror`	anyhow e thiserror
Números aleatórios	`rand`	Números aleatórios
Expressões regulares	`regex`	Expressões regulares
Datas e horas	`chrono`	Datas e horas
Logging	`log` + `env_logger`, `tracing`	Logging
Um servidor web	`axum`	API web com Axum

Adicione qualquer um deles com cargo add <crate>. Veja Cargo e crates para saber como escolher um bom crate.

Para saber mais

Rust Language Cheat Sheet — cheats.rs: uma referência de uma página muito mais completa, da sintaxe ao layout de memória (em inglês).
Apêndice B: Operadores e símbolos — The Rust Book: todos os operadores e símbolos do Rust e o que significam (em inglês).
std::fmt — documentação da biblioteca padrão: toda a sintaxe de formatação de println! e format!: largura, preenchimento, precisão e mais (em inglês).
Comandos do Cargo — The Cargo Book: cada comando do cargo com suas opções (em inglês).