Input 如何在Rust 1.0中读取用户输入的整数？

我找到的现有答案都是基于_str（例如）的

，但显然

来自_str（x）的

在Rust 1.0中已更改为
x.parse（）
。作为一个新手，考虑到这一变化，如何调整原始解决方案并不明显

从Rust 1.0开始，从用户处获取整数输入的最简单方法是什么
 最简单的部分可能是使用和编写：

#[macro_use]
extern crate text_io;

fn main() {
    // read until a whitespace and try to convert what was read into an i32
    let i: i32 = read!();
    println!("Read in: {}", i);
}

如果需要同时读取多个值，则可能需要每晚使用Rust

另见：



解析
大致相同；现在不舒服的是
read\u line

use std::io;

fn main() {
    let mut s = String::new();
    io::stdin().read_line(&mut s).unwrap();

    match s.trim_right().parse::<i32>() {
        Ok(i) => println!("{} + 5 = {}", i, i + 5),
        Err(_) => println!("Invalid number."),
    }
}

使用std:：io；
fn main（）{
让mut s=String:：new（）；
io:：stdin（）。读取行（&mut s）。展开（）；
匹配s.trim_right（）。解析：：（）{
Ok（i）=>println！（“{}+5={}”，i，i+5），
Err（）=>println！（“无效数字”），
}
}
这是一个包含所有可选类型注释和错误处理的版本，对于像我这样的初学者可能很有用：

use std::io;

fn main() {
    let mut input_text = String::new();
    io::stdin()
        .read_line(&mut input_text)
        .expect("failed to read from stdin");

    let trimmed = input_text.trim();
    match trimmed.parse::<u32>() {
        Ok(i) => println!("your integer input: {}", i),
        Err(..) => println!("this was not an integer: {}", trimmed),
    };
}

使用std:：io；
fn main（）{
让mut输入_text=String:：new（）；
io:：stdin（）
.read_行（&mut输入_文本）
.expect（“未能读取标准数据”）；
let trimmed=输入_text.trim（）；
匹配修剪。解析：：（）{
Ok（i）=>println！（“您的整数输入：{}”，i），
Err（..）=>println！（“这不是一个整数：{}”，已修剪），
};
}
以下是一些可能性（Rust 1.7）：

使用std:：io；
fn main（）{
让mut n=String:：new（）；
io:：stdin（）
.读取行（&M n）
.expect（“读取输入失败”）；
设n:i32=n.trim（）.parse（）.expect（“无效输入”）；
println！（“{：？}”，n）；
让mut n=String:：new（）；
io:：stdin（）
.读取行（&M n）
.expect（“读取输入失败”）；
让n=n.trim（）.parse:：（）.expect（“无效输入”）；
println！（“{：？}”，n）；
让mut n=String:：new（）；
io:：stdin（）
.读取行（&M n）
.expect（“读取输入失败”）；
如果让Ok（n）=n.trim（）.parse:：（）{
println！（“{：？}”，n）；
}
}

这样就不用再依赖额外的库来进行模式匹配了
 如果您正在寻找一种方法来读取输入，以便在codeforces等网站上进行竞争性编程，而您无法访问
text\u io
，则此解决方案适合您

我使用以下宏从
stdin
读取不同的值：

使用std:：io；
#[允许（未使用的_宏）]
宏规则！阅读{
（$out:ident as$type:ty）=>{
让mut-inner=String:：new（）；
io:：stdin（）.read_line（&mut-inner）.expect（“字符串”）；
let$out=inner.trim（）.parse:：（）.expect（“可解析”）；
};
}
#[允许（未使用的_宏）]
宏规则！雷丁街{
（$out:ident）=>{
让mut-inner=String:：new（）；
io:：stdin（）.read_line（&mut-inner）.expect（“字符串”）；
let$out=internal.trim（）；
};
}
#[允许（未使用的_宏）]
宏规则！阅读{
（$out:ident as$type:ty）=>{
让mut-inner=String:：new（）；
io:：stdin（）。读取行（&mut-inner）。展开（）；
释放$out=内部
.trim（）
.split_空格（）
.map（|s | s.parse:：（）.unwrap（））
收集：：（）；
};
}

使用它如下


fn main（）{
读取！（x为u32）；
读取！（y为f64）；
读！（z为字符）；
println！（“{}{}{}”，x，y，z）；
read_vec！（v as u32）；//读取以空格分隔的整数，并在遇到换行符时停止。
println！（“{：？}”，v）；
}
如果需要简单的语法，可以创建扩展方法：

use std::error::Error;
use std::io;
use std::str::FromStr;

trait Input {
    fn my_read<T>(&mut self) -> io::Result<T>
    where
        T: FromStr,
        T::Err: Error + Send + Sync + 'static;
}

impl<R> Input for R where R: io::Read {
    fn my_read<T>(&mut self) -> io::Result<T>
    where
        T: FromStr,
        T::Err: Error + Send + Sync + 'static,
    {
        let mut buff = String::new();
        self.read_to_string(&mut buff)?;

        buff.trim()
            .parse()
            .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))
    }
}

// Usage:

fn main() -> io::Result<()> {
    let input: i32 = io::stdin().my_read()?;

    println!("{}", input);

    Ok(())
}

使用std:：error:：error；
使用std：：io；
使用std:：str:：FromStr；
特征输入{
fn my_read（&mut self）->io:：Result
哪里
T:FromStr，
错误：错误+发送+同步+静态；
}
R的impl输入，其中R:io:：读取{
fn my_read（&mut self）->io:：Result
哪里
T:FromStr，
错误：错误+发送+同步+静态，
{
让mut buff=String:：new（）；
self.read_to_字符串（&mut buff）？；
buff.trim（）
.parse（）
.map_err（| e | io:：Error:：new（io:：ErrorKind:：InvalidInput，e））
}
}
//用法：
fn main（）->io:：Result{
让输入：i32=io:：stdin（）.my_read（）？；
println！（“{}”，输入）；
好（（））
}
我肯定会使用Rust Lang提供的文件系统
std:：fs
（请参阅此处的更多内容：），但更具体

假设您只想读取文本文件的输入，请尝试以下操作：

use std::fs
or
use std::fs::read_to_string

fn main() {
    println!("{}", fs::read_to_string("input.txt"));   
}

如果一次只需要读取一个值，我认为它确实可以在稳定的环境下运行。
text\u io
dev here@Vladimitmaveev是对的，
text\u io
如果不读取元组，而只读取每个
read的一个值，则在稳定状态下运行！（）
调用。事实上，它需要每晚输入多个值。我将更新github描述。现在有更好的选择吗？经过3年的锈蚀，我认为会有更好的方法将值输入整数变量。建议的解决方案是我在《铁锈书》中遇到的，但它很长，而且输入有点过份。
text\u io
建议很棒，但在使用
read之前，我无法从函数中打印语句！（）
@joe_04_04“在使用
read！（）
之前从函数中打印语句”是什么意思？@DanielFath，如果我在尝试使用
read！（）
之前使用
println！（）
从
text_io
打印，则应该从
println！（）
打印的项目在
read之后才会打印出来（）
method。算了吧，这显然不同，完整的答案让读者更容易理解。我觉得它看起来很像。是的，你必须从用户那里得到一个字符串并将其存储在变量中，这部分是相同的。解析部分更简洁，正如我的答案中所解释的。解析部分更简洁-a
use std::fs
or
use std::fs::read_to_string

fn main() {
    println!("{}", fs::read_to_string("input.txt"));   
}