Folha de Consulta Rust
Última atualização
Hello World e estrutura
Um programa Rust começa em fn main; as instruções terminam em ponto e vírgula.
| Operação | Sintaxe |
|---|---|
| Ponto de entrada | fn main() { ... } |
| Exibir uma linha | println!("Hello, World!"); |
| Exibir com valores | println!("{} is {}", name, age); |
| Exibir forma de debug | println!("{:?}", value); |
| Comentário de linha | // comment |
| Usar um item de um módulo | use std::collections::HashMap; |
| Compilar e executar | cargo run |
| Compilar um binário de release | cargo build --release |
Variáveis e tipos (let / mut)
As vinculações são imutáveis por padrão; adicione mut para permitir reatribuição.
| Operação | Sintaxe |
|---|---|
| Vinculação imutável | let x = 5; |
| Vinculação mutável | let mut count = 0; |
| Tipo explícito | let age: u32 = 30; |
| Constante | const MAX: u32 = 100; |
| Shadowing | let x = x + 1; |
| Tipos inteiros | i32, u32, i64, usize |
| Outros escalares | f64, bool, char |
| Tupla | let pair: (i32, &str) = (1, "a"); |
| Conversão de tipo | let f = x as f64; |
Controle de fluxo
if é uma expressão, e Rust tem três formas de laço.
| Operação | Sintaxe |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If como expressão | let y = if x > 0 { 1 } else { -1 }; |
| Laço infinito | loop { ... } |
| Laço que retorna um valor | let v = loop { break 5; }; |
| Laço while | while x < 100 { ... } |
| For sobre um range | for i in 0..10 { ... } |
| For sobre uma coleção | for item in &items { ... } |
| Break / continue | break;, continue; |
Funções
A última expressão (sem ponto e vírgula) é o valor de retorno.
| Operação | Sintaxe |
|---|---|
| Função básica | fn add(a: i32, b: i32) -> i32 { a + b } |
| Retorno explícito | fn f() -> i32 { return 5; } |
| Sem valor de retorno | fn log(msg: &str) { ... } |
| Receber uma referência | fn len(s: &String) -> usize { s.len() } |
| Closure | let add = |a, b| a + b; |
| Closure com tipo | let sq = |x: i32| -> i32 { x * x }; |
| Função como argumento | fn apply(f: impl Fn(i32) -> i32) { ... } |
Ownership e borrowing
Cada valor tem um único dono; referências o tomam emprestado sem assumir a posse.
| Operação | Sintaxe |
|---|---|
| Move (transfere a posse) | let b = a; (a deixa de ser válido) |
| Clone (cópia profunda) | let b = a.clone(); |
| Empréstimo imutável | let r = &x; |
| Empréstimo mutável | let r = &mut x; |
| Empréstimo em uma função | fn read(s: &String) { ... } |
| Desreferenciar | *r |
| Regra de borrowing | Vários & OU um &mut por vez, não ambos |
| Slice (toma emprestado um intervalo) | let part = &arr[1..3]; |
Structs e enums
Structs agrupam dados relacionados; enums modelam um valor que é uma de várias variantes.
| Operação | Sintaxe |
|---|---|
| Definir uma struct | struct Point { x: i32, y: i32 } |
| Criar uma instância | let p = Point { x: 1, y: 2 }; |
| Acessar um campo | p.x |
| Tuple struct | struct Pair(i32, i32); |
| Método (bloco impl) | impl Point { fn dist(&self) -> f64 { ... } } |
| Função associada | impl Point { fn new() -> Self { ... } } |
| Definir um enum | enum Shape { Circle(f64), Rect(f64, f64) } |
| Enum com campos nomeados | enum Msg { Move { x: i32, y: i32 } } |
| Derivar traits | #[derive(Debug, Clone)] |
Correspondência de padrões (match)
match compara um valor com padrões e precisa ser exaustivo.
| Operação | Sintaxe |
|---|---|
| Corresponder em valores | match x { 1 => "one", _ => "other" } |
| Corresponder a um enum | match shape { Shape::Circle(r) => ... } |
| Corresponder a um range | match n { 1..=5 => ..., _ => ... } |
| Vincular com uma guarda | match x { n if n > 0 => ... } |
| Corresponder a uma tupla | match point { (0, y) => ..., (x, _) => ... } |
| if let (padrão único) | if let Some(v) = opt { ... } |
| while let | while let Some(v) = stack.pop() { ... } |
| Desestruturar uma struct | let Point { x, y } = p; |
Traits e generics
Traits definem comportamento compartilhado; generics fazem o código funcionar com muitos tipos.
| Operação | Sintaxe |
|---|---|
| Definir um trait | trait Area { fn area(&self) -> f64; } |
| Implementar um trait | impl Area for Circle { fn area(&self) -> f64 { ... } } |
| Método padrão | trait Greet { fn hi(&self) { ... } } |
| Função genérica | fn largest<T: PartialOrd>(list: &[T]) -> &T { ... } |
| Struct genérica | struct Wrapper<T> { value: T } |
| Limite de trait (where) | fn f<T>(x: T) where T: Display { ... } |
| Argumento impl Trait | fn print(item: impl Display) { ... } |
| Trait object | let shapes: Vec<Box<dyn Area>> = ...; |
Tratamento de erros (Result / Option)
Rust modela a ausência com Option e erros recuperáveis com Result.
| Operação | Sintaxe |
|---|---|
| Valor opcional | Option<T>: Some(v) ou None |
| Tipo Result | Result<T, E>: Ok(v) ou Err(e) |
| Retornar um Result | fn read() -> Result<String, Error> { ... } |
| Propagar com ? | let data = read()?; |
| Unwrap (causa panic em None/Err) | opt.unwrap() |
| Valor padrão | opt.unwrap_or(0) |
| Mapear um valor | opt.map(|v| v + 1) |
| Tratar ambos os braços | match res { Ok(v) => ..., Err(e) => ... } |
| Converter Option em Result | opt.ok_or("missing")? |
Coleções comuns (Vec / HashMap)
Vec é um array que cresce; HashMap é um armazenamento chave-valor.
| Operação | Sintaxe |
|---|---|
| Criar um vetor | let mut v: Vec<i32> = Vec::new(); |
| Literal de vetor | let v = vec![1, 2, 3]; |
| Push / pop | v.push(4);, v.pop(); |
| Acesso por índice | v[0] |
| Acesso seguro | v.get(0) retorna Option<&T> |
| Iterar | for x in &v { ... } |
| Comprimento | v.len() |
| Criar um map | let mut m: HashMap<String, i32> = HashMap::new(); |
| Inserir / obter | m.insert(k, v);, m.get(&k) |
| API Entry | *m.entry(k).or_insert(0) += 1; |
A sintaxe de Rust que você mais usa, em uma única página. Esta folha de consulta Rust é uma referência rápida para o núcleo da linguagem - variáveis e mutabilidade, ownership e borrowing, structs e enums, correspondência de padrões, traits e generics, e os tipos Result e Option por trás do tratamento de erros de Rust.
Tudo aqui é Rust padrão que compila em uma toolchain stable recente. Copie o que precisar ou teste cada trecho ao vivo no playground de Rust - sem necessidade de instalar o cargo.
Perguntas frequentes sobre a folha de consulta Rust
Esta folha de consulta Rust é gratuita?
Sim. Esta folha de consulta Rust é totalmente gratuita, sem necessidade de cadastro. Salve nos favoritos e volte sempre que precisar consultar um padrão de match, um limite de trait ou um método de coleção.
O que são ownership e borrowing em Rust?
Ownership é o modelo de memória de Rust: cada valor tem exatamente um dono, e o valor é liberado quando esse dono sai de escopo. O borrowing permite acessar um valor sem assumir a posse usando uma referência -
&x para um empréstimo imutável ou &mut x para um mutável. O compilador impõe uma regra: você pode ter vários empréstimos imutáveis ou exatamente um empréstimo mutável por vez, o que previne disputas de dados em tempo de compilação.Qual é a diferença entre Result e Option em Rust?
Option<T> representa um valor que pode estar ausente - é Some(v) ou None, e você o usa quando não há erro a relatar, apenas um valor faltando. Result<T, E> representa uma operação que pode falhar - é Ok(v) ou Err(e), carregando um valor de erro quando algo dá errado. Use Option para "talvez exista" e Result para "isto pode falhar"; o operador ? propaga ambos.Posso praticar Rust online?
Sim. Abra o playground de Rust para compilar e executar qualquer trecho desta folha de consulta no seu navegador - sem cargo nem toolchain para instalar. Quando quiser estrutura, o curso interativo e gratuito de Rust da Coddy leva você passo a passo de variáveis e ownership a traits e tratamento de erros.
Esta folha de consulta é boa para iniciantes?
Sim. Ela está organizada dos tópicos mais comuns (variáveis, controle de fluxo, funções) até os avançados (traits, generics, tratamento de erros), de modo que você pode usar as seções de cima já no primeiro dia e ir avançando para ownership e o resto.
Recursos relacionados
Mais folhas de consulta
