Rust中如何对字符串迭代器进行破坏性迭代并实现递归处理？

核心思路是不要依赖for循环自动消耗迭代器，而是手动调用迭代器的next()方法控制遍历流程，这样迭代器的当前位置状态会被保留，递归时直接传递可变迭代器即可让后续逻辑继续消费剩余元素。

以下是具体实现：

fn process_tokens<'a>(tokens: &mut impl Iterator<Item = &'a str>) {
    while let Some(token) = tokens.next() {
        match token {
            "option1" => {
                // 处理option1的逻辑
                println!("处理option1");
            }
            "option2" => {
                // 处理option2的逻辑
                println!("处理option2");
            }
            "{" => {
                // 递归处理内部内容，直接传递可变迭代器
                println!("进入内部块");
                process_tokens(tokens);
                println!("退出内部块");
            }
            "}" => {
                // 遇到闭合括号，终止当前递归层的遍历
                return;
            }
            _ => {
                // 处理其他 token
                println!("处理未知token: {}", token);
            }
        }
    }
}

fn main() {
    let s = "option1 { option2 { test } } end";
    let mut tokens = s.split_whitespace();
    process_tokens(&mut tokens);
}

关键说明 #

• 手动使用while let Some(token) = tokens.next()替代for循环，完全掌控迭代器的消费节奏。
• 递归时传递可变引用的迭代器，递归函数会从当前位置继续往后消费元素，无需重新分割字符串或手动计算索引。
• 遇到闭合的}时直接return，终止当前递归层，回到上层继续处理剩余元素。

这种方式比手动操作索引更安全，迭代器已处理好字符串分割的细节，避免了越界、索引计算错误等问题，同时天然支持递进式的破坏性消费。

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