Rust中如何让变量在不同条件下持有Stdout或File类型实例

解决方案1：使用trait对象动态分发（无额外依赖） #

你之前代码报错的核心原因是Stdout和File是完全不同的类型，Rust作为静态类型语言，不允许同一个变量存储不同类型的值；而你之前直接用&mut dyn Write的写法会出现生命周期问题，是因为你引用的是if分支内创建的临时值，临时值在分支结束就会被销毁，导致引用悬垂。

用Box<dyn Write>装箱两种实现可以完美解决这个问题，Box会持有值的所有权，同时把不同类型统一为 trait 对象类型：

fn main() -> std::io::Result<()> {
  let path = std::env::args().nth(1).expect("usage: minidecaf <input path> [output path]");
  let input = std::fs::read_to_string(path)?;
  let output_path = std::env::args().nth(2);

  let mut writer: Box<dyn std::io::Write> = if let Some(output_path) = output_path {
      // 注意：原来的File::open是只读打开，要写入请用File::create
      Box::new(std::fs::File::create(output_path)?)
  } else {
      Box::new(std::io::stdout())
  };

  minidecaf::run(&input, &mut writer)
}

这个方案只有极微小的运行时动态分发开销，绝大多数场景下都可以忽略。

解决方案2：自定义枚举实现静态分发（无运行时开销） #

如果你完全不想要动态分发的开销，可以自己定义一个枚举覆盖两种输出类型，手动为它实现Write trait：

enum OutputWriter {
    Std(std::io::Stdout),
    File(std::fs::File)
}

impl std::io::Write for OutputWriter {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        match self {
            OutputWriter::Std(s) => s.write(buf),
            OutputWriter::File(f) => f.write(buf)
        }
    }

    fn flush(&mut self) -> std::io::Result<()> {
        match self {
            OutputWriter::Std(s) => s.flush(),
            OutputWriter::File(f) => f.flush()
        }
    }
}

fn main() -> std::io::Result<()> {
  let path = std::env::args().nth(1).expect("usage: minidecaf <input path> [output path]");
  let input = std::fs::read_to_string(path)?;
  let output_path = std::env::args().nth(2);

  let mut writer = if let Some(output_path) = output_path {
      OutputWriter::File(std::fs::File::create(output_path)?)
  } else {
      OutputWriter::Std(std::io::stdout())
  };

  minidecaf::run(&input, &mut writer)
}

额外注意点 #

• 你原有代码中使用File::open是只读打开文件，写入数据会报错，写入场景需要替换为File::create
• 优先使用if let匹配Option值，避免无意义的is_none()判断加unwrap()调用，写法更安全也更符合Rust惯例

内容的提问来源于stack exchange，提问作者Tokubara