Rust中的for循环与迭代器

最新推荐文章于 2025-11-23 23:13:13 发布
原创 最新推荐文章于 2025-11-23 23:13:13 发布 · 776 阅读 · 15 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#rust #for #迭代器 #绑定解构 #Iterator #IntoIterator

for 循环是迭代器的语法糖，而迭代器是 Rust 处理集合（如 Vec、HashMap）的核心抽象。

for循环

for 循环本质是自动遍历一个“可迭代对象”（实现 IntoIterator trait 的类型），底层逻辑如下：

  1. 对目标对象调用 into_iter() 方法，将其转换为迭代器（Iterator）；
  2. 循环调用迭代器的 next() 方法，每次获取一个元素（Some(T)）；
  3. 当 next() 返回 None 时，循环终止；
for item in collection {
    // ...
}

// 会转换为以下近似代码
{
    let mut iter = IntoIterator::into_iter(collection);
    while let Some(item) = iter.next() {
        // ...
    }
}

用法

任何实现 IntoIterator 的类型，都能直接用 for 循环遍历。常有以下使用场景：

  • 遍历集合：处理 Vec、数组（[T; N]）、切片（&[T]）等连续存储的集合；需注意所有权与借用模式，三种核心模式；
    • 所有权转移遍历：into_iter()；转移所有权，T类型；
    • 不可变借用遍历：iter()；不可变引用&T，需通过解引用（*）访问元素值。
    • 可变借用遍历：iter_mut()；可变引用&mut T，需通过解引用（*）修改元素。
  • 计数循环：Range区间遍历
    • 左闭右开区间（a..b）
    • 左闭右闭区间（a..=b）
    • 反向计数（rev() 反向迭代）：for i in (1..=5).rev()
  • 键值对遍历（HashMap/BTreeMap）：返回key与value的引用；for (key, value) in &map
  • 遍历索引与值：enumerate() 适配器（返回 (index, value) 元组）；for (idx, fruit) in fruits.iter().enumerate()
写法底层机制说明
for x in vv.into_iter()T（原值）；所有权转移（消耗集合）
for x in &vv.iter()&T（不可变引用）；不可变借用（只读集合）
for x in &mut vv.iter_mut()&mut T（可变引用）；可变借用（修改集合）
for i in 0..nRange迭代器值拷贝
使用 'label
+ break 'label		控制流嵌套退出

绑定解构

迭代器遍历与后续适配器中元素的类型，是由trait中的Item确定的；对于引用类型，可通过&(不是取地址)进行解构。以iter()（Item 是 &T）遍历为例：

  • 用 x：绑定 &T（保留引用），需通过 *x 解引用操作值；
  • 用 &x：解构一层引用，直接绑定 T（原值），无需解引用。
fn type_of<T>(_: &T) -> &'static str {
    type_name::<T>()
}

pub fn for_test() {
    let mut map = HashMap::new();
    map.insert("english", 80);
    map.insert("math", 90);

    // 用&解构过一次，输出：&str: i32
    for (&key, &value) in &map {
        println!("{}: {}", type_of(&key), type_of(&value));
        break;
    }

    // 输出：&&str: &i32
    for (key, value) in &map {
        println!("{}: {}", type_of(&key), type_of(&value));
        break;
    }
}

迭代器

Rust 的迭代器是实现了 Iterator trait 的对象；其不仅仅是一个“遍历工具”，还能惰性处理数据流，即惰性求值（lazy evaluation）；多数方法不会立即执行，只是返回一个新的迭代器（直到 .collect() 或 .for_each() 等最终消费执行时，才计算）。

pub fn it_test() {
    // 1. 拆分单词为字符 → 2. 筛选小写字母 → 3. 转换为大写 → 4. 收集为 Vec<char>
    let words = vec!["Hello", "World", "Rust"];
    let uppercase_chars: Vec<char> = words
        .iter()
        .flat_map(|s| s.chars()) // 扁平化：["H","e","l","l","o", ...]
        .filter(|&c| c.is_ascii_lowercase()) // 筛选小写字母
        .map(|c| c.to_ascii_uppercase()) // 转换为大写
        .collect(); // 消耗迭代器，收集结果
    println!("{:?}", uppercase_chars); // 输出 ['E', 'L', 'L', 'O', 'O', 'R', 'L', 'D', 'U', 'S', 'T']

    let nums = vec![1, 2, 3, 4, 5];
    // 1. 求和（fold 折叠）
    let total = nums.iter().fold(1, |init, &x| init * x);
    println!("阶乘：{}", total); // 输出 120
    // 2. 查找第一个偶数
    let first_even = nums.iter().find(|&&x| x % 2 == 0);
    println!("第一个偶数：{:?}", first_even); // 输出 Some(2)
    // 3. 判断是否存在大于 5 的元素
    let has_gt5 = nums.iter().any(|&x| x > 5);
    println!("存在大于 5 的元素？{}", has_gt5); // 输出 false
}

适配器（Adapter）

适配器是返回新迭代器的方法，用于转换、筛选、组合原迭代器；多个适配器可组成“链式”，即通过把多个迭代器适配器组合在一起形成流水线式的数据处理流程。常见适配器：

适配器功能
map(f)对元素应用 f，转换元素类型
filter(f)保留满足条件 f的元素，返回 bool
flat_map(f)对元素应用 f，扁平化结果
rev()反向遍历（需迭代器实现 DoubleEndedIterator）
skip(n)跳过前 n 个元素
take(n)取前 n 个元素，之后终止迭代
chain(iter2)拼接两个迭代器
enumerate()同时获取元素的索引和值，返回一个元组 (usize, T)

消耗性方法（Consuming Adapter）

消耗型方法会遍历迭代器、消耗元素，并返回最终结果（触发惰性求值），常见方法：

方法功能
collect<T>()收集元素为集合 T
count()返回元素个数
fold(init, f)折叠元素（聚合计算），init 为初始值
any(f)存在元素满足 f， 则返回 true
all(f)所有元素满足 f， 则返回 true
find(f)查找第一个满足 f 的元素，返回 Option<Item>
for_each(f)对每个元素执行 f，等价于 for
循环

无限迭代器

无限迭代器（如 iter::repeat、Range::repeat），需通过 take(n) 等方法限制迭代次数，否则会陷入死循环。

常见无限迭代器：

  • iter::repeat(val)：无限重复 val；
  • iter::cycle()：循环迭代原迭代器（原迭代器需是 Clone）；
  • (0..).step_by(n)：无限递增序列（步长 n）。

自定义迭代器

要创建自定义迭代器，只需实现 Iterator trait 的 next() 方法（其他方法为默认实现）。

Iterator trait 继承了 IntoIterator trait 的默认实现（IntoIterator::into_iter() 会直接返回迭代器本身（Self））。因此，只要一个类型实现了 Iterator::next()，就自动支持 for 循环遍历（本质是遍历迭代器自己）。

// pub trait Iterator {
//     type Item;
//
//     fn next(&mut self) -> Option<Self::Item>;
//
//     // 其他很多默认实现的方法（map, filter, fold等）
// }

struct Counter {
    count: u32,
    upper: u32,
}

impl Counter {
    fn new(upper: u32) -> Counter {
        Counter { count: 0, upper }
    }
}

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        self.count += 1;
        if self.count <= self.upper {
            Some(self.count)
        } else {
            None
        }
    }
}

pub fn it_test() {
    for n in Counter::new(5) {
        println!("{}", n); // 输出：1~5
    }
}

自定义容器

容器要被 for 循环遍历，需让容器（或其引用）实现 IntoIterator trait：

  • iter() -> 返回不可变引用的迭代器
  • iter_mut() -> 返回可变引用的迭代器
  • into_iter() -> 转移所有权迭代器
// for x in my_container（消耗所有权）
impl<T> IntoIterator for MyContainer<T> {
    type Item = T;
    type IntoIter = MyIntoIter<T>;

    fn into_iter(self) -> Self::IntoIter {
        ...
    }
}

// for x in &my_container（不可变引用）
impl<'a, T> IntoIterator for &'a MyContainer<T> {
    type Item = &'a T;
    type IntoIter = MyIter<'a, T>;

    fn into_iter(self) -> Self::IntoIter {
        ...
    }
}

// for x in &mut my_container（可变引用）
impl<'a, T> IntoIterator for &'a mut MyContainer<T> {
    type Item = &'a mut T;
    type IntoIter = MyIterMut<'a, T>;

    fn into_iter(self) -> Self::IntoIter {
        ...
    }
}

以一个环形缓冲区为例，实现三种for操作：

use core::slice;
use std::mem::MaybeUninit;

pub struct RingBuffer<T, const N: usize> {
    data: [MaybeUninit<T>; N],
    head: usize,
    len: usize,
}

impl<T, const N: usize> RingBuffer<T, N> {
    pub fn new() -> Self {
        Self {
            data: unsafe { MaybeUninit::uninit().assume_init() },
            head: 0,
            len: 0,
        }
    }

    pub fn len(&self) -> usize {
        self.len
    }

    pub fn push(&mut self, value: T) -> Result<(), &str> {
        if self.len == N {
            return Err("buffer full");
        }
        let tail = (self.head + self.len) % N;
        self.data[tail] = MaybeUninit::new(value);
        self.len += 1;
        Ok(())
    }

    pub fn pop(&mut self) -> Option<T> {
        if self.len == 0 {
            return None;
        }
        let val = std::mem::replace(&mut self.data[self.head], MaybeUninit::uninit());
        self.head = (self.head + 1) % N;
        self.len -= 1;
        Some(unsafe { val.assume_init() })
    }

    /// 获取不可变切片视图（连续或分段）
    fn as_slices(&self) -> (&[T], &[T]) {
        unsafe {
            let head_ptr = self.data.as_ptr().add(self.head) as *const T;
            if self.head + self.len <= N {
                (slice::from_raw_parts(head_ptr, self.len), &[])
            } else {
                let first_len = N - self.head;
                let rest = (self.head + self.len) % N;
                (
                    slice::from_raw_parts(head_ptr, first_len),
                    slice::from_raw_parts(self.data.as_ptr() as *const T, rest),
                )
            }
        }
    }

    fn as_mut_slice(&mut self) -> (&mut [T], &mut [T]) {
        unsafe {
            let head_ptr = self.data.as_mut_ptr().add(self.head) as *mut T;
            if self.head + self.len <= N {
                (slice::from_raw_parts_mut(head_ptr, self.len), &mut [])
            } else {
                let first_len = N - self.head;
                let rest = (self.head + self.len) % N;
                (
                    slice::from_raw_parts_mut(head_ptr, first_len),
                    slice::from_raw_parts_mut(self.data.as_ptr() as *mut T, rest),
                )
            }
        }
    }
}

impl<T, const N: usize> Drop for RingBuffer<T, N> {
    fn drop(&mut self) {
        for i in 0..self.len {
            let idx = (self.head + i) % N;
            unsafe {
                self.data[idx].assume_init_drop();
            }
        }
    }
}

pub struct Iter<'a, T> {
    first: slice::Iter<'a, T>,
    second: slice::Iter<'a, T>,
}
impl<T, const N: usize> RingBuffer<T, N> {
    pub fn iter(&self) -> Iter<'_, T> {
        let (first, second) = self.as_slices();
        Iter {
            first: first.iter(),
            second: second.iter(),
        }
    }
}
impl<'a, T> Iterator for Iter<'a, T> {
    type Item = &'a T;
    fn next(&mut self) -> Option<Self::Item> {
        self.first.next().or_else(|| self.second.next())
    }
}

pub struct IterMut<'a, T> {
    first: slice::IterMut<'a, T>,
    second: slice::IterMut<'a, T>,
}
impl<T, const N: usize> RingBuffer<T, N> {
    pub fn iter_mut(&mut self) -> IterMut<'_, T> {
        let (first, second) = self.as_mut_slice();
        IterMut {
            first: first.iter_mut(),
            second: second.iter_mut(),
        }
    }
}
impl<'a, T> Iterator for IterMut<'a, T> {
    type Item = &'a mut T;
    fn next(&mut self) -> Option<Self::Item> {
        self.first.next().or_else(|| self.second.next())
    }
}

pub struct IntoIter<T, const N: usize> {
    buff: RingBuffer<T, N>,
}
impl<T, const N: usize> Iterator for IntoIter<T, N> {
    type Item = T;
    fn next(&mut self) -> Option<Self::Item> {
        self.buff.pop()
    }
}

// IntoIterator Trait
impl<T, const N: usize> IntoIterator for RingBuffer<T, N> {
    type Item = T;
    type IntoIter = IntoIter<T, N>;
    fn into_iter(self) -> Self::IntoIter {
        IntoIter { buff: self }
    }
}
impl<'a, T, const N: usize> IntoIterator for &'a RingBuffer<T, N> {
    type Item = &'a T;
    type IntoIter = Iter<'a, T>;
    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}
impl<'a, T, const N: usize> IntoIterator for &'a mut RingBuffer<T, N> {
    type Item = &'a mut T;
    type IntoIter = IterMut<'a, T>;
    fn into_iter(self) -> Self::IntoIter {
        self.iter_mut()
    }
}

pub fn ringbuff_test() {
    let mut buf: RingBuffer<i32, 4> = RingBuffer::new();
    buf.push(10).unwrap();
    buf.push(20).unwrap();
    buf.push(30).unwrap();

    println!("Iterate immutably:");
    for v in &buf {
        println!("  value = {v}");
    }

    println!("Iterate mutably:");
    for v in &mut buf {
        *v += 1;
    }

    println!("Iterate by value:");
    for v in buf {
        println!("  moved = {v}");
    }
}
2024 Rust现代实用教程Iterator迭代器
喜欢打篮球的普通人
11-03 1517
/ 入栈// 出栈// 不可变引用// 返回可变引用// 所有权转移！！println!println!("{:?*item *= 2;println!("{:?println!// println!("{:?编译及运行...| ^^^Item 1Item 2Item 3246。
Rust迭代器详解
ye_yumo的博客
04-01 996
我们也可以为自己的类型实现迭代器 iterator trait（可以理解为接口）只需要定义next方法即可，例如} else {Noneprintln!// 输出 1 到 5这里我们先不去管 impl 是什么，直接翻译的话是实例，适用于给结构体或者特性实现方法的一个关键字。
Rust教程-2.3.3 for 循环和迭代器
wrn_csdn的博客
02-11 510
通过掌握for循环和迭代器的概念，你可以更高效地遍历集合和其他序列类型的元素。无论是简单的数值范围还是复杂的自定义类型，Rust 提供了强大的工具来帮助你编写清晰、高效的代码。希望这部分内容能够帮助你更好地理解和应用 Rust 中的循环和迭代机制。
Rust 性能对比：循环 VS 迭代器
m0_52796585的博客
07-17 1078
闭包和迭代器是 Rust 受函数式编程语言观念所启发的功能。他们对 Rust 以底层的性能来明确的表达高级概念的能力有很大贡献。闭包和迭代器的实现达到了不影响运行时性能的程度。这正是 Rust 竭力提供零成本抽象的目标的一部分。现在我们改进了我们 I/O 项目的（代码）表现力，让我们看一看更多cargo的功能，他们将帮助我们准备好将项目分享给世界。
Rust中的迭代器(Iterator)
mikisan555的博客
10-13 1480
迭代器（Iterator）是计算机编程语言中一个非常优秀的设计，最早本人是在《设计模式：可复用面向对象软件的基础》这本书是看到相关的概念。在面向对象的思想下，迭代器模式是举足轻重的一个优秀设计。可能各位在一些诸如Java和C#之类语言中，学到linq相关的接口，便是基于迭代器模式实现的。Rust不是严格的依据面向对象设计的，但是吸收了很多面向对象的特性，迭代器就是很好的例子。提示：以下是本篇文章正文内容，下面案例可供参考Iterator的知识，其实非常重要。
Rust：官方迭代器大全
程序猿视角
05-12 1664
一、for 和迭代器 先看一段代码： fn main() { for x in [1, 2, 3, 4, 5] { println!("{:?}", x); } } ======== cargorun ======== 1 2 3 4 5 如果 for 语句只能用于数组，那就太可惜了。我们看一下 Vec 类型： fn main() { let list: Vec<i32> = vec![1, 2, 3, 4, 5]; for x in list
Rust 中的迭代器（Iterator）详解
m0_62599305的博客
05-21 524
Rust 中的迭代器（Iterator）详解
rust 迭代器
个人博客，记录了本人学习的各种有趣的技术。
10-15 595
它使用闭包作为参数，该闭包的参数 s 是来自迭代器中的值，然后使用 s 跟外部环境中的 shoe_size 进行比较，若相等，则在迭代器中保留 s 值，若不相等，则从迭代器中剔除 s 值，最终通过 collect 收集为 Vec 类型。之前的内容我们一直基于数组来创建迭代器，实际上，不仅仅是数组，基于其它集合类型一样可以创建迭代器，例如 HashMap。消费者是迭代器上的方法，它会消费掉迭代器中的元素，然后返回其类型的值，这些消费者都有一个共同的特点：在它们的定义中，都依赖 next 方法来消费元素.
Rust 学习笔记：循环和迭代器的性能比较
ProgramNovice的博客
05-28 894
Rust 学习笔记：循环和迭代器的性能比较
Rust中的循环结构与迭代器详解
# 1. 简介 ## 1.1 Rust编程语言概述 Rust是一种系统级编程语言，注重安全性和并发性。它的设计着重于内存安全、...接下来，我们将深入探讨Rust中循环结构与迭代器的用法和实际应用。 # 2. 循环结构 循环结构在编
Rust 语言的 for 循环用法
程序猿视角
03-11 1818
在 Rust 中，for循环是一种用于迭代集合（如数组、切片、向量、字符串、映射、通道等）或其他可迭代对象的方式。Rust 的for循环语法相对直观，并且与许多其他编程语言中的for循环类似。以下是for。
7、探索 Rust 迭代器：从显式循环到迭代器转换
ee345的博客
08-17 43
本文深入探讨了 Rust 中的迭代器转换，详细介绍了从显式循环到迭代器的演变过程及其优势。文章涵盖了迭代器的基本特征、常见转换方法、消费者操作以及在实际编程中的应用场景。通过逐步演示如何将显式循环转换为迭代器转换，展示了迭代器在代码简洁性、性能优化和可读性提升方面的显著优势。同时，文章还提供了使用迭代器时需要注意的所有权、性能开销和类型推断等关键点，并展望了迭代器在未来的发展潜力。
Rust 练习册 63：循环缓冲区与数据结构实现
少湖说
11-20 645
本文介绍了循环缓冲区（Circular Buffer）的实现方法，这是一种固定大小的先进先出数据结构。文章详细讲解了其核心特性：固定内存占用、O(1)时间复杂度的读写操作，以及避免频繁内存分配的优势。通过Rust代码示例展示了如何实现循环缓冲区的基本功能，包括初始化、写入、读取、清空和覆盖操作。实现使用了Vec<Option<T>>存储元素，并通过索引追踪读写位置，当缓冲区满时会覆盖最旧数据。该数据结构在需要高效内存管理和连续数据处理的场景中非常实用。
RustFS：大模型时代的数据基石——千卡训练集群的存储解决方案
分布式存储与RustFS的博客
11-20 1089
2025年AI大模型训练面临存储瓶颈问题，RustFS存储系统成为关键解决方案。该系统通过内存安全设计、元数据分离架构和智能数据分片技术，在千卡GPU集群中实现4K随机读1,580KIOPS（比MinIO快42%），显著提升训练效率。RustFS的优化包括检查点存储、数据预热策略、RDMA网络支持和多级缓存体系，使GPU利用率从55%提升至92%，训练时间缩短30%。该系统兼容S3协议，支持Kubernetes部署，提供完整的监控运维体系，并计划进一步实现存储感知训练优化，成为大模型时代的关键基础设施。
Rust 练习册 56：阿姆斯特朗数与数学算法探索
少湖说
11-20 1499
本文介绍了阿姆斯特朗数的概念及其在Rust中的实现方法。阿姆斯特朗数是指一个n位数，其各位数字的n次幂之和等于该数本身。文章分析了两种主要实现方式：基于字符串转换的简洁实现和纯数学运算方法，并比较了它们的性能特点。此外，还探讨了边界情况处理、函数式编程风格的应用以及阿姆斯特朗数的数学特性。这种数字在算法教学中常作为典型例子，用于练习循环和数学运算。
Rust高性能Web后端服务开发与Actix-Web实战分享：零成本抽象、高并发处理与内存安全实践
最新发布
2501_94181083的博客
11-23 593
数据序列化使用bincode替代 JSON：节省 30% CPU对热点代码进行#[inline]展开Netty 式 Reactor 模型减少线程调度开销批量 DB 提交减少 IO 压力缓存热点业务路径到 Redis最终整个平台达成：单机 QPS：18 万P99 延迟 < 30msCPU 占用在可控范围内资源释放完全可预期，无内存泄漏风险高性能，无 GC 停顿编译期保证内存安全，避免线上事故Actix-Web 性能强劲，适合高并发系统适合对性能和稳定性要求极高的互联网生产环境。
使用chirp内网穿透工具联合rustdesk 实现远程操作安卓手机
a942242856的博客
11-21 571
本文介绍如何利用Chirp内网穿透工具配合RustDesk实现远程控制安卓手机。首先需要下载RustDesk安卓版和Chirp安卓版，并进行自启动和后台运行设置。在RustDesk中开启IP直连功能并启动服务，然后在Chirp中添加隧道映射，将RustDesk的内网IP和端口映射到远程端口。最后通过电脑端RustDesk输入远程IP和端口即可连接手机。文章还提示了可能出现的连接问题及解决方法，强调需要确保两个应用的后台运行权限。该方法无需自建服务器，简单易行。
Rust 练习册 65：考拉兹猜想与数学算法实现
少湖说
11-21 693
本文探讨了著名的考拉兹猜想（Collatz Conjecture），该猜想由德国数学家洛塔尔·考拉兹于1937年提出。文章详细介绍了该猜想的规则（偶数除2，奇数乘3加1）及其数学特性，并提供了多种Rust实现方案，包括迭代、递归和优化版本。重点分析了算法实现中的边界情况处理（如输入为0时返回None）、性能优化技巧（如记忆化、位运算）以及错误处理机制（防止整数溢出）。通过测试用例验证了不同实现的正确性，展示了从基础到高级的编程实践，帮助开发者掌握数值处理和算法优化的关键技能。
Rust在Web开发框架中的性能
2509_93937153的博客
11-23 299
另外Rust的并发模型也帮了大忙，它的async/await语法糖背后是Future轮询，配合多线程运行时能把CPU核心吃满，不像Python的GIL那样卡脖子。我测试时用wrk压测一个简单的JSON API，Rust版本在4核虚拟机上一秒能处理快8万请求，而同配置下Go的gin框架顶多跑到5万，Node.js的Express更是卡在2万出头。最近还有个叫axio的新框架，连中间件都用静态分派实现，性能直逼C++的drogon，实测延迟波动范围能控制在0.1毫秒内，这对金融级应用来说简直是刚需。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值