How do you perform file I/O operations in Rust?

Performing file I/O operations in Rust typically involves several steps: opening the file, reading and writing the file, and handling potential errors. Rust's standard library provides rich APIs via std::fs and std::io for handling file I/O.

1. Opening the File

To open a file in Rust, we typically use the std::fs::File struct. This can be done using File::open for reading or File::create for writing. For example:

rust
use std::fs::File;

fn main() {
    // Open the file for reading
    let file = File::open("foo.txt");

    // Check if the file was successfully opened
    match file {
        Ok(file) => println!("File opened successfully {:?}", file),
        Err(e) => println!("Error opening file: {:?}", e),
    }
}

2. Reading the File

To read file content, you can use the std::io::Read trait, which implements various reading methods for the File type. A common method is using read_to_string to read the file content into a String. For example:

rust
use std::fs::File;
use std::io::Read;

fn main() {
    let mut file = File::open("foo.txt").expect("Unable to open file");

    let mut content = String::new();
    file.read_to_string(&mut content).expect("Unable to read file");

    println!("File content: {}", content);
}

3. Writing to the File

Writing to a file can be achieved using the std::io::Write trait. Use File::create to open or create a file for writing. For example:

rust
use std::fs::File;
use std::io::Write;

fn main() {
    let mut file = File::create("foo.txt").expect("Unable to create file");

    file.write_all(b"Hello, world!").expect("Write failed");

    println!("Data written successfully");
}

4. Error Handling

In Rust, error handling is implemented using the Result type. This allows you to handle potential errors using match, or methods like unwrap and expect.

Example: Using Together

The following is a simple example demonstrating how to combine these techniques to read and write files in Rust:

rust
use std::fs::File;
use std::io::{self, Read, Write};

fn main() -> io::Result<()> {
    let mut file = File::create("example.txt")?;
    file.write_all(b"Welcome to Rust file I/O!")?;

    let mut content = String::new();
    let mut file = File::open("example.txt")?;
    file.read_to_string(&mut content)?;

    println!("File content: {}", content);

    Ok(())
}

In this example, we first create a file and write some text, then open the same file, read its content, and print it out. All operations are properly handled for potential errors.