Ferrugem - Entrada / Saída de Arquivo

Além de ler e gravar no console, o Rust permite ler e gravar arquivos.

A estrutura de arquivo representa um arquivo. Ele permite que um programa execute operações de leitura e gravação em um arquivo. Todos os métodos na estrutura de Arquivo retornam uma variante da enumeração io :: Result.

Os métodos comumente usados da estrutura de arquivo estão listados na tabela abaixo -

Sr. Não	Módulo	Método	Assinatura	Descrição
1	std :: fs :: File	abrir()	pub fn open <P: AsRef> (caminho: P) -> Resultado	O método open static pode ser usado para abrir um arquivo no modo somente leitura.
2	std :: fs :: File	crio()	pub fn create <P: AsRef> (caminho: P) -> Resultado	O método estático abre um arquivo no modo somente gravação. Se o arquivo já existia, o conteúdo antigo é destruído. Caso contrário, um novo arquivo será criado.
3	std :: fs :: remove_file	remover arquivo()	pub fn remove_file <P: AsRef> (caminho: P) -> Resultado <()>	Remove um arquivo do sistema de arquivos. Não há garantia de que o arquivo será excluído imediatamente.
4	std :: fs :: OpenOptions	acrescentar()	pub fn append (& mut self, append: bool) -> & mut OpenOptions	Define a opção para o modo de acréscimo do arquivo.
5	std :: io :: Writes	write_all ()	fn write_all (& mut self, buf: & [u8]) -> Resultado <()>	Tenta gravar um buffer inteiro nesta gravação.
6	std :: io :: Read	read_to_string ()	fn read_to_string (& mut self, buf: & mut String) -> Resultado	Lê todos os bytes até EOF nesta fonte, acrescentando-os ao buf.

Gravar em um arquivo

Vejamos um exemplo para entender como escrever um arquivo.

O programa a seguir cria um arquivo 'data.txt'. O método create () é usado para criar um arquivo. O método retorna um identificador de arquivo se o arquivo for criado com êxito. A função write_all da última linha gravará bytes no arquivo recém-criado. Se alguma das operações falhar, a função expect () retornará uma mensagem de erro.

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" );
}

Resultado

data written to file

Ler de um arquivo

O programa a seguir lê o conteúdo de um arquivo data.txt e o imprime no console. A função "abrir" é usada para abrir um arquivo existente. Um caminho absoluto ou relativo para o arquivo é passado para a função open () como parâmetro. A função open () lança uma exceção se o arquivo não existir ou se não estiver acessível por qualquer motivo. Se for bem-sucedido, um identificador de arquivo para tal arquivo é atribuído à variável "arquivo".

A função "read_to_string" do identificador "arquivo" é usada para ler o conteúdo desse arquivo em uma variável de string.

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);
}

Resultado

Hello World
TutorialsPoint

Excluir um arquivo

O exemplo a seguir usa a função remove_file () para excluir um arquivo. A função expect () retorna uma mensagem personalizada caso ocorra um erro.

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

Resultado

file is removed

Anexar dados a um arquivo

A função append () grava dados no final do arquivo. Isso é mostrado no exemplo abaixo -

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");
}

Resultado

file append success

Copiar um arquivo

O exemplo a seguir copia o conteúdo de um arquivo para um novo arquivo.

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; }
   }
}

Execute o programa acima como main.exe data.txt datacopy.txt . Dois argumentos de linha de comando são passados durante a execução do arquivo -

o caminho para o arquivo de origem
o arquivo de destino

↰ Previous page Next page ↱