Closures
Funções anônimas
Closures é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.
O que é um fechamento?
Um fechamento é uma função anônima que você pode armazenar em uma variável e chamar posteriormente. Ele é escrito com barras verticais ao redor dos parâmetros.
fn main() {
let add_one = |x| x + 1;
println!("{}", add_one(4));
}Sintaxe de fechamentos
Os parâmetros ficam entre |...|, seguidos pelo corpo. Com uma única expressão, não são necessárias chaves.
|x| x + 1— um parâmetro.|a, b| a + b— dois parâmetros.
fn main() {
let multiply = |a, b| a * b;
println!("{}", multiply(3, 5));
}Fechamentos em várias linhas
Para mais de uma instrução, coloque o corpo entre chaves, assim como em uma função.
fn main() {
let describe = |n: i32| {
let doubled = n * 2;
println!("{} doubled is {}", n, doubled);
};
describe(7);
}Capturando o ambiente
Ao contrário de uma função comum, um fechamento pode capturar variáveis do escopo ao redor e usá-las internamente.
fn main() {
let factor = 10;
let scale = |x| x * factor;
println!("{}", scale(5));
}Inferência de tipos em fechamentos
Normalmente, os fechamentos inferem os tipos dos parâmetros e do retorno a partir de como são usados, portanto as anotações são opcionais.
Você pode adicionar tipos para maior clareza quando necessário.
fn main() {
let greet = |name: &str| -> String {
format!("Hello, {}!", name)
};
println!("{}", greet("Rust"));
}Fechamentos como argumentos
Muitos métodos padrão aceitam um fechamento. Por exemplo, map aplica um fechamento a cada item.
fn main() {
let nums = vec![1, 2, 3];
let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
println!("{:?}", doubled);
}Filtrando com fechamentos
O método filter mantém apenas os itens para os quais o fechamento retorna true.
fn main() {
let nums = vec![1, 2, 3, 4, 5, 6];
let evens: Vec<i32> = nums.into_iter().filter(|x| x % 2 == 0).collect();
println!("{:?}", evens);
}Armazenando fechamentos
Os fechamentos têm tipos anônimos exclusivos, mas você pode armazená-los em uma variável e reutilizá-los.
fn main() {
let is_even = |n: i32| n % 2 == 0;
println!("{} {}", is_even(4), is_even(7));
}Fechamentos versus funções
Diferenças:
- As funções não podem capturar variáveis ao redor; os fechamentos podem.
- Os fechamentos são anônimos e geralmente curtos.
- Os tipos dos fechamentos normalmente são inferidos.
fn main() {
let base = 100;
let bonus = |earned: i32| earned + base;
println!("{}", bonus(25));
}Retornando valores calculados
Combine fechamentos com iteradores para calcular resultados em um encadeamento limpo e expressivo.
fn main() {
let nums = vec![10, 20, 30];
let total: i32 = nums.iter().map(|x| x + 1).sum();
println!("total {}", total);
}Fechamentos capturam por referência
Por padrão, um fechamento toma emprestadas as variáveis capturadas. Você ainda pode lê-las externamente depois, quando elas tiverem sido apenas emprestadas.
fn main() {
let name = String::from("Ada");
let printer = || println!("Name: {}", name);
printer();
println!("still usable: {}", name);
}Verificação rápida
Recorde uma capacidade importante dos fechamentos.
Recapitulação
Fechamentos no Rust:
- Funções anônimas escritas como
|params| body. - Podem capturar variáveis do ambiente.
- Os tipos normalmente são inferidos.
- São amplamente usados com métodos de iteradores, como
mapefilter.
fn main() {
let tax = 0.2;
let with_tax = |price: f64| price * (1.0 + tax);
println!("{}", with_tax(50.0));
}Perguntas Frequentes
A aula “Closures” é grátis?
Sim — o texto completo de “Closures” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.
O que vou aprender em “Closures”?
Funções anônimas Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Learn Rust Coding?
Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Closures”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Learn Rust Coding?
Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.