Learn Rust Coding · Aula

A característica Iterator

next e avaliação preguiçosa

A característica Iterator é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 1 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 iterador?

Um iterador é qualquer coisa que produz uma sequência de valores, um de cada vez. Em Rust, iteradores são a forma idiomática de processar coleções como vetores, intervalos e fatias.

Todo o conceito se baseia em uma única característica: Iterator. Assim que um tipo a implementa, você obtém dezenas de métodos úteis gratuitamente.

A característica Iterator

A característica Iterator tem um método obrigatório, next, e um tipo associado, Item:

type Item — o tipo de valor produzido
fn next(&mut self) -> Option<Self::Item> — retorna o próximo valor

Ela retorna Some(value) enquanto houver valores; depois retorna None ao terminar.

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

next retorna Option

Cada chamada a next avança o iterador e fornece um Option. Some envolve um valor real; None sinaliza o fim.

Observe que next recebe &mut self — chamá-lo altera o estado interno, fazendo com que a próxima chamada retorne um valor diferente.

fn main() {
    let mut it = (1..4).into_iter();
    while let Some(n) = it.next() {
        println!("got {}", n);
    }
    println!("done");
}

Iteradores são preguiçosos

Criar um iterador, por si só, não faz nada. Nenhum valor é calculado até que algo os solicite. Isso é chamado de avaliação tardia.

No próximo exemplo, o fechamento map nunca é executado, porque nunca consumimos o iterador.

fn main() {
    let nums = vec![1, 2, 3];
    let _doubled = nums.iter().map(|x| {
        println!("mapping {}", x);
        x * 2
    });
    println!("nothing printed above this line");
}

Consumir inicia o trabalho

Para fazer um iterador preguiçoso realmente executar, você precisa consumi-lo. Um laço for é o consumidor mais simples: ele chama next repetidamente até obter None.

Agora o mesmo fechamento map é executado para cada elemento.

fn main() {
    let nums = vec![1, 2, 3];
    for x in nums.iter().map(|x| x * 2) {
        println!("value {}", x);
    }
}

Três formas de iterar

As coleções oferecem três métodos que produzem iteradores:

iter() — produz &T (faz empréstimos)
iter_mut() — produz &mut T (faz empréstimos mutáveis)
into_iter() — produz T (assume a propriedade)

fn main() {
    let mut v = vec![1, 2, 3];
    for x in v.iter_mut() {
        *x += 10;
    }
    println!("{:?}", v);
}

Laços for usam into_iter

Quando você escreve for x in collection diretamente, Rust chama into_iter(), que consome a coleção.

Depois desse laço, você não pode usar v novamente, pois ele foi movido para o iterador.

fn main() {
    let v = vec![String::from("a"), String::from("b")];
    for s in v {
        println!("{}", s);
    }
    // v is no longer usable here
}

Intervalos são iteradores

Um intervalo como 0..5 é um iterador que produz 0, 1, 2, 3, 4. O fim é exclusivo. Use 0..=5 para um intervalo inclusivo.

Intervalos são ótimos para laços de contagem sem acompanhar índices manualmente.

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

count: um consumidor simples

count consome todo o iterador e retorna quantos itens ele produziu. Ele é um dos muitos adaptadores consumidores.

Como ele consome o iterador, você não pode reutilizá-lo depois.

fn main() {
    let total = (1..=100).count();
    println!("there are {} numbers", total);
}

sum: reduzindo a um valor

sum soma todos os itens e retorna um único valor. Muitas vezes você anota o tipo de destino para que Rust saiba o que produzir.

Isso é mais conciso e claro do que um laço manual com acumulador.

fn main() {
    let total: i32 = (1..=5).sum();
    println!("sum is {}", total);
}

Por que os iteradores são importantes

Iteradores oferecem componibilidade: encadeie pequenas operações em sequências claras. Eles também têm custo zero — o compilador os otimiza para serem tão rápidos quanto laços escritos manualmente.

Dominar next, a avaliação tardia e o consumo é a base de tudo o que vem a seguir.

Verificação rápida

Teste sua compreensão da característica Iterator.

Recapitulação

Você aprendeu o essencial sobre os iteradores de Rust:

A característica Iterator precisa apenas de next e de um tipo Item
next retorna Some(value) e depois None
Iteradores são preguiçosos — não fazem nada até serem consumidos
iter, iter_mut e into_iter controlam empréstimos e propriedade
Consumidores como for, count e sum executam o trabalho

Perguntas Frequentes

A aula “A característica Iterator” é grátis?

Sim — o texto completo de “A característica Iterator” é 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 “A característica Iterator”?

next e avaliação preguiçosa 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 1 de 4.

Quanto tempo leva a aula “A característica Iterator”?

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

← Voltar para Learn Rust Coding