Lendo Arquivos em Rust

Introdução

Neste laboratório, a função open é apresentada como uma forma de abrir um arquivo em modo de leitura somente, fornecendo o caminho para o arquivo desejado. A função retorna um objeto File que possui o descritor do arquivo e cuida do fechamento do arquivo quando não mais necessário.

Para usar a função open, é necessário importar os módulos necessários, como std::fs::File, std::io::prelude::*, e std::path::Path. O método File::open é então chamado com o caminho como argumento. Se o arquivo for aberto com sucesso, a função retorna um objeto Result<File, io::Error>, caso contrário, gera uma falha com uma mensagem de erro.

Uma vez que o arquivo esteja aberto, seu conteúdo pode ser lido usando o método read_to_string. Este método lê o conteúdo do arquivo para uma string e retorna um Result<usize, io::Error>. Se a operação de leitura for bem-sucedida, a string conterá o conteúdo do arquivo. Caso contrário, gera uma falha com uma mensagem de erro.

No exemplo fornecido, o conteúdo do arquivo hello.txt é lido e impresso no console. O traço drop é usado para garantir que o arquivo seja fechado quando o objeto file sai de escopo.

Nota: Se o laboratório não especificar um nome de arquivo, você pode usar qualquer nome de arquivo que desejar. Por exemplo, você pode usar main.rs, compilar e executar com rustc main.rs && ./main.

open

A função open pode ser usada para abrir um arquivo em modo de leitura somente.

Um objeto File possui um recurso, o descritor de arquivo, e cuida do fechamento do arquivo quando é dropado.

use std::fs::File;
use std::io::prelude::*;
use std::path::Path;

fn main() {
    // Cria um caminho para o arquivo desejado
    let path = Path::new("hello.txt");
    let display = path.display();

    // Abre o caminho em modo de leitura somente, retorna `io::Result<File>`
    let mut file = match File::open(&path) {
        Err(why) => panic!("não foi possível abrir {}: {}", display, why),
        Ok(file) => file,
    };

    // Lê o conteúdo do arquivo para uma string, retorna `io::Result<usize>`
    let mut s = String::new();
    match file.read_to_string(&mut s) {
        Err(why) => panic!("não foi possível ler {}: {}", display, why),
        Ok(_) => print!("{} contém:\n{}", display, s),
    }

    // `file` sai de escopo, e o arquivo "hello.txt" é fechado
}

Aqui está a saída esperada em caso de sucesso:

$ echo "Hello World!" > hello.txt
$ rustc open.rs && ./open
hello.txt contém:
Hello World!

(É recomendado testar o exemplo anterior em diferentes condições de falha: hello.txt não existe, ou hello.txt não é legível, etc.)

Resumo

Parabéns! Você concluiu o laboratório Open. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.