牛逼，多谢大佬

--
👇
苦瓜小仔: 如果你能保证你的数据满足一些限制，那么可以自己手写，比如这个例子保证：

以 e 作为指数幂的符号；

e 前后的数据类型完全固定：e 前的数据为整数，e 后的数据为非负整数。

fn main() {
    assert_eq!(parse_i32("1e3"), Some(1000));
    assert_eq!(parse_i32("10e3"), Some(10000));
    assert_eq!(parse_i32("-10e3"), Some(-10000));
    assert_eq!(parse_i32("-10e-3"), None);

    assert_eq!(parse_i32("1e3"), Some(1000));
    assert_eq!(parse_u32("10e3"), Some(10000));
    assert_eq!(parse_u32("-10e3"), None);
}

fn parse_i32(s: impl AsRef<str>) -> Option<i32> {
    let s = s.as_ref();
    let pos = s.find("e")?;
    let i: i32 = unsafe { s.get_unchecked(..pos) }.parse().ok()?;
    let e: u32 = unsafe { s.get_unchecked(pos + 1..) }.parse().ok()?;
    Some(i * 10i32.pow(e))
}

fn parse_u32(s: impl AsRef<str>) -> Option<u32> {
    let s = s.as_ref();
    let pos = s.find("e")?;
    let i: u32 = unsafe { s.get_unchecked(..pos) }.parse().ok()?;
    let e: u32 = unsafe { s.get_unchecked(pos + 1..) }.parse().ok()?;
    Some(i * 10u32.pow(e))
}

如果不能满足第一条保证，那么很容易修改。如果你的数据来源遵照一些规范，使用 lexical 更省事。

如果不能满足第二条，那么科学记数法使用浮点数解析是很正常的：

以 i32 为例，它的 pow 签名：pub const fn pow(self, exp: u32) -> i32 规定以 u32 类型为幂，这很容易理解，因为整数的负数幂或者浮点数幂会导致浮点类型。

而 f64 的 pow 签名为 pub fn powi(self, n: i32) -> f64 和 pub fn powf(self, n: f64) -> f64 ，其计算结果可以使用 as 转化成整数。

如果你能保证你的数据满足一些限制，那么可以自己手写，比如这个例子保证：

以 e 作为指数幂的符号；

e 前后的数据类型完全固定：e 前的数据为整数，e 后的数据为非负整数。

fn main() {
    assert_eq!(parse_i32("1e3"), Some(1000));
    assert_eq!(parse_i32("10e3"), Some(10000));
    assert_eq!(parse_i32("-10e3"), Some(-10000));
    assert_eq!(parse_i32("-10e-3"), None);

    assert_eq!(parse_i32("1e3"), Some(1000));
    assert_eq!(parse_u32("10e3"), Some(10000));
    assert_eq!(parse_u32("-10e3"), None);
}

fn parse_i32(s: impl AsRef<str>) -> Option<i32> {
    let s = s.as_ref();
    let pos = s.find("e")?;
    let i: i32 = unsafe { s.get_unchecked(..pos) }.parse().ok()?;
    let e: u32 = unsafe { s.get_unchecked(pos + 1..) }.parse().ok()?;
    Some(i * 10i32.pow(e))
}

fn parse_u32(s: impl AsRef<str>) -> Option<u32> {
    let s = s.as_ref();
    let pos = s.find("e")?;
    let i: u32 = unsafe { s.get_unchecked(..pos) }.parse().ok()?;
    let e: u32 = unsafe { s.get_unchecked(pos + 1..) }.parse().ok()?;
    Some(i * 10u32.pow(e))
}

如果不能满足第一条保证，那么很容易修改。如果你的数据来源遵照一些规范，使用 lexical 更省事。

如果不能满足第二条，那么科学记数法使用浮点数解析是很正常的：

以 i32 为例，它的 pow 签名：pub const fn pow(self, exp: u32) -> i32 规定以 u32 类型为幂，这很容易理解，因为整数的负数幂或者浮点数幂会导致浮点类型。

而 f64 的 pow 签名为 pub fn powi(self, n: i32) -> f64 和 pub fn powf(self, n: f64) -> f64 ，其计算结果可以使用 as 转化成整数。

这个库好像只能从string转成float

--
👇
苦瓜小仔: https://docs.rs/lexical/latest/lexical/

let i: f64 ="1.3e5".parse().expect("not a floating point number");

直接转成浮点型可以，不能直接转成整型

fn main() {
    let s = "10e3".to_string();
    let i = s.parse::<f64>();
    println!("{:?}",i);//Ok(10000.0)
    let i = s.parse::<i32>();
    println!("{:?}",i);//Err(ParseIntError { kind: InvalidDigit })
}

https://docs.rs/lexical/latest/lexical/

--
👇
formoon: 不需要外部库

fn main(){
    let a=1e3;
    println!("a={}",&a);
}

输出：
a=1000

这里a应该是i32吧？，a要是string类型的，怎么把他转换成i32呢？

不需要外部库

fn main(){
    let a=1e3;
    println!("a={}",&a);
}

输出：
a=1000