如何让Rust迭代器返回跳过指定步长后的正确索引？

我明白你遇到的问题了——当你用skip(n)加step_by(m)遍历数组时，用enumerate()得到的是迭代器内部的计数，而不是原数组的真实索引对吧？咱们直接来看怎么修复这个问题。

为什么你的索引不对？ #

首先得搞清楚原因：enumerate()是给当前迭代器的每个元素分配一个从0开始的序号，这个序号只和你迭代了多少次有关，和原数组的位置没关系。比如你跳过了前3个元素，第一个被迭代的元素在原数组里是索引3，但enumerate()会给它标0，这就是你看到错误输出的原因。

解决方案1：手动计算原索引 #

这是最简单的方法，既然知道起始索引是n，每次步长是m，那第x次迭代的原索引就是n + x * m，这里的x就是enumerate()给你的那个计数。

示例代码：

fn main() {
    let arr = [false, false, false, true, false, true, false];
    let start_idx = 3;
    let step = 2;

    for (iter_count, val) in arr.iter().skip(start_idx).step_by(step).enumerate() {
        let original_idx = start_idx + iter_count * step;
        println!("{} = {}", original_idx, val);
    }
}

运行这个代码，你会得到正确的输出：

3 = true
5 = true

解决方案2：用范围迭代器和zip配对 #

另一种更直观的方式是直接生成原数组的目标索引序列，然后和元素迭代器zip起来。这样你就能同时拿到正确的索引和对应的元素，不需要额外计算。

示例代码：

fn main() {
    let arr = [false, false, false, true, false, true, false];
    let start_idx = 3;
    let step = 2;

    // 生成从start_idx开始、步长为step的索引范围
    let index_iter = (start_idx..arr.len()).step_by(step);
    // 和元素迭代器配对
    for (original_idx, val) in index_iter.zip(arr.iter().skip(start_idx).step_by(step)) {
        println!("{} = {}", original_idx, val);
    }
}

这个方法的好处是代码可读性更高，一眼就能看出来你在遍历哪些索引。

解决方案3：自定义迭代器（适合复用场景） #

如果你需要在多个地方用到这种迭代器，可以封装成一个自定义的迭代器类型，这样代码更整洁，复用性更强。

示例代码：

struct StepIndexedIter<'a, T> {
    slice: &'a [T],
    current_idx: usize,
    step: usize,
}

impl<'a, T> StepIndexedIter<'a, T> {
    // 构造函数：如果起始索引超出数组长度或步长为0，返回None
    fn new(slice: &'a [T], start: usize, step: usize) -> Option<Self> {
        if start >= slice.len() || step == 0 {
            return None;
        }
        Some(Self {
            slice,
            current_idx: start,
            step,
        })
    }
}

impl<'a, T> Iterator for StepIndexedIter<'a, T> {
    type Item = (usize, &'a T);

    fn next(&mut self) -> Option<Self::Item> {
        // 获取当前索引对应的元素
        let val = self.slice.get(self.current_idx)?;
        let current = self.current_idx;
        // 更新下一次的索引
        self.current_idx += self.step;
        Some((current, val))
    }
}

// 使用示例
fn main() {
    let arr = [false, false, false, true, false, true, false];
    let start_idx = 3;
    let step = 2;

    if let Some(iter) = StepIndexedIter::new(&arr, start_idx, step) {
        for (idx, val) in iter {
            println!("{} = {}", idx, val);
        }
    }
}

这个自定义迭代器会自动处理起始索引越界的情况，而且每次调用next()都会返回正确的原索引和元素。

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