Iterators

Method สามแบบของ Iterator

ทุก Collection มีสามวิธีในการสร้าง Iterator:

Method	ให้ผลเป็น	Ownership
`.iter()`	`&T`	ยืม Collection
`.iter_mut()`	`&mut T`	ยืม Collection แบบ Mutable
`.into_iter()`	`T`	Consume (Move) Collection

let v = vec![1, 2, 3];

for x in v.iter() { }        // v ยังใช้ได้หลังจากนั้น
for x in v.into_iter() { }   // v ถูก Move — ใช้ v ไม่ได้อีก

Adaptor — การแปลงแบบ Lazy

Adaptor แปลง Iterator หนึ่งเป็น Iterator อื่น และ ไม่ทำงานจริง จนกว่า Consumer จะขับเคลื่อน

`map`

แปลง Element แต่ละตัว:

let doubled: Vec<i32> = vec![1, 2, 3].iter().map(|&x| x * 2).collect();
// [2, 4, 6]

`filter`

เก็บ Element ที่ตรงกับ Predicate สังเกต: .iter() บน Vec<i32> ให้ &&i32 ภายใน filter — ใช้ |&&x| เพื่อ Destructure:

let evens: Vec<i32> = vec![1, 2, 3, 4].iter().filter(|&&x| x % 2 == 0).map(|&x| x).collect();
// [2, 4]

`enumerate`

จับคู่แต่ละ Element กับ Index (usize, &T):

for (i, val) in vec!["a", "b", "c"].iter().enumerate() {
    println!("[{}] {}", i, val);
}

`zip`

รวม Iterator สองตัวเป็นคู่ (A, B) ทีละ Element โดยหยุดที่ตัวที่สั้นกว่า:

let names = vec!["Alice", "Bob"];
let scores = vec![100, 85];
for (name, score) in names.iter().zip(scores.iter()) {
    println!("{}: {}", name, score);
}

Consumer — ขับเคลื่อน Chain

Consumer ดึงค่าผ่าน Chain ของ Adaptor และสร้างผลลัพธ์สุดท้าย

Consumer	ผลลัพธ์
`.collect::<Vec<T>>()`	สร้าง Collection
`.sum::<i32>()`	รวมค่าตัวเลข
`.fold(init, f)`	ลดเหลือค่าเดียวด้วย Accumulator
`.count()`	นับ Element
`.any(pred)` / `.all(pred)`	Test Boolean แบบ Short-circuit

let nums = vec![1, 2, 3, 4, 5];
let total: i32 = nums.iter().sum();            // 15
let product: i32 = nums.iter().fold(1, |acc, &x| acc * x);  // 120

Open in Rust Playground

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];

    // filter + map + collect
    let evens_doubled: Vec<i32> = numbers
        .iter()
        .filter(|&&x| x % 2 == 0)
        .map(|&x| x * 2)
        .collect();
    println!("evens doubled: {:?}", evens_doubled);

    // enumerate
    for (i, val) in numbers.iter().enumerate() {
        println!("[{}] = {}", i, val);
    }

    // zip two iterators
    let letters = vec!["a", "b", "c"];
    for (n, l) in numbers.iter().take(3).zip(letters.iter()) {
        println!("{} -> {}", n, l);
    }

    // consumers: sum and fold
    let total: i32 = numbers.iter().sum();
    let product: i32 = numbers.iter().fold(1, |acc, &x| acc * x);
    println!("sum={} product={}", total, product);
}