如何使用BufReader文件并仍能写入？

2 回答

• 7

  要避免移动值，可以使用引用和新范围 . 这是你如何做到这一点：

  fn main() {
      let filename = "tt.txt";
  
      // open a tt.txt file in the local directory
      let mut file = OpenOptions::new()
          .read(true)
          .write(true)
          .create(true)
          .open(filename)
          .unwrap();
  
      // now read the whole file to get the latest state
      let date_re = Regex::new(r"^(\d{4})-(\d{2})-(\d{2})").unwrap();
      let time_activity_re = Regex::new(r"^(\d{2}):(\d{2})\s*(.*)").unwrap();
      {
          // BufReader now borrows the value instead of taking ownership.
          let reader = BufReader::new(&mut file);
          let mut latest_date: Option<Date<Local>> = None;
          let mut latest_datetime: Option<DateTime<Local>> = None;
          let mut latest_activity: Option<String> = None;
  
          for wrapped_line in reader.lines() {
              let line = wrapped_line.unwrap();
              println!("line: {}", line);
  
              if date_re.is_match(&line) {
                  let captures = date_re.captures(&line).unwrap();
                  let year = captures.at(1).unwrap().parse::<i32>().unwrap();
                  let month = captures.at(2).unwrap().parse::<u32>().unwrap();
                  let day = captures.at(3).unwrap().parse::<u32>().unwrap();
                  latest_date = Some(Local.ymd(year, month, day));
                  latest_datetime = None;
                  latest_activity = None;
              }
  
              if time_activity_re.is_match(&line) && latest_date != None {
                  let captures = time_activity_re.captures(&line).unwrap();
                  let hour = captures.at(1).unwrap().parse::<u32>().unwrap();
                  let minute = captures.at(2).unwrap().parse::<u32>().unwrap();
                  let activity = captures.at(3).unwrap();
  
                  latest_datetime = Some(latest_date.unwrap().and_hms(hour, minute, 0));
  
                  latest_activity = if activity.len() > 0 {
                      // TODO: if latest_activity already constains a string, clear it and reuse it
                      // as per: https://stackoverflow.com/questions/33781625/how-to-allocate-a-string-before-you-know-how-big-it-needs-to-be
                      Some(activity.to_string())
                  } else {
                      None
                  };
  
                  println!("time activity: {} |{}|", latest_datetime.unwrap(), activity);
              }
          }
      }
      // End of the scope, so now file is not borrowed anymore.
  
      file.seek(End(0));
  
      let now = Local::now();
      if latest_date == None || latest_date.unwrap().year() != now.year()
          || latest_date.unwrap().month() != now.month()
          || latest_date.unwrap().day() != now.day()
      {
          if (latest_date != None) {
              // not an empy file, as far as tt is concerned
              file.write_all(b"\n\n");
          }
          file.write_all(format!("{}\n", now.format("%Y-%m-%d")).as_bytes());
          file.write_all(b"\n");
      }
  
      let activity = env::args().skip(1).join(" ");
      if (activity.len() > 0) {
          file.write_all(format!("{} {}\n", now.format("%H:%M"), activity).as_bytes());
      } else {
          // if there was no latest activity *and* there is no activity, then there's no point in writing a second blank line with just a time
          if latest_activity == None {
              return;
          }
          file.write_all(format!("{}\n", now.format("%H:%M")).as_bytes());
      }
  
      // FIXME: we're just relying on the program exit to close the two file descriptors (which point at the same file).
  }
  

  回复于 2024-05-16T06:05:40+08:00
• 1

  在将文件传递给 BufReader 后，您可以使用BufReader::into_inner来"recover" . 这可以与Read::by_ref一起使用，以避免首先放弃 BufReader<File> 的所有权：

  use std::fs::File;
  use std::io::{BufRead, BufReader, Read, Write};
  
  fn example(file: File) {
      let mut reader = BufReader::new(file);
      for _ in reader.by_ref().lines() {}
  
      let mut out = reader.into_inner();
  
      out.write_all(b"new stuff").unwrap();
  }
  

  这是antoyo's solution，具有类似的简化代码：

  use std::fs::File;
  use std::io::{BufRead, BufReader, Write};
  
  fn example(mut file: File) {
      {
          let reader = BufReader::new(&file);
          for _ in reader.lines() {}
      }
  
      file.write_all(b"new stuff").unwrap();
  }
  

  当实现非词法生存期（NLL）时，可以通过删除额外的大括号来简化这一过程 .

  回复于 2024-05-16T06:05:40+08:00