Skip to main content
Welcome to the first lesson on file handling in Rust. In this guide, we’ll explore the fundamental operations of reading from and writing to files using Rust’s standard library. File handling is essential for persistent data storage, configuration management, logging, and more. File operations such as creating, reading, writing, and deleting files are mainly managed through Rust’s std::fs module. This module provides safe and efficient methods to handle files within your applications.

​
Setting Up Your Project

Begin by creating a new binary application in your project directory. For this lesson, we will name the application my_file_handling: 
cargo new my_file_handling
After running the above command, you should see a confirmation similar to: 
Creating binary (application) `my_file_handling` package
note: see more `Cargo.toml` keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
Open the newly created project in your favorite text editor (e.g., VS Code) to start coding.

​
Importing Essential Modules

To work with files and handle input/output operations, import the necessary modules at the beginning of your Rust file. The fs module provides structures like File, and the io module offers various functions and traits for I/O tasks. Start with a simple Rust program: 
fn main() {
    println!("Hello, world!");
}
Then, import the File struct from std::fs and Error from std::io: 
use std::fs::File;
use std::io::Error;

fn main() {
    // Your file handling code will go here.
}
The File struct is central to the file operations like opening and creating files.

​
Opening an Existing File

To open an existing file (e.g., example.txt), first ensure the file is present in your project’s root directory with some sample content (for example, “Hey, how is it going!”). Use the File::open method, which returns a Result to handle success or errors: 
use std::fs::File;
use std::io::{self, Error};

fn main() {
    // Attempt to open 'example.txt'
    let file_result: Result<File, io::Error> = File::open("example.txt");
    match file_result {
        Ok(_) => println!("File opened successfully."),
        Err(e) => println!("Error opening file: {}", e),
    }
}
Make sure that example.txt is located in the project’s root directory before running the code to avoid file not found errors.

​
Creating a New File

Creating a file is as straightforward as opening one. Use the File::create method, which also returns a Result: 
use std::fs::File;
use std::io::Error;

fn main() {
    // Attempt to create a new file 'new_file.txt'
    let file_result: Result<File, Error> = File::create("new_file.txt");
    match file_result {
        Ok(_) => println!("File created successfully."),
        Err(e) => println!("Error creating file: {}", e),
    }
}
When you build and run the program, Cargo will search for example.txt in the project’s root directory. If example.txt does not exist, you will see an error for opening the file, while the file creation should succeed. Example output when example.txt is missing: 
cargo run --quiet
Error opening file: No such file or directory (os error 2)
File created successfully.
After adding a valid example.txt file, both operations should succeed: 
cargo run --quiet
File opened successfully.
File created successfully.

​
Reading File Contents

To load the entire file into a string, you need to bring the Read trait from std::io into scope. The example below reads the complete content of example.txt and then creates a new file as previously demonstrated: 
use std::fs::File;
use std::io::{self, Read, Error};

fn main() {
    // Attempt to open 'example.txt'
    let file_result: Result<File, io::Error> = File::open("example.txt");
    let mut file: File = match file_result {
        Ok(f) => f,
        Err(e) => {
            println!("Error opening file: {}", e);
            return;
        }
    };

    // Create a mutable string to store file contents.
    let mut contents: String = String::new();
    
    // Read the entire file into the string.
    let _ = file.read_to_string(&mut contents);
    
    // Display file contents.
    println!("File contents: {:?}", contents);

    // Create a new file as an additional example.
    let file_result: Result<File, Error> = File::create("new_file.txt");
    match file_result {
        Ok(_) => println!("File created successfully."),
        Err(e) => println!("Error creating file: {:?}", e),
    }
}
When you run the code, your terminal displays the contents of example.txt along with status messages for each file operation.
Compiler warnings may flag the unused Result from read_to_string. Consider incorporating robust error handling in your production code.

​
Reading a File Using a Buffer

For larger files or more controlled file reading, processing data in chunks using a buffer can be more efficient. The following example reads example.txt in chunks of 10 bytes in a loop: 
use std::fs::File;
use std::io::{self, Read};

fn main() -> io::Result<()> {
    let mut file: File = File::open("example.txt")?;
    let mut buffer: [u8; 10] = [0; 10]; // Buffer to hold 10 bytes

    loop {
        // Read a chunk into the buffer
        let bytes_read: usize = file.read(&mut buffer)?;

        // Break the loop if no bytes are read (end of file reached)
        if bytes_read == 0 {
            break;
        }

        // Process and print the data chunk
        println!(
            "Read {} bytes: {:?}",
            bytes_read,
            String::from_utf8_lossy(&buffer[..bytes_read])
        );
    }

    Ok(())
}
An example output from this code might look like: 
cargo run --quiet
Read 10 bytes: "Hey, how i"
Read 10 bytes: "s it going"
Read 1 bytes: "!"

​
Writing Data to a File

To write data into a file, use the write_all method from the std::io::Write trait. In the example below, a file named output.txt is created and the string “Hello, Rust!” is written to it: 
use std::fs::File;
use std::io::{self, Write};

fn main() -> io::Result<()> {
    let mut file = File::create("output.txt")?;
    
    // Write data to the file.
    file.write_all(b"Hello, Rust!")?;
    println!("Data written to file.");

    Ok(())
}
After executing the code, inspect output.txt to verify that it contains “Hello, Rust!”.

​
Appending Data to a File

Appending new data to an existing file is managed efficiently with the OpenOptions struct. This lets you configure file access options, such as append mode: 
use std::fs::OpenOptions;
use std::io::{self, Write};

fn main() -> io::Result<()> {
    let mut file = OpenOptions::new()
        .append(true)
        .open("output.txt")?;
    
    // Append data to the file.
    file.write_all(b" Appending more data.")?;
    println!("Data appended to file.");

    Ok(())
}
After running the above code, the specified text (” Appending more data.”) is added to the end of output.txt. Example output: 
cargo run --quiet
Data appended to file.
Ensure that output.txt exists before attempting to append data. Otherwise, the program will fail.

​
Summary

In this lesson, you learned the basics of file handling in Rust. We covered:
  • Setting up the Rust project.
  • Importing required modules.
  • Opening, reading, creating, and writing to files.
  • Reading file contents using a buffer.
  • Appending data to an existing file.
These core file operations are foundational for managing disk-based data in real-world applications. In the next article, we will expand on error handling techniques and explore additional file system operations in Rust.

​
Additional Resources

Keep exploring and happy coding!

Watch Video