Rust - Đầu vào / đầu ra tệp

Ngoài việc đọc và ghi vào bảng điều khiển, Rust cho phép đọc và ghi vào các tệp.

Cấu trúc Tệp đại diện cho một tệp. Nó cho phép một chương trình thực hiện các thao tác đọc-ghi trên một tệp. Tất cả các phương thức trong cấu trúc Tệp trả về một biến thể của kiểu liệt kê io :: Kết quả.

Các phương thức thường được sử dụng của cấu trúc tệp được liệt kê trong bảng dưới đây:

Sr.No	Mô-đun	phương pháp	Chữ ký	Sự miêu tả
1	std :: fs :: Tệp	mở()	pub fn open <P: AsRef> (path: P) -> Kết quả	Phương thức tĩnh mở có thể được sử dụng để mở tệp ở chế độ chỉ đọc.
2	std :: fs :: Tệp	tạo nên()	pub fn create <P: AsRef> (path: P) -> Kết quả	Phương thức tĩnh mở tệp ở chế độ chỉ ghi. Nếu tệp đã tồn tại, nội dung cũ sẽ bị hủy. Nếu không, một tệp mới sẽ được tạo.
3	std :: fs :: remove_file	remove_file ()	pub fn remove_file <P: AsRef> (path: P) -> Kết quả <()>	Xóa tệp khỏi hệ thống tệp. Không có gì đảm bảo rằng tệp sẽ bị xóa ngay lập tức.
4	std :: fs :: OpenOptions	append ()	pub fn append (& mut self, append: bool) -> & mut OpenOptions	Đặt tùy chọn cho chế độ nối thêm của tệp.
5	std :: io :: Writes	write_all ()	fn write_all (& mut self, buf: & [u8]) -> Kết quả <()>	Cố gắng ghi toàn bộ bộ đệm vào lần ghi này.
6	std :: io :: Đọc	read_to_string ()	fn read_to_string (& mut self, buf: & mut String) -> Kết quả	Đọc tất cả các byte cho đến khi EOF trong nguồn này, gắn chúng vào buf.

Ghi vào tệp

Hãy để chúng tôi xem một ví dụ để hiểu cách ghi một tệp.

Chương trình sau tạo một tệp 'data.txt'. Phương thức create () được sử dụng để tạo một tệp. Phương thức trả về một xử lý tệp nếu tệp được tạo thành công. Dòng cuối cùng hàm write_all sẽ ghi các byte trong tệp mới tạo. Nếu bất kỳ hoạt động nào không thành công, hàm mong đợi () trả về một thông báo lỗi.

use std::io::Write;
fn main() {
   let mut file = std::fs::File::create("data.txt").expect("create failed");
   file.write_all("Hello World".as_bytes()).expect("write failed");
   file.write_all("\nTutorialsPoint".as_bytes()).expect("write failed");
   println!("data written to file" );
}

Đầu ra

data written to file

Đọc từ một tệp

Chương trình sau đây đọc nội dung trong tệp data.txt và in ra bảng điều khiển. Chức năng "mở" được sử dụng để mở một tệp hiện có. Một đường dẫn tuyệt đối hoặc tương đối đến tệp được chuyển đến hàm open () dưới dạng một tham số. Hàm open () ném ra một ngoại lệ nếu tệp không tồn tại hoặc nếu nó không thể truy cập được vì bất kỳ lý do gì. Nếu nó thành công, một xử lý tệp cho tệp đó sẽ được gán cho biến "tệp".

Hàm "read_to_string" của xử lý "tệp" được sử dụng để đọc nội dung của tệp đó thành một biến chuỗi.

use std::io::Read;

fn main(){
   let mut file = std::fs::File::open("data.txt").unwrap();
   let mut contents = String::new();
   file.read_to_string(&mut contents).unwrap();
   print!("{}", contents);
}

Đầu ra

Hello World
TutorialsPoint

Xóa tệp

Ví dụ sau sử dụng hàm remove_file () để xóa một tệp. Hàm mong đợi () trả về một thông báo tùy chỉnh trong trường hợp xảy ra lỗi.

use std::fs;
fn main() {
   fs::remove_file("data.txt").expect("could not remove file");
   println!("file is removed");
}

Đầu ra

file is removed

Nối dữ liệu vào một tệp

Hàm append () ghi dữ liệu vào cuối tệp. Điều này được thể hiện trong ví dụ dưới đây:

use std::fs::OpenOptions;
use std::io::Write;

fn main() {
   let mut file = OpenOptions::new().append(true).open("data.txt").expect(
      "cannot open file");
   file.write_all("Hello World".as_bytes()).expect("write failed");
   file.write_all("\nTutorialsPoint".as_bytes()).expect("write failed");
   println!("file append success");
}

Đầu ra

file append success

Sao chép một tập tin

Ví dụ sau đây sao chép nội dung trong tệp sang tệp mới.

use std::io::Read;
use std::io::Write;

fn main() {
   let mut command_line: std::env::Args = std::env::args();
   command_line.next().unwrap();
   // skip the executable file name
   // accept the source file
   let source = command_line.next().unwrap();
   // accept the destination file
   let destination = command_line.next().unwrap();
   let mut file_in = std::fs::File::open(source).unwrap();
   let mut file_out = std::fs::File::create(destination).unwrap();
   let mut buffer = [0u8; 4096];
   loop {
      let nbytes = file_in.read(&mut buffer).unwrap();
      file_out.write(&buffer[..nbytes]).unwrap();
      if nbytes < buffer.len() { break; }
   }
}

Thực thi chương trình trên dưới dạng main.exe data.txt datacopy.txt . Hai đối số dòng lệnh được truyền trong khi thực thi tệp:

đường dẫn đến tệp nguồn
tệp đích