Reading and writing using the new Rust IO library
When the re-write of the std::io
module landed in Rust 1.0.0-alpha.2, there were a lot of changes to the way you read/write to a file. I’ll cover some simple examples and probably make edits in the future to add more fancy stuff.
Disclaimer: At the time of writing this,
std::io
is still a work in progress! I’m also currently learning this new library as I go along, so there may be errors on my behalf as well!
Reading from a file
Reading to a file can be done in two ways (both really simple). I’ll talk about one way here and the second a little later.
let file = match File::open("test_file.txt") {
Ok(file) => file,
Err(..) => panic!("room"),
}
File::open
by default gives you Read
permissons, so you can create a BufReader
from that.
let mut reader = BufReader::new(&file);
// read_line takes reads a line and writes to a string, so we give it one.
let buffer_string = &mut String::new();
reader.read_line(buffer_string);
println!("We read a new line: {}", buffer_string);
Writing to a file
Permissons
A simple example for writing to a file is to start by creating your Path
, and an OpenOptions
. An OpenOptions
is how you provide the file permissons and that you would need to read or write to a file appropriately.
let mut options = OpenOptions::new();
// We want to write to our file as well as append new data to it.
options.write(true).append(true);
You can also add .read(true)
for read permissions as an alternate way to read from the file. Although, the interesting part about OpenOptions
is that you can re-use the options set for multiple files:
// We can create a Path
let path = Path::new("test_file.txt");
// or we can also just use a string slice:
let path2 = "test_file2.txt";
// We create file options to write
let mut options = OpenOptions::new();
options.write(true)
// Both of these should be valid
let file: Result<File, Error> = options.open(path);
let file2: Result<File, Error> = options.open(path2);
The actual writing bit
So now that we have the permissons setup correctly, we can create a BufWriter
to actually write to the file. I’ve added a match statement to unwrap the unlike the previous snippet:
let file = match options.open(&path) {
Ok(file) => file,
Err(..) => panic!("at the Disco"),
};
// We create a buffered writer from the file we get
let mut writer = BufWriter::new(&file);
// Then we write to the file. write_all() calls flush() after the write as well.
writer.write_all(b"test\n");
Conclusion
In my examples, I’ve used separate buffers but you can use a BufStream
as well to get all the same features combined.