map, filter, collect
Transforme sequências
map, filter, collect é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 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.
Transformando sequências
Três métodos fazem a maior parte do trabalho em sequências de iteradores: map transforma cada item, filter mantém alguns itens e collect reúne os resultados em uma coleção.
Juntos, eles substituem muitos laços manuais por cadeias curtas e legíveis.
map: uma entrada, uma saída
map aplica um fechamento a cada item e produz o valor transformado. O número de itens permanece igual; apenas seus valores mudam.
Ele é preguiçoso, portanto o fechamento só é executado quando o iterador é consumido.
fn main() {
let nums = vec![1, 2, 3];
let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
println!("{:?}", doubled);
}map pode alterar o tipo
O tipo de saída de map não precisa corresponder ao de entrada. Aqui, transformamos números em strings.
Isso torna map perfeito para converter dados de uma forma para outra.
fn main() {
let nums = vec![1, 2, 3];
let labels: Vec<String> = nums.iter().map(|x| format!("n{}", x)).collect();
println!("{:?}", labels);
}filter: mantendo o que você quer
filter recebe um fechamento que retorna bool. Os itens para os quais ele retorna true são mantidos; os demais são descartados.
O fechamento recebe uma referência, portanto muitas vezes você remove a referência com * ou usa correspondência de padrões.
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);
}Encadeando map e filter
Você pode encadear adaptadores livremente. A ordem importa: cada item passa pela cadeia de cima para baixo.
Aqui, mantemos os números pares e depois elevamos ao quadrado os que sobraram.
fn main() {
let result: Vec<i32> = (1..=6)
.filter(|x| x % 2 == 0)
.map(|x| x * x)
.collect();
println!("{:?}", result);
}collect em um Vec
collect consome um iterador e cria uma coleção. Como há vários tipos de coleção possíveis, geralmente você anota o tipo de destino.
A sintaxe turbofish collect::<Vec<_>>() é uma alternativa a anotar a variável.
fn main() {
let squares = (1..=4).map(|x| x * x).collect::<Vec<i32>>();
println!("{:?}", squares);
}collect em uma String
collect não se limita a vetores. Um iterador de char pode ser reunido em uma String.
Rust usa o tipo de destino para decidir como montar os itens.
fn main() {
let shouted: String = "hello".chars().map(|c| c.to_ascii_uppercase()).collect();
println!("{}", shouted);
}collect em um HashMap
Um iterador de tuplas de chave e valor pode ser reunido em um HashMap. Combine os itens com zip ou crie tuplas em um map.
Essa é uma forma limpa de construir buscas a partir de duas sequências paralelas.
use std::collections::HashMap;
fn main() {
let map: HashMap<i32, i32> = (1..=3).map(|x| (x, x * x)).collect();
println!("{:?}", map.get(&2));
}Combinando os três
Uma sequência típica é lida como uma frase: pegue os itens, filtre-os, transforme-os e reúna-os.
Aqui, mantemos palavras com mais de três letras e as colocamos em maiúsculas.
fn main() {
let words = vec!["hi", "rust", "go", "code"];
let kept: Vec<String> = words
.into_iter()
.filter(|w| w.len() > 3)
.map(|w| w.to_uppercase())
.collect();
println!("{:?}", kept);
}filter_map: filtrando e transformando de uma vez
filter_map aplica um fechamento que retorna Option. Some(v) é mantido e desembrulhado; None é descartado.
Ele é especialmente útil na análise, quando algumas entradas podem ser inválidas.
fn main() {
let inputs = vec!["1", "two", "3"];
let nums: Vec<i32> = inputs
.into_iter()
.filter_map(|s| s.parse::<i32>().ok())
.collect();
println!("{:?}", nums);
}Por que esse padrão é melhor
Sequências de map/filter/collect são declarativas: dizem o que você quer, não como fazer o laço. Elas evitam erros de deslocamento de um e estados mutáveis intermediários.
E, graças à avaliação tardia, nenhum vetor temporário é criado entre as etapas.
Verificação rápida
Verifique o que você sabe sobre transformação de sequências.
Recapitulação
Agora você pode criar pipelines reais de iteradores:
maptransforma cada item e pode alterar seu tipofiltermantém os itens cujo predicado étruecollectreúne os resultados emVec,String,HashMape muito maisfilter_mapfiltra e mapeia em uma única etapa usandoOption
Perguntas Frequentes
A aula “map, filter, collect” é grátis?
Sim — o texto completo de “map, filter, collect” é 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 “map, filter, collect”?
Transforme sequências 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 2 de 4.
Quanto tempo leva a aula “map, filter, collect”?
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.
Todas as aulas deste curso
- A característica Iterator
- map, filter, collect
- Adaptadores e consumidores
- Iteradores personalizados