Trait std::iter::IntoIterator1.0.0[−][src]

pub trait IntoIterator {
    type Item;
    type IntoIter: Iterator;
    fn into_iter(self) -> Self::IntoIter;
}
Expand description

转换为 Iterator。

通过为类型实现 IntoIterator，可以定义如何将其转换为迭代器。 这对于描述某种集合的类型很常见。

实现 IntoIterator 的好处之一是您的类型将为 work with Rust’s for loop syntax。

也可以看看: FromIterator.

Examples

基本用法:

let v = vec![1, 2, 3];
let mut iter = v.into_iter();

assert_eq!(Some(1), iter.next());
assert_eq!(Some(2), iter.next());
assert_eq!(Some(3), iter.next());
assert_eq!(None, iter.next());
Run

为您的类型实现 IntoIterator:

// 一个样本集合，这只是 Vec<T> 的包装
#[derive(Debug)]
struct MyCollection(Vec<i32>);

// 让我们给它一些方法，以便我们可以创建一个方法并向其中添加一些东西。
impl MyCollection {
    fn new() -> MyCollection {
        MyCollection(Vec::new())
    }

    fn add(&mut self, elem: i32) {
        self.0.push(elem);
    }
}

// 我们将实现 IntoIterator
impl IntoIterator for MyCollection {
    type Item = i32;
    type IntoIter = std::vec::IntoIter<Self::Item>;

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

// 现在我们可以进行一个新的集合了...
let mut c = MyCollection::new();

// ... 添加一些东西 ...
c.add(0);
c.add(1);
c.add(2);

// ... 然后将其转换为迭代器:
for (i, n) in c.into_iter().enumerate() {
    assert_eq!(i as i32, n);
}
Run

通常将 IntoIterator 用作 trait bound。只要它仍然是迭代器，就可以更改输入集合类型。 可以通过限制限制来指定其他范围 Item:

fn collect_as_strings<T>(collection: T) -> Vec<String>
where
    T: IntoIterator,
    T::Item: std::fmt::Debug,
{
    collection
        .into_iter()
        .map(|item| format!("{:?}", item))
        .collect()
}
Run

Associated Types

被迭代的元素的类型。

我们将其变成哪种迭代器?

Required methods

从一个值创建一个迭代器。

有关更多信息，请参见 module-level documentation。

Examples

基本用法:

let v = vec![1, 2, 3];
let mut iter = v.into_iter();

assert_eq!(Some(1), iter.next());
assert_eq!(Some(2), iter.next());
assert_eq!(Some(3), iter.next());
assert_eq!(None, iter.next());
Run

Implementors

This is supported on Unix only.

创建一个消耗迭代器，即一个将任意键值对以任意顺序移出 map 的迭代器。 调用后不能使用 map。

Examples

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

// .iter() 无法使用
let vec: Vec<(&str, i32)> = map.into_iter().collect();
Run

返回可能包含的值上的消耗迭代器。

Examples

let x = Some("string");
let v: Vec<&str> = x.into_iter().collect();
assert_eq!(v, ["string"]);

let x = None;
let v: Vec<&str> = x.into_iter().collect();
assert!(v.is_empty());
Run

获取用于移出 BTreeSet 内容的迭代器。

Examples

use std::collections::BTreeSet;

let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect();

let v: Vec<_> = set.into_iter().collect();
assert_eq!(v, [1, 2, 3, 4]);
Run

创建一个消耗迭代器，即一个将任意值以任意顺序移出二进制堆的迭代器。 调用此后不能使用二进制堆。

Examples

基本用法:

use std::collections::BinaryHeap;
let heap = BinaryHeap::from(vec![1, 2, 3, 4]);

// 以任意顺序打印 1，2，3，4
for x in heap.into_iter() {
    // x 的类型为 i32，不是 &i32
    println!("{}", x);
}
Run

将列表消耗到迭代器中，该迭代器按值产生元素。

将 VecDeque 消费为从前到后的迭代器，按值产生元素。

创建一个消耗迭代器，即一个将每个值移出 vector (从开始到结束) 的迭代器。 调用此后不能使用 vector。

Examples

let v = vec!["a".to_string(), "b".to_string()];
for s in v.into_iter() {
    // s 具有字符串类型，而不是 &String
    println!("{}", s);
}
Run

返回可能包含的值上的消耗迭代器。

如果结果为 Result::Ok，则迭代器将产生一个值，否则将不产生任何值。

Examples

基本用法:

let x: Result<u32, &str> = Ok(5);
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, [5]);

let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);
Run

创建一个消耗迭代器，即将每个值以任意顺序移出集合的迭代器。 调用此设置后将无法使用该设置。

Examples

use std::collections::HashSet;
let mut set = HashSet::new();
set.insert("a".to_string());
set.insert("b".to_string());

// 不能与常规 `.iter()` 一起收集到 Vec<String>。
let v: Vec<String> = set.into_iter().collect();

// 将以任意顺序打印。
for x in &v {
    println!("{}", x);
}
Run

创建一个消费迭代器，即将每个值移出数组 (从开始到结束)。 除非 T 实现了 Copy，否则调用此数组后不能使用数组，因此整个数组都会被复制。

在调用 .into_iter() 之前，数组具有特殊行为 2021 版 – 有关更多信息，请参见 array 版本部分。