Filesystem Operations

The std::io::fs module contains several functions that deal with the
filesystem.

  1. use std::fs;
  2. use std::fs::{File, OpenOptions};
  3. use std::io;
  4. use std::io::prelude::*;
  5. use std::os::unix;
  6. use std::path::Path;
  8. // A simple implementation of `% cat path`
  9. fn cat(path: &Path) -> io::Result<String> {
  10.     let mut f = File::open(path)?;
  11.     let mut s = String::new();
  12.     match f.read_to_string(&mut s) {
  13.         Ok(_) => Ok(s),
  14.         Err(e) => Err(e),
  15.     }
  16. }
  18. // A simple implementation of `% echo s > path`
  19. fn echo(s: &str, path: &Path) -> io::Result<()> {
  20.     let mut f = File::create(path)?;
  22.     f.write_all(s.as_bytes())
  23. }
  25. // A simple implementation of `% touch path` (ignores existing files)
  26. fn touch(path: &Path) -> io::Result<()> {
  27.     match OpenOptions::new().create(true).write(true).open(path) {
  28.         Ok(_) => Ok(()),
  29.         Err(e) => Err(e),
  30.     }
  31. }
  33. fn main() {
  34.     println!("`mkdir a`");
  35.     // Create a directory, returns `io::Result<()>`
  36.     match fs::create_dir("a") {
  37.         Err(why) => println!("! {:?}", why.kind()),
  38.         Ok(_) => {},
  39.     }
  41.     println!("`echo hello > a/b.txt`");
  42.     // The previous match can be simplified using the `unwrap_or_else` method
  43.     echo("hello", &Path::new("a/b.txt")).unwrap_or_else(|why| {
  44.         println!("! {:?}", why.kind());
  45.     });
  47.     println!("`mkdir -p a/c/d`");
  48.     // Recursively create a directory, returns `io::Result<()>`
  49.     fs::create_dir_all("a/c/d").unwrap_or_else(|why| {
  50.         println!("! {:?}", why.kind());
  51.     });
  53.     println!("`touch a/c/e.txt`");
  54.     touch(&Path::new("a/c/e.txt")).unwrap_or_else(|why| {
  55.         println!("! {:?}", why.kind());
  56.     });
  58.     println!("`ln -s ../b.txt a/c/b.txt`");
  59.     // Create a symbolic link, returns `io::Result<()>`
  60.     if cfg!(target_family = "unix") {
  61.         unix::fs::symlink("../b.txt", "a/c/b.txt").unwrap_or_else(|why| {
  62.         println!("! {:?}", why.kind());
  63.         });
  64.     }
  66.     println!("`cat a/c/b.txt`");
  67.     match cat(&Path::new("a/c/b.txt")) {
  68.         Err(why) => println!("! {:?}", why.kind()),
  69.         Ok(s) => println!("> {}", s),
  70.     }
  72.     println!("`ls a`");
  73.     // Read the contents of a directory, returns `io::Result<Vec<Path>>`
  74.     match fs::read_dir("a") {
  75.         Err(why) => println!("! {:?}", why.kind()),
  76.         Ok(paths) => for path in paths {
  77.             println!("> {:?}", path.unwrap().path());
  78.         },
  79.     }
  81.     println!("`rm a/c/e.txt`");
  82.     // Remove a file, returns `io::Result<()>`
  83.     fs::remove_file("a/c/e.txt").unwrap_or_else(|why| {
  84.         println!("! {:?}", why.kind());
  85.     });
  87.     println!("`rmdir a/c/d`");
  88.     // Remove an empty directory, returns `io::Result<()>`
  89.     fs::remove_dir("a/c/d").unwrap_or_else(|why| {
  90.         println!("! {:?}", why.kind());
  91.     });
  92. }

Here’s the expected successful output:

  1. $ rustc fs.rs && ./fs
  2. `mkdir a`
  3. `echo hello > a/b.txt`
  4. `mkdir -p a/c/d`
  5. `touch a/c/e.txt`
  6. `ln -s ../b.txt a/c/b.txt`
  7. `cat a/c/b.txt`
  8. > hello
  9. `ls a`
  10. > "a/b.txt"
  11. > "a/c"
  12. `rm a/c/e.txt`
  13. `rmdir a/c/d`

And the final state of the a directory is:

  1. $ tree a
  2. a
  3. |-- b.txt
  4. `-- c
  5.     `-- b.txt -> ../b.txt
  7. 1 directory, 2 files

An alternative way to define the function cat is with ? notation:

  1. fn cat(path: &Path) -> io::Result<String> {
  2.     let mut f = File::open(path)?;
  3.     let mut s = String::new();
  4.     f.read_to_string(&mut s)?;
  5.     Ok(s)
  6. }

See also:

cfg!