next 方法 ​

核心概念 ​

next() 是 Iterator trait 中唯一必须实现的方法,签名为 fn next(&mut self) -> Option<Self::Item>。每次调用 next() 会尝试产出迭代器中的下一个元素:返回 Some(值) 表示成功产出一个元素,返回 None 表示迭代结束。next() 接受 &mut self,意味着每次调用都会修改迭代器的内部状态(推进位置)。所有迭代器的高级方法(map、filter、collect、for 循环等)在底层都是通过反复调用 next() 来工作的。

rust
fn main() {
    let fruits = vec!["苹果", "香蕉", "橘子"];
    let mut iter = fruits.iter();

    // 手动调用 next()
    let first = iter.next();   // Some(&"苹果")
    let second = iter.next();  // Some(&"香蕉")
    let third = iter.next();   // Some(&"橘子")
    let end = iter.next();     // None

    println!("第一个: {:?}", first);
    println!("第二个: {:?}", second);
    println!("第三个: {:?}", third);
    println!("结束: {:?}", end);

    // 继续调用 next() 仍然返回 None
    println!("再次: {:?}", iter.next());  // None
}

next() 与 for 循环的关系 ​

rust
fn main() {
    let data = vec![10, 20, 30];

    // for 循环的本质:
    // 1. 调用 into_iter() 获取迭代器
    // 2. 反复调用 next()
    // 3. 遇到 None 时退出

    // for 循环写法
    for item in data.iter() {
        print!("{} ", item);
    }
    println!();

    // 等价的手动 next() 写法
    let mut iter = data.iter();
    loop {
        match iter.next() {
            Some(item) => print!("{} ", item),
            None => break,
        }
    }
    println!();

    // while let 写法(更简洁的手动方式)
    let mut iter = data.iter();
    while let Some(item) = iter.next() {
        print!("{} ", item);
    }
    println!();
}

next() 的 &mut self ​

rust
fn main() {
    let nums = vec![1, 2, 3, 4, 5];
    let mut iter = nums.iter();

    // next() 修改迭代器状态,需要 &mut self
    // 所以 iter 必须是 mut

    // 消费前两个
    println!("消费: {:?}", iter.next());  // Some(&1)
    println!("消费: {:?}", iter.next());  // Some(&2)

    // 剩下的元素可以继续用其他方法处理
    let remaining: Vec<&&i32> = iter.collect();
    println!("剩余: {:?}", remaining);  // [&3, &4, &5]

    // 部分消费后用 for 循环处理剩余
    let data = vec!["a", "b", "c", "d", "e"];
    let mut iter = data.iter();

    // 跳过前两个
    iter.next();
    iter.next();

    // for 循环处理剩余
    print!("剩余: ");
    for item in iter {
        print!("{} ", item);
    }
    println!();  // c d e
}

在自定义迭代器中实现 next() ​

rust
// 范围步进迭代器
struct StepRange {
    current: i64,
    end: i64,
    step: i64,
}

impl StepRange {
    fn new(start: i64, end: i64, step: i64) -> Self {
        StepRange {
            current: start,
            end,
            step,
        }
    }
}

impl Iterator for StepRange {
    type Item = i64;

    fn next(&mut self) -> Option<i64> {
        if (self.step > 0 && self.current >= self.end)
            || (self.step < 0 && self.current <= self.end)
        {
            None  // 到达边界,迭代结束
        } else {
            let value = self.current;
            self.current += self.step;  // 推进状态
            Some(value)
        }
    }
}

// 字符串分段迭代器
struct Chunks<'a> {
    data: &'a str,
    size: usize,
    pos: usize,
}

impl<'a> Chunks<'a> {
    fn new(data: &'a str, size: usize) -> Self {
        Chunks { data, size, pos: 0 }
    }
}

impl<'a> Iterator for Chunks<'a> {
    type Item = &'a str;

    fn next(&mut self) -> Option<&'a str> {
        if self.pos >= self.data.len() {
            None
        } else {
            let end = (self.pos + self.size).min(self.data.len());
            let chunk = &self.data[self.pos..end];
            self.pos = end;
            Some(chunk)
        }
    }
}

fn main() {
    // 步进范围
    println!("步进2 (0..10):");
    let stepped: Vec<i64> = StepRange::new(0, 10, 2).collect();
    println!("  {:?}", stepped);

    println!("步进3 (1..20):");
    let stepped: Vec<i64> = StepRange::new(1, 20, 3).collect();
    println!("  {:?}", stepped);

    println!("倒数 (10..0, step=-2):");
    let countdown: Vec<i64> = StepRange::new(10, 0, -2).collect();
    println!("  {:?}", countdown);

    // 字符串分段
    println!("\n字符串分段:");
    let text = "HelloRustWorld";
    for chunk in Chunks::new(text, 4) {
        println!("  '{}'", chunk);
    }
}

next() 与 peek() ​

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

    // peekable() 可以查看下一个元素但不消费它
    let mut iter = data.iter().peekable();

    // peek() 返回 Option<&&i32>,不推进迭代器
    println!("偷看: {:?}", iter.peek());  // Some(&&1)
    println!("偷看: {:?}", iter.peek());  // 仍然是 Some(&&1)

    // next() 消费元素,推进迭代器
    println!("消费: {:?}", iter.next());  // Some(&1)
    println!("偷看: {:?}", iter.peek());  // Some(&&2)

    // 利用 peek 实现条件消费
    let nums = vec![1, 3, 5, 2, 4, 6, 8, 7];
    let mut iter = nums.iter().peekable();

    // 收集连续的奇数
    let mut odds = Vec::new();
    while let Some(&&n) = iter.peek() {
        if n % 2 == 1 {
            odds.push(*iter.next().unwrap());
        } else {
            break;
        }
    }

    // 收集剩余元素
    let rest: Vec<&i32> = iter.collect();

    println!("连续奇数: {:?}", odds);
    println!("剩余: {:?}", rest);
}

基本示例 ​

用 next() 实现一个 CSV 行解析迭代器:

rust
// CSV 字段迭代器
struct CsvFields<'a> {
    line: &'a str,
    pos: usize,
}

impl<'a> CsvFields<'a> {
    fn new(line: &'a str) -> Self {
        CsvFields { line, pos: 0 }
    }
}

impl<'a> Iterator for CsvFields<'a> {
    type Item = &'a str;

    fn next(&mut self) -> Option<&'a str> {
        // 已经到末尾
        if self.pos > self.line.len() {
            return None;
        }

        if self.pos == self.line.len() {
            // 处理末尾空字段的情况
            self.pos = self.line.len() + 1;
            return Some("");
        }

        // 查找下一个逗号
        let remaining = &self.line[self.pos..];
        match remaining.find(',') {
            Some(comma_pos) => {
                let field = &self.line[self.pos..self.pos + comma_pos];
                self.pos += comma_pos + 1;  // 跳过逗号
                Some(field.trim())
            }
            None => {
                // 最后一个字段
                let field = &self.line[self.pos..];
                self.pos = self.line.len() + 1;  // 标记结束
                Some(field.trim())
            }
        }
    }
}

fn main() {
    // 解析 CSV 行
    let lines = vec![
        "张三, 25, 北京, 工程师",
        "李四, 30, 上海, 设计师",
        "王五, 28, 广州, 产品经理",
    ];

    println!("=== CSV 解析 ===");
    for line in &lines {
        let fields: Vec<&str> = CsvFields::new(line).collect();
        println!("字段数: {}, 内容: {:?}", fields.len(), fields);
    }

    // 手动用 next() 逐字段处理
    println!("\n=== 逐字段处理 ===");
    let record = "Rust, 2015, Mozilla, 系统编程";
    let mut fields = CsvFields::new(record);

    if let Some(name) = fields.next() {
        println!("名称: {}", name);
    }
    if let Some(year) = fields.next() {
        println!("年份: {}", year);
    }

    // 剩余字段
    let rest: Vec<&str> = fields.collect();
    println!("其他: {:?}", rest);

    // 使用迭代器方法
    println!("\n=== 迭代器方法 ===");
    let data = "10, 20, 30, 40, 50";
    let sum: i32 = CsvFields::new(data)
        .filter_map(|f| f.parse::<i32>().ok())
        .sum();
    println!("数字总和: {}", sum);

    let count = CsvFields::new(data).count();
    println!("字段数量: {}", count);
}

常见问题 ​

问题一:next() 返回 None 后还能继续调用吗?

可以调用,但标准约定是返回 None 后应该持续返回 None。这叫做"融合"(fused)行为。如果需要保证这一点,可以用 .fuse() 适配器包装。

问题二:next() 里可以做耗时操作吗?

可以。next() 就是普通的方法调用,可以做任何计算,包括 IO 操作。但要注意,迭代器的使用者可能不知道 next() 的开销,所以文档中应说明。

问题三:为什么 next() 需要 &mut self?

因为每次调用 next() 都会推进迭代器的内部位置。这是一个修改操作,需要可变引用。

问题四:一次 next() 调用可以产出多个值吗?

不可以。next() 每次只返回一个 Option<Item>。如果需要批量产出,可以让 Item 是一个集合类型(如 Vec),或使用 flat_map。

适用场景 ​

  • 自定义数据源:文件读取、网络数据、传感器数据
  • 数学序列:斐波那契、素数、阶乘
  • 解析器:逐 token/逐字段解析
  • 有限状态机:每次 next() 推进一步状态

注意事项 ​

  • next() 是 Iterator trait 唯一必须实现的方法
  • 返回 Some(值) 表示有下一个元素,None 表示结束
  • next() 接受 &mut self,会修改迭代器状态
  • 返回 None 后应持续返回 None
  • for 循环、collect、sum 等底层都是调用 next()
  • peekable() 可以查看下一个元素但不消费它

总结 ​

next() 是 Iterator trait 的核心方法,每次调用产出一个 Option<Self::Item>:Some(值) 表示有元素,None 表示结束。实现自定义迭代器只需要定义这一个方法,就能自动获得几十个迭代器方法。next() 通过 &mut self 修改内部状态来推进迭代位置。for 循环和所有迭代器消费器在底层都是反复调用 next()。用 peekable() 可以在不消费元素的情况下查看下一个值。返回 None 后应持续返回 None(融合语义)。