如何在Rust中使用字符串迭代器实现预读（peek）功能？

针对你遇到的Unicode兼容、无消耗查看下一个字符且保证性能的问题，最直接的方案是利用Rust标准库的Peekable迭代器适配器，它完美适配扫描器的逐字符处理场景：

核心思路 #

Peekable是Iterator trait的适配器，允许你查看迭代器的下一个元素而不消耗当前迭代状态，同时天然支持Unicode字符（基于chars()迭代器，每个元素是合法的Unicode标量值），且peek()操作是O(1)时间复杂度，完全避免了chars().nth()的遍历开销。

代码实现示例 #

首先定义扫描器结构体，封装Peekable<char>迭代器，还可以按需跟踪当前位置（字节偏移或字符计数）：

use std::iter::Peekable;
use std::str::Chars;

struct Scanner<'a> {
    chars: Peekable<Chars<'a>>,
    // 可选：跟踪当前字节位置，用于错误提示
    current_byte: usize,
    // 可选：跟踪当前字符索引
    current_char: usize,
}

impl<'a> Scanner<'a> {
    fn new(source: &'a str) -> Self {
        Scanner {
            chars: source.chars().peekable(),
            current_byte: 0,
            current_char: 0,
        }
    }

    // 获取当前位置的下一个字符（不消耗）
    fn peek(&mut self) -> Option<&char> {
        self.chars.peek()
    }

    // 消耗当前字符并返回，同时更新位置
    fn next(&mut self) -> Option<char> {
        let c = self.chars.next()?;
        // 更新字节位置：注意char的字节长度可能大于1
        self.current_byte += c.len_utf8();
        self.current_char += 1;
        Some(c)
    }
}

进阶：手动缓存方案（无依赖支持多步peek） #

如果需要查看多个后续字符（比如peek2、peek3），且不想引入第三方库，可手动在扫描器中缓存后续字符：

struct Scanner<'a> {
    chars: Chars<'a>,
    next_char: Option<char>,
    current_byte: usize,
    current_char: usize,
}

impl<'a> Scanner<'a> {
    fn new(source: &'a str) -> Self {
        let mut chars = source.chars();
        let next_char = chars.next();
        Scanner {
            chars,
            next_char,
            current_byte: 0,
            current_char: 0,
        }
    }

    fn peek(&self) -> Option<char> {
        self.next_char.clone()
    }

    fn next(&mut self) -> Option<char> {
        let current = self.next_char.take()?;
        let byte_len = current.len_utf8();
        self.current_byte += byte_len;
        self.current_char += 1;
        // 预取下一个字符
        self.next_char = self.chars.next();
        Some(current)
    }

    // 查看下下个字符
    fn peek_next(&mut self) -> Option<char> {
        let temp = self.next_char.take();
        let peeked = temp.and_then(|_| self.chars.next());
        // 放回缓存的字符
        self.next_char = temp;
        peeked
    }
}

关键优势对比 #

• 避免字符串索引：完全基于chars()迭代器处理Unicode，不会出现索引越界或截断字符的问题
• 无消耗查看：peek()仅查看下一个字符，不会改变迭代器的当前位置
• 全Unicode支持：天然处理所有合法Unicode标量值，不限于ASCII
• 高性能：两种方案的peek操作都是O(1)，远优于chars().nth(n)的O(n)遍历开销

内容的提问来源于stack exchange，提问作者sean