Với việc Rust tương đối mới, tôi đã thấy quá nhiều cách đọc và ghi tệp. Nhiều đoạn cực kỳ lộn xộn mà ai đó đã đưa ra cho blog của họ và 99% các ví dụ tôi đã tìm thấy (ngay cả trên Stack Overflow) là từ các bản dựng không ổn định không còn hoạt động. Bây giờ Rust đã ổn định, một đoạn mã đơn giản, dễ đọc, không hoảng loạn để đọc hoặc ghi tệp là gì?

Đây là lần gần nhất tôi có được thứ gì đó hoạt động trong việc đọc tệp văn bản, nhưng nó vẫn không biên dịch mặc dù tôi khá chắc chắn rằng tôi đã bao gồm mọi thứ tôi nên có. Điều này dựa trên đoạn trích tôi tìm thấy trên Google+ của tất cả các địa điểm và điều duy nhất tôi đã thay đổi là cái cũ BufferedReaderbây giờ chỉ là BufReader:

use std::fs::File;
use std::io::BufReader;
use std::path::Path;

fn main() {
    let path = Path::new("./textfile");
    let mut file = BufReader::new(File::open(&path));
    for line in file.lines() {
        println!("{}", line);
    }
}

Trình biên dịch phàn nàn:

error: the trait bound `std::result::Result<std::fs::File, std::io::Error>: std::io::Read` is not satisfied [--explain E0277]
 --> src/main.rs:7:20
  |>
7 |>     let mut file = BufReader::new(File::open(&path));
  |>                    ^^^^^^^^^^^^^^
note: required by `std::io::BufReader::new`

error: no method named `lines` found for type `std::io::BufReader<std::result::Result<std::fs::File, std::io::Error>>` in the current scope
 --> src/main.rs:8:22
  |>
8 |>     for line in file.lines() {
  |>                      ^^^^^

Tóm lại, điều tôi đang tìm kiếm là:

• ngắn gọn
• khả năng đọc
• bao gồm tất cả các lỗi có thể
• không hoảng sợ

Không có chức năng nào tôi hiển thị ở đây hoảng loạn, nhưng tôi đang sử dụng expectvì tôi không biết cách xử lý lỗi nào sẽ phù hợp nhất với ứng dụng của bạn. Go đọc Các Rust Lập trình Ngôn ngữ 's chương về xử lý lỗi để hiểu làm thế nào để xử lý một cách thích hợp thất bại trong chương trình của riêng bạn.

Rust 1.26 trở đi

Nếu bạn không muốn quan tâm đến các chi tiết cơ bản, có các hàm một dòng để đọc và viết.

Đọc một tập tin cho một String

use std::fs;

fn main() {
    let data = fs::read_to_string("/etc/hosts").expect("Unable to read file");
    println!("{}", data);
}

Đọc một tập tin như là một Vec<u8>

use std::fs;

fn main() {
    let data = fs::read("/etc/hosts").expect("Unable to read file");
    println!("{}", data.len());
}

Viết một tập tin

use std::fs;

fn main() {
    let data = "Some data!";
    fs::write("/tmp/foo", data).expect("Unable to write file");
}

Rust 1.0 trở đi

Các biểu mẫu này dài hơn một chút so với các hàm một dòng phân bổ một Stringhoặc Veccho bạn, nhưng mạnh hơn ở chỗ bạn có thể sử dụng lại dữ liệu được phân bổ hoặc nối vào một đối tượng hiện có.

Đọc dữ liệu

Đọc một tập tin đòi hỏi hai phần cốt lõi: Filevà Read.

Đọc một tập tin cho một String

use std::fs::File;
use std::io::Read;

fn main() {
    let mut data = String::new();
    let mut f = File::open("/etc/hosts").expect("Unable to open file");
    f.read_to_string(&mut data).expect("Unable to read string");
    println!("{}", data);
}

Đọc một tập tin như là một Vec<u8>

use std::fs::File;
use std::io::Read;

fn main() {
    let mut data = Vec::new();
    let mut f = File::open("/etc/hosts").expect("Unable to open file");
    f.read_to_end(&mut data).expect("Unable to read data");
    println!("{}", data.len());
}

Viết một tập tin

Viết một tệp tương tự, ngoại trừ chúng tôi sử dụng Writeđặc điểm và chúng tôi luôn viết ra các byte. Bạn có thể chuyển đổi a String/ &strthành byte bằng as_bytes:

use std::fs::File;
use std::io::Write;

fn main() {
    let data = "Some data!";
    let mut f = File::create("/tmp/foo").expect("Unable to create file");
    f.write_all(data.as_bytes()).expect("Unable to write data");
}

Bộ đệm I / O

Tôi cảm thấy một chút thúc đẩy từ cộng đồng để sử dụng BufReadervà BufWriterthay vì đọc thẳng từ một tập tin

Một trình đọc đệm (hoặc nhà văn) sử dụng bộ đệm để giảm số lượng yêu cầu I / O. Ví dụ, truy cập đĩa một lần sẽ hiệu quả hơn nhiều khi đọc 256 byte thay vì truy cập đĩa 256 lần.

Điều đó đang được nói, tôi không tin rằng một trình đọc / ghi đệm được đệm sẽ hữu ích khi đọc toàn bộ tệp. read_to_enddường như sao chép dữ liệu trong các phần lớn, do đó việc chuyển có thể được kết hợp một cách tự nhiên thành ít yêu cầu I / O hơn.

Đây là một ví dụ về việc sử dụng nó để đọc:

use std::fs::File;
use std::io::{BufReader, Read};

fn main() {
    let mut data = String::new();
    let f = File::open("/etc/hosts").expect("Unable to open file");
    let mut br = BufReader::new(f);
    br.read_to_string(&mut data).expect("Unable to read string");
    println!("{}", data);
}

Và để viết:

use std::fs::File;
use std::io::{BufWriter, Write};

fn main() {
    let data = "Some data!";
    let f = File::create("/tmp/foo").expect("Unable to create file");
    let mut f = BufWriter::new(f);
    f.write_all(data.as_bytes()).expect("Unable to write data");
}

A BufReaderhữu ích hơn khi bạn muốn đọc từng dòng một:

use std::fs::File;
use std::io::{BufRead, BufReader};

fn main() {
    let f = File::open("/etc/hosts").expect("Unable to open file");
    let f = BufReader::new(f);

    for line in f.lines() {
        let line = line.expect("Unable to read line");
        println!("Line: {}", line);
    }
}