skip 跳过 ​

核心概念 ​

skip(n) 是迭代器适配器,它跳过迭代器的前 n 个元素,从第 n+1 个元素开始产出。如果迭代器的元素总数不足 n 个,skip 后的迭代器为空。skip 是惰性的,它在第一次调用 next() 时才会实际跳过元素(消耗前 n 个)。skip 常与 take 搭配实现分页,也用于跳过文件头、标题行等场景。

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

    // 跳过前 3 个
    let after_skip: Vec<&i32> = data.iter().skip(3).collect();
    println!("跳过3个: {:?}", after_skip);  // [40, 50, 60, 70]

    // 跳过全部
    let empty: Vec<&i32> = data.iter().skip(100).collect();
    println!("跳过100: {:?}", empty);  // []

    // skip(0) 不跳过任何元素
    let all: Vec<&i32> = data.iter().skip(0).collect();
    println!("skip(0): {:?}", all);

    // 原始集合不受影响
    println!("原始: {:?}", data);
}

skip 与 skip_while 的对比 ​

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

    // skip(n):按数量跳过固定的前 n 个
    let by_count: Vec<&i32> = data.iter().skip(3).collect();
    println!("skip(3): {:?}", by_count);  // [2, 4, 6, 8]

    // skip_while:按条件跳过,遇到不满足条件的就开始产出
    let by_condition: Vec<&i32> = data.iter()
        .skip_while(|&&x| x % 2 == 1)  // 跳过开头的奇数
        .collect();
    println!("skip_while(奇数): {:?}", by_condition);  // [2, 4, 6, 8]

    // skip_while 只跳过开头连续满足条件的元素
    // 一旦遇到不满足的,后面的全部产出(即使后面有满足条件的)
    let mixed = vec![2, 4, 6, 1, 8, 10];
    let result: Vec<&i32> = mixed.iter()
        .skip_while(|&&x| x % 2 == 0)  // 跳过开头的偶数
        .collect();
    println!("skip_while(偶数): {:?}", result);  // [1, 8, 10]
}
方法跳过方式参数适用场景
skip(n)固定数量usize分页、跳过固定头部
skip_while(f)条件满足时跳过FnMut(&T) -> bool跳过开头满足条件的连续元素

skip + take 分页 ​

rust
fn main() {
    let items: Vec<String> = (1..=20)
        .map(|i| format!("项目{:02}", i))
        .collect();

    let page_size = 5;
    let total_pages = (items.len() + page_size - 1) / page_size;

    // 逐页显示
    for page in 0..total_pages {
        println!("=== 第 {} 页 ===", page + 1);
        items.iter()
            .skip(page * page_size)   // 跳过前面的页
            .take(page_size)          // 取当前页的条目
            .enumerate()
            .for_each(|(i, item)| {
                let global_idx = page * page_size + i + 1;
                println!("  {}. {}", global_idx, item);
            });
    }
    println!("共 {} 条,每页 {} 条,共 {} 页", items.len(), page_size, total_pages);
}

skip 与其他适配器配合 ​

rust
fn main() {
    let data = vec![100, 200, 300, 400, 500, 600, 700, 800, 900, 1000];

    // skip + filter
    let result: Vec<&i32> = data.iter()
        .skip(3)
        .filter(|&&x| x > 500)
        .collect();
    println!("skip(3)+filter(>500): {:?}", result);

    // skip + map
    let result: Vec<String> = data.iter()
        .skip(5)
        .map(|&x| format!("¥{}", x))
        .collect();
    println!("skip(5)+map: {:?}", result);

    // skip + enumerate:注意索引从 0 重新开始
    println!("\nskip(3)+enumerate:");
    data.iter()
        .skip(3)
        .enumerate()
        .for_each(|(i, &x)| println!("  [{}] = {}", i, x));

    // skip + sum
    let partial_sum: i32 = data.iter().skip(7).sum();
    println!("\n后3个之和: {}", partial_sum);

    // skip + take(窗口)
    let window: Vec<&i32> = data.iter().skip(2).take(4).collect();
    println!("窗口[2..6]: {:?}", window);

    // skip + chain:跳过开头后追加新元素
    let extra = vec![0, 0, 0];
    let result: Vec<&i32> = data.iter()
        .skip(8)
        .chain(extra.iter())
        .collect();
    println!("skip(8)+chain: {:?}", result);
}

基本示例 ​

用 skip 处理带头部的数据文件:

rust
fn main() {
    // 模拟 CSV 文件内容(第一行是标题)
    let csv_content = vec![
        "姓名,年龄,城市,职业",
        "张三,25,北京,工程师",
        "李四,30,上海,设计师",
        "王五,28,广州,产品经理",
        "赵六,35,深圳,架构师",
        "钱七,22,杭州,实习生",
    ];

    // 跳过标题行
    println!("=== 数据记录 ===");
    let records: Vec<Vec<&str>> = csv_content.iter()
        .skip(1)  // 跳过标题行
        .map(|line| line.split(',').collect())
        .collect();

    for record in &records {
        println!("  {} | {}岁 | {} | {}", record[0], record[1], record[2], record[3]);
    }

    // 统计(跳过标题行)
    let ages: Vec<u32> = csv_content.iter()
        .skip(1)
        .filter_map(|line| {
            let fields: Vec<&str> = line.split(',').collect();
            fields.get(1).and_then(|s| s.parse().ok())
        })
        .collect();

    let avg_age: f64 = ages.iter().sum::<u32>() as f64 / ages.len() as f64;
    println!("\n平均年龄: {:.1}", avg_age);
    println!("最大年龄: {}", ages.iter().max().unwrap());
    println!("最小年龄: {}", ages.iter().min().unwrap());

    // 模拟日志文件:跳过旧日志
    let log_lines = vec![
        "[2026-01-01] 系统启动",
        "[2026-01-02] 用户注册",
        "[2026-01-03] 数据备份",
        "[2026-03-01] 系统升级",
        "[2026-03-15] 安全补丁",
        "[2026-03-20] 性能优化",
        "[2026-03-25] 新功能上线",
    ];

    // 只看最近 3 条
    let recent_count = 3;
    let skip_count = log_lines.len().saturating_sub(recent_count);
    println!("\n=== 最近 {} 条日志 ===", recent_count);
    log_lines.iter()
        .skip(skip_count)
        .for_each(|line| println!("  {}", line));

    // 跳过前 N 行求和(模拟跳过注释行)
    let data_with_comments = vec![
        "# 这是注释",
        "# 数据说明",
        "# 单位: 元",
        "100",
        "250",
        "180",
        "320",
    ];

    let comment_lines = data_with_comments.iter()
        .take_while(|line| line.starts_with('#'))
        .count();

    let total: i32 = data_with_comments.iter()
        .skip(comment_lines)
        .filter_map(|s| s.parse::<i32>().ok())
        .sum();
    println!("\n跳过{}行注释后,数据总和: {}", comment_lines, total);
}

常见问题 ​

问题一:skip(n) 中 n 大于迭代器长度会怎样?

不会报错,skip 后的迭代器为空,collect 得到空集合,sum 得到 0 等。

问题二:skip 会实际遍历被跳过的元素吗?

对大多数迭代器是的——skip 在第一次 next() 调用时会连续调用底层迭代器的 next() n 次来跳过元素。但某些迭代器(如 Vec 的切片迭代器)可能有优化的 nth() 实现。

问题三:skip 和切片索引 &data[n..] 有什么区别?

切片索引是 O(1) 直接跳到目标位置(仅适用于切片类型),skip 是通用的迭代器方法,适用于任何迭代器但可能是 O(n)。对切片来说优先用索引,对通用迭代器用 skip。

问题四:skip 后的 enumerate 索引从几开始?

从 0 开始。skip 不影响后续 enumerate 的起始索引。如果需要保留原始索引,先 enumerate 再 skip。

适用场景 ​

  • 分页:skip(page * size).take(size)
  • 跳过头部:CSV 标题行、文件注释、日志头部
  • 尾部截取:skip(len - n) 取最后 n 个
  • 窗口操作:skip(start).take(end - start)

注意事项 ​

  • skip 是惰性的,但首次拉取时会消耗被跳过的元素
  • n 大于元素数量时安全返回空迭代器
  • skip(0) 不跳过任何元素
  • skip 后 enumerate 索引从 0 重新开始
  • 对切片类型,&data[n..] 比 skip(n) 更高效
  • skip_while 按条件跳过开头连续满足条件的元素

总结 ​

skip(n) 跳过迭代器的前 n 个元素,从第 n+1 个开始产出。元素不足 n 个时安全返回空迭代器。skip 与 take 搭配是实现分页的标准方式:skip(page * size).take(size)。skip_while 是按条件跳过的变体,一旦遇到不满足条件的元素就开始产出所有后续元素。skip 后的 enumerate 索引从 0 重新开始。skip 常用于跳过文件头部(标题行、注释行)、分页显示、尾部截取等场景。