Rust Lang

How to Read a File Using the Rust Language

The ability to read files is critically important to any developer. It allows us to load information from external sources and manipulate it as we see fit.

In this article, we will discuss various tricks and methods to read files in the Rust programming language.

Project Setup

The initial set is to create a project structure. We can do this using the cargo command as:

$ cargo new read_file

The previous command will initialize a new project with the specified name. In the root directory, add a text file that will contain the sample data we will read with Rust.

This tutorial will use a simple text file containing ARP information from a Windows machine.

Sample information is as shown:

Interface: --- 0xc
 Internet Address      Physical Address      Type           d4-b1-06-99-3b-63     dynamic         ff-ff-ff-ff-ff-ff     static            01-00-5e-00-00-16     static           01-00-5e-00-00-fb     static           01-00-5e-00-00-fc     static       01-00-5e-7f-ff-fa     static       ff-ff-ff-ff-ff-ff     static

Interface: --- 0x16
 Internet Address      Physical Address      Type        00-15-5d-a5-46-20     dynamic       00-15-5d-a5-40-17     dynamic       00-15-5d-a5-4a-c1     dynamic       00-15-5d-a5-47-cd     dynamic       ff-ff-ff-ff-ff-ff     static            01-00-5e-00-00-16     static           01-00-5e-00-00-fb     static       01-00-5e-40-98-8f     static       01-00-5e-7f-ff-fa     static

With the project setup and the sample file ready, we can read the file’s content.

Read File as a String

The first and simplest method to read a file in Rust is to load it as an entire string. We can accomplish this using the std::fs::read_to_string method.

The following code shows how you can read a file as a string in Rust:

use std::fs::File;
use std::io::prelude::*;

fn main() {
 let mut file = File::open("arp.txt")
  .expect("File not found");
  let mut data = String::new();
 file.read_to_string(&mut data)
  .expect("Error while reading file");
 println!("{}", data);


The previous code imports the File struct and the prelude module. In the main function, we create a mutable variable called file and load open the arp.txt file for reading.

Next, we read the file’s content using the read_to_string and pass a mutable reference to the data variable. Then, we can print the content of the file using the println! macro.

We can run the code as:

$ cargo run

Read File Line by Line

We can also read a file line by line using the lines iterator. The iterator will operate on the BufReader from the File object. An example code is provided below:

use std::fs::File;
use std::io::BufReader;
use std::io::prelude::*;
fn main()-> std::io::Result<()> {
 let file = File::open("arp.txt")
  .expect("file not found!");
 let  buf_reader = BufReader::new(file);

 for line in buf_reader.lines() {
  println!("{}", line?);

Read File as Vector

We can also read a file as a vector as shown in the example code provided below:

fn read_file() -> std::io::Result<Vec<u8>> {
 let mut file = File::open("arp.txt")?;
 let mut buf = Vec::new();
 file.read_to_end(&mut data);
 return Ok(data);

The previous code uses the Vec::new method to create a new empty vector. Then, we use the read_to_end to read the bytes until the End Of File and place them into the buffer.


In this article, we covered the basics of file operation using the Rust programming language. In addition, we illustrated various methods and techniques used to read files. We hope you found this article helpful. Check the other Linux Hint articles for more tips and information.

About the author

John Otieno

My name is John and am a fellow geek like you. I am passionate about all things computers from Hardware, Operating systems to Programming. My dream is to share my knowledge with the world and help out fellow geeks. Follow my content by subscribing to LinuxHint mailing list