Learn Rust Coding · Aula

Iteração sobre coleções

for e iteradores

Iteração sobre coleções é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 4 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.

Laços com for

O laço for é a maneira mais simples de visitar cada elemento de uma coleção.

fn main() {
    let nums = vec![1, 2, 3];
    for n in &nums {
        println!("{}", n);
    }
}

Percorrendo intervalos

Os intervalos produzem uma sequência que pode ser percorrida. 1..5 é exclusivo; 1..=5 inclui o final.

fn main() {
    for i in 1..=3 {
        println!("i = {}", i);
    }
}

O método iter

Chamar .iter() cria um iterador que fornece referências a cada elemento. Os iteradores são preguiçosos até serem consumidos.

fn main() {
    let v = vec![10, 20, 30];
    let mut it = v.iter();
    println!("{:?}", it.next());
    println!("{:?}", it.next());
}

Três maneiras de iterar

Os vetores oferecem três estilos de iteração:

iter() — fornece &T (empréstimo).
iter_mut() — fornece &mut T (empréstimo mutável).
into_iter() — fornece T (assume a propriedade).

fn main() {
    let v = vec![1, 2, 3];
    for x in v.into_iter() {
        println!("owned {}", x);
    }
}

Transformando com map

map aplica uma closure a cada elemento, produzindo um novo iterador. Use collect para reunir os resultados.

fn main() {
    let v = vec![1, 2, 3];
    let squared: Vec<i32> = v.iter().map(|x| x * x).collect();
    println!("{:?}", squared);
}

Selecionando com filter

filter mantém somente os elementos para os quais a closure retorna true.

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let odds: Vec<i32> = v.into_iter().filter(|x| x % 2 == 1).collect();
    println!("{:?}", odds);
}

Agregando com sum e count

Os métodos consumidores reduzem um iterador a um único valor, como sum, count, max e min.

fn main() {
    let v = vec![4, 8, 15, 16];
    let total: i32 = v.iter().sum();
    let how_many = v.iter().count();
    println!("sum {} count {}", total, how_many);
}

Encadeando adaptadores

Os métodos de iterador podem ser encadeados em um fluxo claro de processamento. Cada etapa transforma o fluxo antes do consumidor final.

fn main() {
    let v = vec![1, 2, 3, 4, 5, 6];
    let result: i32 = v.iter()
        .filter(|x| *x % 2 == 0)
        .map(|x| x * 10)
        .sum();
    println!("{}", result);
}

enumerate para obter índices

enumerate associa cada elemento ao seu índice, produzindo tuplas (index, value).

fn main() {
    let letters = vec!['a', 'b', 'c'];
    for (i, ch) in letters.iter().enumerate() {
        println!("{}: {}", i, ch);
    }
}

Percorrendo um HashMap

Os iteradores também funcionam em mapas. O laço fornece tuplas de chave e valor.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("a", 1);
    m.insert("b", 2);
    for (k, v) in &m {
        println!("{} -> {}", k, v);
    }
}

for versus métodos de iterador

Um laço for simples é ótimo para efeitos colaterais, como imprimir. Os adaptadores de iterador (map, filter, sum) são ideais para transformar dados em um novo valor.

fn main() {
    let v = vec![2, 4, 6];
    let doubled: Vec<i32> = v.iter().map(|x| x * 2).collect();
    for x in &doubled {
        println!("{}", x);
    }
}

Verificação rápida

Recorde a função dos adaptadores de iterador.

Recapitulação

Percorrendo coleções em Rust:

for x in &collection para laços simples.
iter, iter_mut, into_iter controlam os empréstimos.
Adaptadores: map, filter, enumerate.
Consumidores: collect, sum, count, max.

fn main() {
    let prices = vec![10, 25, 40];
    let with_tax: Vec<i32> = prices.iter().map(|p| p + p / 5).collect();
    let total: i32 = with_tax.iter().sum();
    println!("{:?} total {}", with_tax, total);
}

Perguntas Frequentes

A aula “Iteração sobre coleções” é grátis?

Sim — o texto completo de “Iteração sobre coleções” é 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 “Iteração sobre coleções”?

for e iteradores 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 4 de 4.

Quanto tempo leva a aula “Iteração sobre coleções”?

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

Vetores
Strings e &str
HashMaps
Iteração sobre coleções

← Voltar para Learn Rust Coding