在 Rust 中多次使用同一个迭代器

编者注：此代码示例来自 1.0 之前的 Rust 版本，当时实现了许多迭代器Copy。此代码的更新版本会产生不同的错误，但答案仍然包含有价值的信息。

我正在尝试编写一个函数来将字符串拆分为字母和数字块；例如，"test123test"会变成[ "test", "123", "test" ]。到目前为止，这是我的尝试：

pub fn split(input: &str) -> Vec<String> {
    let mut bits: Vec<String> = vec![];
    let mut iter = input.chars().peekable();
    loop {
        match iter.peek() {
            None => return bits,
            Some(c) => if c.is_digit() {
                bits.push(iter.take_while(|c| c.is_digit()).collect());
            } else {
                bits.push(iter.take_while(|c| !c.is_digit()).collect());
            }
        }
    }
    return bits;
}

然而，这不起作用，永远循环。似乎它正在使用的克隆iter每次我打电话take_while，一遍又一遍地从同一个位置开始。我希望它使用相同的iter每次，在所有的迭代器上推进相同的迭代器each_times。这可能吗？

正如您所确定的，每个take_while呼叫重复iter, since take_while takes self和Peekable字符迭代器是Copy http://doc.rust-lang.org/master/std/kinds/trait.Copy.html. (仅在 Rust 1.0 之前正确 - 编辑器)

您希望每次都修改迭代器，即take_while操作于&mut到你的迭代器。这正是.by_ref https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.by_ref适配器用于：

pub fn split(input: &str) -> Vec<String> {
    let mut bits: Vec<String> = vec![];
    let mut iter = input.chars().peekable();
    loop {
        match iter.peek().map(|c| *c) {
            None => return bits,
            Some(c) => if c.is_digit(10) {
                bits.push(iter.by_ref().take_while(|c| c.is_digit(10)).collect());
            } else {
                bits.push(iter.by_ref().take_while(|c| !c.is_digit(10)).collect());
            },
        }
    }
}

fn main() {
    println!("{:?}", split("123abc456def"))
}

Prints

["123", "bc", "56", "ef"]

但是，我认为这是不正确的。

我实际上建议像平常一样写这个for循环，使用char_indices https://doc.rust-lang.org/std/primitive.str.html#method.char_indices迭代器：

pub fn split(input: &str) -> Vec<String> {
    let mut bits: Vec<String> = vec![];
    if input.is_empty() {
        return bits;
    }

    let mut is_digit = input.chars().next().unwrap().is_digit(10);
    let mut start = 0;

    for (i, c) in input.char_indices() {
        let this_is_digit = c.is_digit(10);
        if is_digit != this_is_digit {
            bits.push(input[start..i].to_string());
            is_digit = this_is_digit;
            start = i;
        }
    }

    bits.push(input[start..].to_string());
    bits
}

这种形式还允许用更少的分配来做到这一点（即，Strings 不是必需的），因为每个返回值只是input，我们可以用生命周期来说明这一点：

pub fn split<'a>(input: &'a str) -> Vec<&'a str> {
    let mut bits = vec![];
    if input.is_empty() {
        return bits;
    }

    let mut is_digit = input.chars().next().unwrap().is_digit(10);
    let mut start = 0;

    for (i, c) in input.char_indices() {
        let this_is_digit = c.is_digit(10);
        if is_digit != this_is_digit {
            bits.push(&input[start..i]);
            is_digit = this_is_digit;
            start = i;
        }
    }

    bits.push(&input[start..]);
    bits
}

所有改变的是类型签名，删除了Vec<String>类型提示和.to_string calls.

人们甚至可以编写这样的迭代器，以避免分配Vec。就像是fn split<'a>(input: &'a str) -> Splits<'a> { /* construct a Splits */ } where Splits是一个实现的结构体Iterator<&'a str>.