文件系统操作

std::io::fs 模块包含几个处理文件系统的函数。

  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. // `% cat path` 的简单实现
  9. fn cat(path: &Path) -> io::Result<String> {
  10.     let mut f = try!(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. // `% echo s > path` 的简单实现
  19. fn echo(s: &str, path: &Path) -> io::Result<()> {
  20.     let mut f = try!(File::create(path));
  22.     f.write_all(s.as_bytes())
  23. }
  25. // `% touch path` 的简单实现（忽略已存在的文件）
  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.     // 创建一个目录，返回 `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.     // 前面的匹配可以用 `unwrap_or_else` 方法简化
  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.     // 递归地创建一个目录，返回 `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.     // 创建一个符号链接，返回 `io::Resutl<()>`
  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.     // 读取目录的内容，返回 `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.     // 删除一个文件，返回 `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.     // 移除一个空目录，返回 `io::Result<()>`
  89.     fs::remove_dir("a/c/d").unwrap_or_else(|why| {
  90.         println!("! {:?}", why.kind());
  91.     });
  92. }

下面是所期望的成功的输出：

  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. `walk a`
  13. > a/c
  14. > a/c/b.txt
  15. > a/c/e.txt
  16. > a/c/d
  17. > a/b.txt
  18. `rm a/c/e.txt`
  19. `rmdir a/c/d`

且 a 目录的最终状态为：

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

另一种定义 cat 函数的方式是使用 ? 标记：

  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. }

参见：

cfg!