Reading Text Files in Rust: A Beginner's Guide

Welcome to the first lesson in our “Fundamentals of Text Data Manipulation” course! In this lesson, you'll explore how to read text files using Rust's file handling capabilities. Text files appear everywhere in programming — whether you're logging data, storing configuration information, or working with raw input files. By learning how to open and read text files in Rust, you'll establish a crucial skill set for manipulating data within your applications. Let's dive in!

File paths let us locate and identify files on our system. In Rust, we often leverage the std::path::Path type to work with both absolute and relative paths.

• Absolute Path
  An absolute path starts at the root directory of the operating system. Examples:

  • Linux: /home/user/documents/input.txt
  • macOS: /Users/user/documents/input.txt
  • Windows: C:\Users\user\documents\input.txt

• Relative Path
  A relative path indicates a path based on the current working directory of your program. For instance, data/input.txt is relative to wherever your program is running.

A path is like a physical address: an absolute path is the full address, while a relative path is a set of directions starting from your current location.

Here's a simple snippet showing a path in Rust:

use std::path::Path;

fn main() {
    // Example of creating a Path from a string slice
    let path = Path::new("data/example.txt");
    println!("File name: {:?}", path.file_name());
}

When you structure your projects, you might organize them into folders such as “data” or “resources.” Here are a few examples with file trees and corresponding Rust code:

1. Example 1

   Directory Tree:

   project/
   ├── program (executable or compiled output)
   └── data/
       └── input.txt

   In Rust:

   Rust

   use std::path::Path;
   
   fn main() {
       let file_path = Path::new("data/input.txt");
       println!("Path: {:?}", file_path);
   }

2. Example 2

   Directory Tree:

   user/
   ├── documents/
   │   └── program (executable or compiled output)
   └── input.txt

   Here, you might need to go up one directory before descending into the target file:

   Rust

   use std::path::Path;
   
   fn main() {
       let file_path = Path::new("../input.txt");
       println!("Path: {:?}", file_path);
   }

3. Example 3

   Directory Tree:

   application/
   ├── scripts/
   │   ├── program1
   │   └── program2
   └── resources/
       └── input.txt

   If running from scripts/program2:

   Rust

   use std::path::Path;
   
   fn main() {
       let file_path = Path::new("../resources/input.txt");
       println!("Path: {:?}", file_path);
   }

4. Example 4

   Directory Tree:

   my_project/
   ├── program (executable)
   └── input.txt

   In this situation:

   Rust

   use std::path::Path;
   
   fn main() {
       let file_path = Path::new("input.txt");
       println!("Path: {:?}", file_path);
   }

All these examples demonstrate how relative paths revolve around where your compiled program is being run.