Vector 如何以函数的方式将字符串向量转换为整数向量？

我正在尝试将

Vec

转换为

Vec

，但我想不出一种实用的方法来实现

let foo: &str = "1,2,3"; // Parsing a string here
let bar: Vec<&str> = foo.split(",").collect(); // Bar is a nice vector of &str's

let foo:&str=“1,2,3”//在这里解析字符串
let bar:Vec=foo.split（“，”）.collect（）；//Bar是&str的一个很好的向量

---

我需要将

bar

放入

Vec

有一个迭代器适配器！您可以这样使用它：

let bar: Vec<u16> = foo.split(",").map(|x| x.parse::<u16>().unwrap()).collect();

let bar:Vec=foo.split（“，”）.map（|x | x.parse:：（）.unwrap（））.collect（）；

是一个依赖于trait的库函数，它可能返回错误，因此我们需要

unwrap（）

错误类型。（对于一个简短的示例来说，这是一个好主意，但在实际代码中，您需要正确处理错误-如果您的值不是

u16

，您的程序将崩溃）

---

map

接受一个闭包，该闭包按值获取其参数，然后返回通过延迟应用该函数获得的迭代器。您将在此处解析所有值，但如果只解析其中的一个，则只解析其中的5个字符串。

您尚未完全指定您的问题。具体来说，当其中一个字符串无法解析为数字时会发生什么情况？使用解析字符串中的数字时，可能会失败。这就是函数返回

结果的原因：

fn parse<F>(&self) -> Result<F, F::Err>
where
    F: FromStr,

或者，您可以通过过滤掉
Err
值来删除失败的转换，方法是：

fn main（）{
让输入=“1,2,3”；
let strings:Vec=input.split（“，”）.collect（）；
让数字：Vec=strings.iter（）.flat|u映射（|x | x.parse（））.collect（）；
println！（“{：？}”，数字）；
}

当然，将字符串转换为字符串向量，然后再将其转换为整数向量有点愚蠢。如果您实际上有一个逗号分隔的字符串，并且想要数字，请一次性完成：

fn main() {
    let input = "1,2,3";

    let numbers: Result<Vec<u16>, _> = input.split(",").map(|x| x.parse()).collect();

    println!("{:?}", numbers);
}

fn main（）{
让输入=“1,2,3”；
让数字：Result=input.split（“，”）.map（|x | x.parse（））.collect（）；
println！（“{：？}”，数字）；
}

另见：



我认为自己还没有真正经历过锈蚀

fn main() {
    let foo: &str = "1,2,3"; // Parsing a string here
    let bar: Vec<&str> = foo.split(",").collect(); // Bar is a nice vector of &str's

    // here the magic happens
    let baz = bar.iter().map(|x| x.parse::<i64>());

    for x in baz {
        match x {
            Ok(i) => println!("{}", i),
            Err(_) => println!("parse failed"),
        }
    }
}

fn main（）{
让foo:&str=“1,2,3”//在这里解析字符串
let-bar:Vec=foo.split（“，”）.collect（）；//bar是&str的一个很好的向量
//奇迹就在这里发生了
设baz=bar.iter（）.map（|x | x.parse:：（））；
对于baz中的x{
匹配x{
Ok（i）=>println！（“{}”，i），
Err（）=>println！（“分析失败”），
}
}
}

请注意，由于
parse
返回
结果
，因此必须从每个解析的元素中提取值。您可能希望以不同的方式进行操作，例如仅过滤成功的结果

fn main() {
    let input = "1,2,3";

    let numbers: Result<Vec<u16>, _> = input.split(",").map(|x| x.parse()).collect();

    println!("{:?}", numbers);
}

fn main() {
    let foo: &str = "1,2,3"; // Parsing a string here
    let bar: Vec<&str> = foo.split(",").collect(); // Bar is a nice vector of &str's

    // here the magic happens
    let baz = bar.iter().map(|x| x.parse::<i64>());

    for x in baz {
        match x {
            Ok(i) => println!("{}", i),
            Err(_) => println!("parse failed"),
        }
    }
}