Difference between revisions of "Rust-Programming-Language/C2/Path-Struct/English"

Title Slide

Learning Objectives

• Path Struct and
• Common methods of Path struct

System Requirements

Code Files

• The following code file is required to practise this tutorial.
• This file is provided in the Code Files link of this tutorial page.

Path Struct

• Path is a struct in Rust’s standard library (std::path::Path)
• It is used to represent file system’s path.
• A Path does not actually open or read files.

> cd Desktop/MyRustProject

> cargo new pathstruct

We will see how Rust interacts with files and folders using the Path struct.

fn main() {

let path = Path::new("hello.txt");

println!("Exists: {}", path.exists());

println!("Is file: {}", path.is_file());

println!("Is directory: {}", path.is_dir());

}

We import the Path struct from the std::path module.

Path is used to inspect and manipulate file or directory paths in a safe way.

It creates a Path instance pointing to "hello.txt".

At this stage, no file is created or opened.

path.exists() method checks if hello.txt actually exists in the file system or not.

path.is_file() method checks if the path points to a file.

path.is_dir() method checks if the path points to a directory.

Save the program.

Here the hello.txt file does not exist and so it returns false.

Type cargo run at the terminal prompt.

Run the same code and check the output.

fn main() {

let path = Path::new("/home/nirmala/docs/file.txt");

println!("Full path: {:?}", path);

// Get the file name (last component)

if let Some(filename) = path.file_name() {

println!("File name: {}", filename.to_string_lossy());

}

// Get the parent directory

if let Some(parent) = path.parent() {

println!("Parent directory: {:?}", parent);

}

// Get the extension

if let Some(ext) = path.extension() {

println!("Extension: {}", ext.to_string_lossy());

}

}

path.file_name() method gets the last component of the path.

Here it is the filename file.txt

to_string_lossy() function converts it into a human-readable String.

path.parent() gets the parent directory of the path.

path.extension() gets the file extension.

Here the extension is .txt

Save the program.

These operations deal with reading from the keyboard and writing to the terminal.

fn main() {

let mut input = String::new();

println!("Enter your name:");

io::stdin().read_line(&mut input).expect("Failed to read line");

println!("Hello, {}", input.trim());

}

String::new() method creates a mutable empty string to store user input.

Next it prompts the user to type his/her name.

read_line waits for the user to type and press Enter.

.expect() is used here for simple error handling.

.trim() method removes the unwanted characters from the end of input and format it.

At last we print Hello and the input that user enters on the console.

Save the program.

Enter the name

Type name >> Press Enter.

It prompts to enter the name.

Type your name and press Enter.

It prints Hello and the entered name as output.

fn main() {

match File::open("non_existent.txt") {

Ok(_) => println!("File opened successfully."),

Err(e) => println!("Error opening file: {}", e),

}

}

File::open method returns a Result enum type.

If the file exists and opens successfully it returns the OK type.

If the file doesn’t exist (or another error happens), e holds the error details.

Save the program.

Point to the error message.

We can see an error message “Error opening file: No such file or directory”.

Summary

Let us summarize.

Assignment

Write a Rust program that:

1. Asks the user to enter a file path

2. Prints the following information using methods from std::path::Path module.

Thank You