• 文件系统操作
    • 参见：

    文件系统操作

    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!