Rust iter 和 into_iter 有什么区别

发布于01月12日

我正在做Rust by Example教程，其中包含以下代码片段:

// Vec example
let vec1 = vec![1, 2, 3];
let vec2 = vec![4, 5, 6];

// `iter()` for vecs yields `&i32`. Destructure to `i32`.
println!("2 in vec1: {}", vec1.iter()     .any(|&x| x == 2));
// `into_iter()` for vecs yields `i32`. No destructuring required.
println!("2 in vec2: {}", vec2.into_iter().any(| x| x == 2));

// Array example
let array1 = [1, 2, 3];
let array2 = [4, 5, 6];

// `iter()` for arrays yields `&i32`.
println!("2 in array1: {}", array1.iter()     .any(|&x| x == 2));
// `into_iter()` for arrays unusually yields `&i32`.
println!("2 in array2: {}", array2.into_iter().any(|&x| x == 2));

我完全搞糊涂了——对于Vec，从iter返回的迭代器产生引用，从into_iter返回的迭代器产生值，但是对于数组，这些迭代器是相同的吗？

这两种方法的用例/API是什么？

推荐答案

TL;DR:

根据上下文，由into_iter返回的迭代器可能会产生T、&T或&mut T中的任何一个.
按照惯例，由iter返回的迭代器将产生&T.
按照惯例，由iter_mut返回的迭代器将产生&mut T.

第一个问题是:"什么是into_iter？"

into_iter来自IntoIterator trait:

pub trait IntoIterator 
where
    <Self::IntoIter as Iterator>::Item == Self::Item, 
{
    type Item;
    type IntoIter: Iterator;
    fn into_iter(self) -> Self::IntoIter;
}

当您想要指定如何将特定类型转换为迭代器时，就可以实现这个特性.最值得注意的是，如果一个类型实现了IntoIterator，那么它可以在for循环中使用.

例如，Vec实现了IntoIterator...三次！

impl<T> IntoIterator for Vec<T>
impl<'a, T> IntoIterator for &'a Vec<T>
impl<'a, T> IntoIterator for &'a mut Vec<T>

每种变体略有不同.

这个函数消耗Vec及其迭代器yields values(直接消耗T):

impl<T> IntoIterator for Vec<T> {
    type Item = T;
    type IntoIter = IntoIter<T>;

    fn into_iter(mut self) -> IntoIter<T> { /* ... */ }
}

另外两个通过引用获取向量(不要被into_iter(self)的签名欺骗，因为self在这两种情况下都是引用)，它们的迭代器将生成对Vec中元素的引用.

这个yields immutable references:

impl<'a, T> IntoIterator for &'a Vec<T> {
    type Item = &'a T;
    type IntoIter = slice::Iter<'a, T>;

    fn into_iter(self) -> slice::Iter<'a, T> { /* ... */ }
}

而这个yields mutable references:

impl<'a, T> IntoIterator for &'a mut Vec<T> {
    type Item = &'a mut T;
    type IntoIter = slice::IterMut<'a, T>;

    fn into_iter(self) -> slice::IterMut<'a, T> { /* ... */ }
}

所以: