Difference between revisions of "Rust-Programming-Language/C2/File-Handling/English"

Title Slide

Learning Objectives

• File operations
• Input and Output operations

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.

File I/O – Standard Library

• std::fs is a module for file handling
• std::io is a module for reading and writing

use std::io::{self, Write};

fn main() -> io::Result<()> {

let mut file = File::create("output.txt")?; // Create or overwrites file

file.write_all(b"Hello, Rust file writing!")?; // Write bytes to file

println!("Data written to file");

Ok(())

}

File is used to create, open and work with files.

Then we import the io module and write the trait.

Here self means importing std::io itself as io.

In the main function, File::create() method creates a new file called output.txt.

If it already exists, it truncates it before writing, otherwise creates a new file.

Write_all writes all the bytes from the given byte string into the file.

The b before the string literal means that we are writing raw bytes, not a String.

This is often safer and faster for low-level writing.

The question mark(?) operator is used to handle any write failure.

After successful writing, we print a successful message.

We return the Ok() method variant to signal that everything worked without errors.

Save the file.

Let us open the output.txt.

We can see the data written to the file.

use std::io::{self, Read};

fn main() -> io::Result<()> {

let mut file = File::open("output.txt")?; // Open file in read-only mode

let mut contents = String::new();

file.read_to_string(&mut contents)?; // Read file into a string

println!("File content: {}", contents);

Ok(())

}

In the main function, we return io::Result<()>.

File::open() method opens output.txt file in read-only mode.

Question mark(?) propagates an error if the file doesn’t exist or can’t be opened.

We create an empty String to hold the file’s contents.

Next we create a mutable String named contents.

It stores the contents that are read.

Finally, we print the file contents to the console.

Save the program.

We can see the content of the file output.txt is displayed.

use std::io::Write;

fn main() -> std::io::Result<()> {

let mut file = OpenOptions::new()

.append(true)

.open("output.txt")?;

file.write_all(b"\nThis is an appended line.")?;

println!("Data added to the file");

Ok(())

}

Operations like appending, reading and writing can be done simultaneously.

.append(true)method enables the append mode.

New data will be appended at the end of the file instead of overwriting.

It opens output.txt file with the question mark(?) which handles errors.

For example, if the file doesn’t exist.

file.write_all writes a newline followed by the text "This is an appended line."

Save the program.

We see the message “Data added to the file”.

Let us open the output.txt .

We can see the data is added at the end of the file.

fn main() -> std::io::Result<()> {

fs::remove_file("output.txt")?;

println!("File deleted");

Ok(())

}

If the file doesn’t exist or if you don’t have permission, it returns an error.

If the file is deleted successfully, “File Deleted” message is printed.

Save the program.

We see the message “File deleted”.

Let us summarize.

Assignment

Write a Rust program to do the following steps in order:

• Create a file named notes.txt
• Write the below text into the file:
• Reopen the same file in append mode and add one more line:
• Read back the entire contents of the file and print them on the console.

Thank You