将int转换为字符串向量

Question

我试图将长数字转换为字符串向量.例如,17562会成为["1", "7", "5", "6", "2"].我已经看到很多将int转换为字符串的例子,但没有将字符串向量转换为int.我想分别迭代每个数字.

这是我到目前为止所做的,但它不起作用.

fn main() {
    let x = 42;
    let values: Vec<&str> = x.to_string().split(|c: char| c.is_alphabetic()).collect();
    println!("{:?}", values);     
}

给我编译错误:

<anon>:3:29: 3:42 error: borrowed value does not live long enough
<anon>:3     let values: Vec<&str> = x.to_string().split(|c: char| c.is_alphabetic()).collect();

<anon>:3:88: 6:2 note: reference must be valid for the block suffix following statement 1 at 3:87...
<anon>:3     let values: Vec<&str> = x.to_string().split(|c: char| c.is_alphabetic()).collect();
<anon>:4     println!("{:?}", values);
<anon>:5     
<anon>:6 }
<anon>:3:5: 3:88 note: ...but borrowed value is only valid for the statement at 3:4
<anon>:3     let values: Vec<&str> = x.to_string().split(|c: char| c.is_alphabetic()).collect();

<anon>:3:5: 3:88 help: consider using a `let` binding to increase its lifetime
<anon>:3     let values: Vec<&str> = x.to_string().split(|c: char| c.is_alphabetic()).collect();

相当于我在python中尝试做的事情 x = 42; x = list(str(x)); print(x)

Answer 1

好的,第一个问题是你不存储x.to_string()任何地方的结果.因此,它将不再存在于表达式的末尾,这意味着values将尝试引用不再存在的值.因此错误.最简单的解决方案是将临时字符串存储在某处,以便它继续存在:

fn main() {
    let x = 42;
    let x_str = x.to_string();
    let values: Vec<&str> = x_str.split(|c: char| c.is_alphabetic()).collect();
    println!("{:?}", values);     
}

第二个问题:这个输出["42"]是因为你告诉它要拆分字母.你可能想要使用is_numeric:

fn main() {
    let x = 42;
    let x_str = x.to_string();
    let values: Vec<&str> = x_str.split(|c: char| c.is_numeric()).collect();
    println!("{:?}", values);     
}

第三个问题:这是输出["", "", ""],因为它们是数字字符之间的三个字符串.Split的参数是分隔符.因此,第三个问题是你开始使用完全错误的方法.

与您列出的Python代码最接近的直接等价物是:

fn main() {
    let x = 42;
    let values: Vec<String> = x.to_string().chars().map(|c| c.to_string()).collect();
    println!("{:?}", values);     
}

最后,它输出:["4", "2"].

但是,这非常低效:这需要整数,分配一个中间缓冲区,将整数打印到它,将其转换为字符串.它接受该字符串中的每个代码点,分配一个中间缓冲区,将代码点打印到它,将其转换为字符串.然后它将所有这些字符串收集到一个Vec,可能不止一次重新分配.

它有效,但有点浪费.如果你不关心浪费,你现在可以停止阅读.

通过收集代码点而不是字符串,您可以减少浪费:

fn main() {
    let x = 42;
    let values: Vec<char> = x.to_string().chars().collect();
    println!("{:?}", values);     
}

这输出:['4', '2'].请注意不同的引号,因为我们使用的是char代替String.

我们可以Vec通过预先分配其存储来从调整大小中删除中间分配,这为我们提供了以下版本:

fn main() {
    let x = 42u32; // no negatives!
    let values = {
        if x == 0 {
            vec!['0']
        } else {
            // pre-allocate Vec so there's no resizing
            let digits = 1 + (x as f64).log10() as u32;
            let mut cs = Vec::with_capacity(digits as usize);
            let mut div = 10u32.pow(digits - 1);
            while div > 0 {
                cs.push((b'0' + ((x / div) % 10) as u8) as char);
                div /= 10;
            }
            cs
        }
    };
    println!("{:?}", values);     
}

除非你在循环中这样做,否则我只会坚持正确,浪费的版本.