Performing Common Filesystem Operations

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.

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:

• fs::remove_dir to remove empty directories.
• fs::remove_dir_all to remove directories along with all their contents.

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: