Arquivos e IO do Rust

Este capítulo introduce a linguagem Rust/O operação.

Receber parâmetros de linha de comando

Os programas de linha de comando são a forma mais básica de existência de programas de computador, quase todas as operações de sistema suportam programas de linha de comando e baseiam a execução de programas visuais no mecanismo de linha de comando.

Os programas de linha de comando devem ser capazes de aceitar parâmetros do ambiente de linha de comando, esses parâmetros geralmente são separados por espaços após um comando na linha de comando.

Em muitos idiomas (como Java e C/C++Os parâmetros de ambiente são passados para o programa como parâmetros do main (requentemente um array de strings), mas no Rust, o main é uma função sem parâmetros, os parâmetros de ambiente precisam ser obtidos pelo desenvolvedor através do módulo std::env, o processo é muito simples:

fn main() {
　　　　let args = std::env::args();
　　　　println!("{:?}", args);
}

Agora execute o programa diretamente:

Args { inner: ["D:\\rust\\greeting\\target\\debug\\greeting.exe"] }

Talvez o resultado que você obter seja muito maior do que este, isso é normal, o resultado contém um array inner na estrutura Args, que contém apenas uma string única, representando o local atual do programa em execução.

Mas essa estrutura de dados é difícil de entender, não se preocupe, podemos simplesmente percorrê-la:

fn main() {
　　　　let args = std::env::args();
　　　　for arg in args {
　　　　　　　　println!("{}", arg);
　　　　}
}

Resultados da execução:

D:\rust\greeting\target\debug\greeting.exe

Os parâmetros geralmente são usados para serem percorridos, não é?

Agora vamos abrir o launch.json que não usamos há muito tempo, encontrar "args": [], aqui podemos configurar os parâmetros de execução, vamos escrever "args": ["first", "second"]", então salvar e executar novamente o programa anterior, o resultado da execução:

D:\rust\greeting\target\debug\greeting.exe
first
second

Como um verdadeiro programa de linha de comando, nunca usamos ele, e como um tutorial de linguagem, não vamos descrever como executar programas Rust via linha de comando. Mas se você for um desenvolvedor treinado, deve ser capaz de encontrar o local do arquivo executável, pode tentar entrar no diretório e usar comandos de linha de comando para testar se o programa aceita parâmetros de ambiente de linha de comando.

Entrada de linha de comando

Capítulos anteriores detalharam como usar a saída da linha de comando, devido às necessidades de aprendizado da linguagem, a ausência de saída impossibilita a depuração do programa. No entanto, obter informações de entrada da linha de comando para um programa de linha de comando é ainda muito importante.

No Rust, o módulo std::io fornece funcionalidades relacionadas à entrada padrão (considerada entrada da linha de comando):

use std::io::stdin;
fn main() {
let mut str_buf = String::new();
　　　　stdin().read_line(&mut str_buf)
　　　　　　　　.expect("Falha ao ler linha.");
　　　　println!("Sua linha de entrada é 
{}", str_buf);
}

Fazer o ambiente do VSCode suportar entrada de linha de comando é uma tarefa muito complicada, envolvendo problemas de plataforma e problemas de depuração, então simplesmente executamos o programa no terminal do VSCode. No comando de linha, execute:

D:\rust\greeting> cd ./target/debug
D:\rust\greeting\target\debug> ./greeting.exe
w3codebox
Sua linha de entrada é　
w3codebox

std::io::Stdio contém o método read_line, que pode ler uma linha de string para o buffer, os valores de retorno são do tipo enum Result, usado para passar erros que podem ocorrer na leitura, então é comum usar as funções expect ou unwrap para lidar com erros.

Atenção：A biblioteca padrão do Rust ainda não fornece um método direto para ler números ou dados formatados da linha de comando, então podemos ler uma linha de string e usar funções de reconhecimento de string para processar os dados.

Leitura de arquivo

Nós criamos um arquivo text.txt na pasta D:\ do computador, cujo conteúdo é o seguinte:

Este é um arquivo de texto.

Este é um programa que lê o conteúdo de um arquivo de texto para uma string:

use std::fs;
fn main() {
　　　　let text = fs::read_to_string("D:\\text.txt").unwrap();
　　　　println!("{}", text);
}

Resultados da execução:

Este é um arquivo de texto.

Ler um arquivo inteiro que pode ser contido na memória em Rust é uma tarefa extremamente simples, o método read_to_string do módulo std::fs pode facilmente completar a leitura de arquivos de texto.

Mas se o arquivo a ser lido for um arquivo binário, podemos usar a função std::fs::read para ler u8 conjunto de tipos:

use std::fs;
fn main() {
　　　　let content = fs::read("D:\\text.txt").unwrap();
　　　　println!("{:?}", content);
}

Resultados da execução:

[84,　104,　105,　115,　32,　105,　115,　32,　97,　32,　116,　101,　120,　116,　32,　102,　105,　108,　101,　46]

Os dois métodos acima são leituras únicas, muito adequados para o desenvolvimento de aplicações Web. No entanto, para alguns programas de baixo nível, o modo de leitura tradicional de fluxo ainda não pode ser substituído, pois, na maioria dos casos, o tamanho do arquivo pode ser muito maior que a capacidade da memória.

Modo de leitura de fluxo de arquivo no Rust:

use std::io::prelude::*;
use std::fs;
fn main() {
　　　　let mut buffer = [0u8;　5];
　　　　let mut file = fs::File::open("D:\\text.txt").unwrap();
　　　　file.read(&mut buffer).unwrap();
　　　　println!("{:?}", buffer);
　　　　file.read(&mut buffer).unwrap();
　　　　println!("{:?}", buffer);
}

Resultados da execução:

[84,　104,　105,　115,　32]　
[105,　115,　32,　97,　32]

A classe File do módulo std::fs é uma classe que descreve arquivos, pode ser usada para abrir arquivos, e após abrir o arquivo, podemos usar o método read do File para ler alguns bytes do arquivo para o buffer (o buffer é um u8 de array), o número de bytes lidos é igual ao comprimento do buffer.

Atenção: O VSCode ainda não possui a função de adicionar automaticamente referências à biblioteca padrão, então possivelmente, erros como "função ou método inexistente" podem ser problemas de referência à biblioteca padrão. Podemos consultar os comentários da documentação da biblioteca padrão (ao passar o mouse sobre eles) para adicionar manualmente a biblioteca padrão.

O método open da std::fs::File abre o arquivo em modo "somente leitura" e não há método de fechar correspondente, pois o compilador Rust pode fechar automaticamente o arquivo quando ele não for mais usado.

Escrita de arquivo

A escrita de arquivo é dividida em escrita única e escrita de fluxo. A escrita de fluxo requer abrir o arquivo, e as maneiras de abrir são "criar" (create) e "adicionar" (append).

Escrita única:

use std::fs;
fn main() {
　　　　fs::write("D:\\text.txt", "FROM　RUST　PROGRAM")
　　　　　　　　.unwrap();
}

Isso é tão simples e conveniente quanto uma leitura única. Após a execução do programa, o conteúdo do arquivo D:\text.txt será reescrito como FROM RUST PROGRAM. Portanto, use a escrita única com cautela! Isso excluirá diretamente o conteúdo do arquivo (independentemente do tamanho do arquivo). Se o arquivo não existir, ele será criado.

Se desejar escrever o conteúdo do arquivo de forma streaming, você pode usar o método create da std::fs::File:

use std::io::prelude::*;
use std::fs::File;
fn main() {
　　　　let mut file = File::create("D:\\text.txt").unwrap();
　　　　file.write(b"FROM RUST PROGRAM").unwrap();
}

Este programa é equivalente ao programa anterior.

Atenção：O arquivo aberto deve estar armazenado em uma variável mutável para que possamos usar os métodos de File!

Não existe método estático append na classe File, mas podemos usar OpenOptions para abrir arquivos com métodos específicos:

use std::io::prelude::*;
use std::fs::OpenOptions;
fn main()　-> std::io::Result<()> {
　　　　
　　　　let mut file = OpenOptions::new()
　　　　　　　　　　　　.append(true).open("D:\\text.txt")?;
　　　　file.write(b"　APPEND　WORD")?;
　　　　Ok(())
}

Após a execução, o conteúdo do arquivo D:\text.txt será:

FROM RUST PROGRAM APPEND WORD

OpenOptions é um método flexível para abrir arquivos, que pode configurar permissões de abertura, além da permissão de append, ainda há permissões de leitura e escrita. Se quisermos abrir um arquivo com permissões de leitura e escrita, podemos escrever assim:

use std::io::prelude::*;
use std::fs::OpenOptions;
fn main()　-> std::io::Result<()> {
　　　　
　　　　let mut file = OpenOptions::new()
　　　　　　　　　　　　.read(true).write(true).open("D:\\text.txt")?;
　　　　file.write(b"COVER")?;
　　　　Ok(())
}

Após a execução, o conteúdo do arquivo D:\text.txt será:

COVERRUST PROGRAM APPEND WORD