Skip to main content
In this guide, we explore advanced file operations and common filesystem tasks in Rust. By the end of this tutorial, you’ll have a solid understanding of how to copy, move, rename, and delete both files and directories efficiently using Rust’s standard library.

​
Copying Files

Copying files is a frequent requirement for tasks such as backups or duplicating data. Rust’s fs::copy function makes this process straightforward. The example below copies the contents of “example.txt” to “example_copy.txt” and prints a confirmation message upon success: 
use std::fs;
use std::io;

fn main() -> io::Result<()> {
    fs::copy("example.txt", "example_copy.txt")?;
    println!("File copied successfully.");
    Ok(())
}
Running this code produces the following output: 
cargo run --quiet
File copied successfully.

​
Moving and Renaming Files

Renaming or relocating files is another common operation. Rust’s fs::rename function serves both purposes, whether you need to rename a file or move it to a different directory. For example, to rename “example_copy.txt” to “renamed_example.txt”: 
use std::fs;
use std::io;

fn main() -> io::Result<()> {
    fs::rename("example_copy.txt", "renamed_example.txt")?;
    println!("File renamed successfully.");
    Ok(())
}
To move the renamed file into the “src” directory, adjust the path accordingly: 
use std::fs;
use std::io;

fn main() -> io::Result<()> {
    fs::rename("renamed_example.txt", "src/renamed_example.txt")?;
    println!("File moved successfully.");
    Ok(())
}
When executed, the output will be: 
cargo run --quiet
File moved successfully.

​
Deleting Files

For removing files that are no longer necessary, Rust provides the fs::remove_file function. The following example demonstrates how to delete a file: 
use std::fs;
use std::io;

fn main() -> io::Result<()> {
    fs::remove_file("renamed_example.txt")?;
    println!("File deleted successfully.");
    Ok(())
}
If the file is located within the “src” directory, modify the file path as shown: 
use std::fs;
use std::io;

fn main() -> io::Result<()> {
    fs::remove_file("src/renamed_example.txt")?;
    println!("File deleted successfully.");
    Ok(())
}
Expected output when running the deletion code: 
cargo run --quiet
File deleted successfully.
Be cautious when deleting files since removed files cannot be recovered using the Rust standard library.

​
Directory Operations

Rust offers comprehensive support for working with directories, including operations to create, read, and remove directories.

​
Creating a Directory

You can create a new directory using the fs::create_dir function: 
use std::fs;
use std::io;

fn main() -> io::Result<()> {
    fs::create_dir("example_dir")?;
    println!("Directory created successfully.");
    Ok(())
}
This code creates a new directory named “example_dir”.

​
Reading Directory Contents

To list the contents of a directory, use the fs::read_dir function. This function returns an iterator over directory entries. The example below prints the names of all entries in the current directory: 
use std::fs;
use std::io;
use std::fs::{DirEntry, ReadDir};

fn main() -> io::Result<()> {
    let entries: ReadDir = fs::read_dir(".")?;
    for entry in entries {
        let entry: DirEntry = entry?;
        println!("Name: {:?}", entry.file_name());
    }
    Ok(())
}
An example output might be: 
cargo run --quiet
"Cargo.toml"
"new_file.txt"
"target"
"Cargo.lock"
".gitignore"
".git"
"example.txt"
"example_dir"
"output.txt"
"src"
This output reflects the files and directories in your current working directory.

​
Removing Directories

Rust provides two distinct functions for directory removal: To delete a directory and its contents, use this example: 
use std::fs;
use std::io;

fn main() -> io::Result<()> {
    fs::remove_dir_all("example_dir")?;
    println!("Directory and all contents removed.");
    Ok(())
}
When executed, the code will remove “example_dir” and its contents, then display: 
cargo run --quiet
Directory and all contents removed.

​
Summary

In this tutorial, we reviewed several key filesystem operations in Rust:
OperationDescriptionFunction Reference
Copying FilesDuplicating file contents to a new filefs::copy
Moving/Renaming FilesRenaming or moving files between directoriesfs::rename
Deleting FilesRemoving unnecessary files from the filesystemfs::remove_file
Creating DirectoriesGenerating new directoriesfs::create_dir
Reading Directory ContentsListing files and folders within a directoryfs::read_dir
Removing DirectoriesDeleting directories, including non-empty onesfs::remove_dir_all
This guide covers essential file and directory manipulation techniques in Rust, including copying, moving, renaming, and deleting operations. Always ensure to handle errors appropriately when working with file systems, and be mindful of concurrency control for performance-critical applications.
The image is a summary of key concepts related to file operations, including advanced file operations, directories and buffers, error handling, buffered I/O, and race conditions. Each concept is numbered and briefly explained.

Watch Video

Practice Lab