Rust 以其强大的所有权系统、借用检查器和零成本抽象闻名，而 迭代（Iteration） 作为 Rust 中常见的数据处理方式，不仅影响代码的可读性和安全性，还直接关系到性能。Rust 提供了多种迭代方式，每种方式都有其特定的应用场景、实现原理、优势及局限性。

在这篇文章中，我们将从 Rust for 循环的迭代方式 出发，结合 不同的迭代器方法（iter()、iter_mut()、into_iter()），进行全面的解析，帮助你在实际开发中选择最佳的迭代方式。

1. for 循环的迭代方式

Rust 的 for 语法实际上是一个 语法糖，它背后会调用 IntoIterator trait 的 into_iter() 方法。因此，for 循环的行为取决于被遍历的变量的类型。

1.1 for 默认使用 IntoIterator::into_iter()

Rust 的 for 循环实际上等价于：

let collection = vec![1, 2, 3, 4];
for item in collection {
    println!("{}", item);
}

// 等价于：
let mut iter = collection.into_iter();
while let Some(item) = iter.next() {
    println!("{}", item);
}

• for 默认会调用 IntoIterator::into_iter()，但 IntoIterator 的实现 因数据类型不同而不同，因此 for 的行为也有所不同。

1.2 for 在不同数据类型上的行为

• 迭代 Vec<T> 本身 → into_iter()，会消耗 Vec，无法再次访问。
• 迭代 &Vec<T>（不可变引用） → iter()，不会消耗 Vec，适用于只读场景。
• 迭代 &mut Vec<T>（可变引用） → iter_mut()，允许修改元素。
• 数组 [T; N] → 默认 iter()，返回不可变引用，不会移动数据。

示例：

let vec = vec![1, 2, 3];

// 所有权转移
for x in vec { 
    println!("{}", x);
} 
// println!("{:?}", vec); // ❌ vec 被移动，不能再访问

let vec = vec![1, 2, 3];
// 仅借用，不移动数据
for x in &vec { 
    println!("{}", x);
} 
println!("{:?}", vec); // ✅ vec 仍可访问

2. Rust 迭代方式的实现原理、优势与局限性

2.1 iter() - 不可变借用迭代器

实现原理

• iter() 方法返回 不可变借用 (&T) 迭代器，允许遍历但不修改数据。
• 实现于 IntoIterator trait，for x in &vec 会默认调用 iter()。

let vec = vec![1, 2, 3];
for x in vec.iter() {  // 等价于 `for x in &vec`
    println!("{}", x);
}

优势

✅ 避免所有权转移：不影响原始数据，可重复使用。
✅ 高效：适用于只读遍历，无需移动数据。

局限性

❌ 不能修改数据：仅提供不可变引用。

适用场景

• 仅遍历数据，不修改。
• 不希望数据被移动，例如多次迭代。

2.2 iter_mut() - 可变借用迭代器

实现原理

• iter_mut() 方法返回 可变借用 (&mut T) 迭代器，允许在遍历过程中修改元素。
• for x in &mut vec 默认调用 iter_mut()。

let mut vec = vec![1, 2, 3];
for x in vec.iter_mut() {  // 等价于 `for x in &mut vec`
    *x *= 2; // 修改元素
}
println!("{:?}", vec); // [2, 4, 6]

优势

✅ 支持修改元素：可以在迭代过程中改变数据。
✅ 避免索引操作：更安全，不会产生数组越界问题。

局限性

❌ 不能获取所有权：仅能修改数据，无法移动元素。
❌ 必须使用 &mut：整个 Vec 被借用，不能同时用其他 &mut 变量操作它。

适用场景

• 需要修改数据，但不移动所有权。

2.3 into_iter() - 所有权转移迭代器

实现原理

• into_iter() 消耗容器，返回 T 类型迭代器，转移元素所有权。
• for x in vec 默认调用 into_iter()（对 Vec<T> 本身）。

let vec = vec![1, 2, 3];
for x in vec.into_iter() {  // 所有权转移
    println!("{}", x);
}
// println!("{:?}", vec); // ❌ vec 已被移动，不能再访问

优势

✅ 不需要拷贝数据：直接获取 T，避免拷贝。
✅ 适用于所有权转移：尤其是数据处理、计算等场景。

局限性

❌ 原容器不可用：数据被移动，无法再次访问原 Vec。
❌ 不适用于只读遍历：如果只想遍历数据，iter() 更合适。

适用场景

• 希望消耗数据，不再使用原容器。
• 需要移动数据到其他数据结构。

3. Rust 迭代方式对比与选择

最佳实践

• 只想遍历数据？ ✅ iter()
• 需要修改数据？ ✅ iter_mut()
• 要消耗数据并获取所有权？ ✅ into_iter()

4. 结论

Rust 提供的三种迭代方式适用于不同的应用场景：

• iter() 适用于 只读遍历，不会修改或消耗数据。
• iter_mut() 适用于 需要修改数据但不移动所有权。
• into_iter() 适用于 需要获取数据的所有权，不再使用原容器。

理解 for 循环的工作方式，结合 Rust 的迭代器特性，可以帮助我们编写 高效、安全且符合 Rust 设计哲学的代码。