Rust-IO-Toy模板网

这篇具有很好参考价值的文章主要介绍了Rust-IO。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

In Rust, input and output (I/O) operations are mainly handled through the std::io module, which provides a number of important functionalities for performing I/O operations. Here’s a quick overview of some of the key features provided by std::io.

Read and Write Traits

Two of the most important traits for I/O operations in Rust are Read and Write. These traits provide methods that allow bytes to be read from and written to streams respectively.

For example, any type that implements the Read trait will provide a method read(&mut self, buf: &mut [u8]) -> Result<usize>, which reads data into buf and returns the number of bytes read. Similarity, any type that implements the Write trait provides a method write(&mut self, buf: &[u8]) -> Result<usize>, which writes the bytes from buf and returns the number of bytes written.

Standard Input and Output

The std::io module also provides functionality for interacting with the standard input (stdin), standard output (stdout), and standard error (stderr) streams. For example:

use std::io::{self, Write};

fn main() -> io::Result<()> {
    let mut input = String::new();
    io::stdin().read_line(&mut input)?;

    io::stdout().write_all(input.as_bytes())?;

    Ok(())
}

In this example, read_line is called on the standard input to read a line from the user, and then write_all is called on the standard output to write this line out.

Files

The File struct represents a file on the filesystem and it implements both the Read and Write traits, so you can perform I/O operations on files. Here’s an example:

use std::fs::File;
use std::io::prelude::*;

fn main() -> std::io::Result<()> {
    let mut file = File::open("foo.txt")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;

    let mut file = File::create("bar.txt")?;
    file.write_all(contents.as_bytes())?;

    Ok(())
}

In this example, the file foo.txt is opened and read into a string. Then, a new file bar.txt is created, and the contents of the string are written into it.

Buffered I/O

The std::io module provides BufReader and BufWriter structs for buffered I/O operations. These wrap readers and writers and buffer their input and output, which can improve performance for certain types of I/O operations.

use std::io::BufReader;
use std::io::prelude::*;
use std::fs::File;

fn main() -> std::io::Result<()> {
    let file = File::open("foo.txt")?;
    let mut buf_reader = BufReader::new(file);
    let mut contents = String::new();
    buf_reader.read_to_string(&mut contents)?;

    println!("{}", contents);
    Ok(())
}

In this example, a BufReader is created from a File. This BufReader can then be used to read from the file more efficiently.

Errors

Most operations in std::io return the Result type, which represents either a successful result (an Ok(T) variant), or an error (an Err(E) variant). This allows Rust to express I/O operations that could fail in a way that must be handled by your code. The ? operator can be used to propagate these errors up the call stack.

A comprehensive case is as follows:

use std::io::Write;
fn main() {

    /*
        std::io::stdin() 返回标准输入流stdin的句柄。
        read_line() stdin的句柄的一个方法，从标准输入流中读取一行数据
        返回一个Result枚举。会自动删除行尾的换行符\n。
        unwrap() 是一个帮助的方法，简化恢复错误的处理。返回Result中的存储实际值。
     */
    let mut in_word = String::new();
    let result = std::io::stdin().read_line(&mut in_word).unwrap();
    println!("您输入的是:{}\n", in_word);       // 您输入的是:hello
    println!("读取的字节数为:{}\n", result);    // 读取的字节数为:7

    let result1 = std::io::stdout().write("Rust".as_bytes()).unwrap();
    println!("写入的字节数为:{}\n", result1);   // Rust写入的字节数为:4
    let result2 = std::io::stdout().write("Hello".as_bytes()).unwrap();
    println!("写入的字节数为:{}\n", result2);   // Hello写入的字节数为:5

    /*
        std::io::stdout()返回标准输出流的句柄。
        write()是标准输出流stdout的句柄上的一个方法，用于向标准输出流中写入字节流的内容。
        也放回一个Result枚举，不会输出结束时自动追加换行符\n
     */

    let input_args = std::env::args();
    for arg in input_args {
        println!("命令行参数:{}", arg);
    }

    /*
        输出：
        命令行参数:D:\Rust\io_23\target\debug\io_23.exe
        命令行参数:Rust
        命令行参数:Programming
        命令行参数:Language
     */
}

unwrap()

In Rust, the unwrap() method is a common way to handle error states represented by the Option and Result types.

Let’s break it down a bit:

Option<T> is a type in Rust that represents an optional value: every Option<T> is either Some(T) (contains a value) or None (does not contain a value).
Result<T, E> is a type in Rust that can represent either success (Ok(T)) or failure (Err(E)).

Both Option and Result types have the method unwrap(). For an Option, calling unwrap() returns the contained value if it’s Some(T), but if it’s None, it will cause the program to panic (crash).

For a Result, calling unwrap() returns the contained value if it’s Ok(T), but if it’s Err(E), it will also cause the program to panic.

So, the unwrap() method is a somewhat risky operation to use, because while it’s a quick and easy way to obtain the inner value, it can cause your program to crash if the Option is None or the Result is an Err. In production code, it’s often preferable to handle errors more gracefully rather than using unwrap().文章来源地址https://www.toymoban.com/news/detail-616659.html

到了这里，关于Rust-IO的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！