File Handling in Rust

# CHAPTER 20

File Handling in Rust #

1. Chapter Introduction #

2. Learning Objectives #

• Read the entire contents of a file into a String.

• Write new data to a file (overwriting existing content).

• Append data to an existing file.

• Understand the std::fs and std::io modules.

3. Reading a File #

use std::fs;

fn main() {
    // Attempt to read the file. Returns a Result<String, Error>
    let content = fs::read_to_string("hello.txt");

    match content {
        Ok(text) => println!("File contains:\n{}", text),
        Err(e) => println!("Failed to read file: {}", e),
    }
}

4. Writing to a File #

use std::fs;

fn main() {
    let data = "This is some new data we are writing to the disk!";
    
    // Write data. Returns a Result<(), Error>
    match fs::write("output.txt", data) {
        Ok(_) => println!("Successfully wrote to the file."),
        Err(e) => println!("Error writing: {}", e),
    }
}

5. Appending to a File #

use std::fs::OpenOptions;
use std::io::Write; // Needed for the .write_all() trait method

fn main() {
    // Configure how we open the file
    let file_result = OpenOptions::new()
        .create(true) // Create if it doesn't exist
        .append(true) // Append to the end
        .open("logs.txt");

    match file_result {
        Ok(mut file) => {
            // Write the data as bytes
            if let Err(e) = file.write_all(b"User logged in.\n") {
                println!("Failed to write to file: {}", e);
            } else {
                println!("Log updated.");
            }
        }
        Err(e) => println!("Failed to open file: {}", e),
    }
}

6. Mini Project: Notes Manager #

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

// Function returns a Result so we can use '?'
fn save_note(note: &str) -> io::Result<()> {
    let mut file = OpenOptions::new()
        .create(true)
        .append(true)
        .open("notes.txt")?; // The '?' handles the Err automatically!

    file.write_all(note.as_bytes())?;
    file.write_all(b"\n")?; // Add a newline

    Ok(()) // Return success
}

fn main() {
    println!("Enter a note to save:");
    let mut input = String::new();
    
    io::stdin().read_line(&mut input).expect("Failed to read input");

    match save_note(input.trim()) {
        Ok(_) => println!("Note saved successfully!"),
        Err(e) => println!("Critical Error: Could not save note. {}", e),
    }
}

7. Common Mistakes #

• Forgetting use std::io::Write;: If you try to use .write_all(), the compiler will complain that the method doesn't exist unless you bring the Write trait into scope!

• Pathing Issues: Expecting "file.txt" to be relative to the .rs file. It is actually relative to where you execute cargo run (usually the root directory of the project).

8. Best Practices #

• Never use unwrap() for File I/O: File operations are the most likely things to fail in a program (due to permissions, missing files, or full hard drives). Always handle the Result.

9. Exercises #

1. 1. Write a program that uses fs::write to create a file named secret.txt containing the word "Rust".

1. 2. Use fs::read_to_string to read secret.txt and print the contents to the console.

10. MCQs with Answers #

11. Interview Questions #

• Q: Explain how Rust handles the closing of file handles. Do you need to call file.close()? (Answer: No, Rust's Ownership rules automatically drop the file handle and close the OS resource when the file variable goes out of scope).

12. Summary #

13. Next Chapter Recommendation #