Rust:
Escrevendo um arquivo de texto

Como fazer:

A biblioteca padrão do Rust fornece ferramentas robustas para manipulação de arquivos, encapsuladas principalmente dentro dos módulos std::fs e std::io. Aqui está um exemplo básico para criar e escrever em um arquivo de texto:

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

fn main() -> std::io::Result<()> {
    let mut file = File::create("hello.txt")?;
    file.write_all(b"Hello, world!")?;
    Ok(())
}

Depois de executar esse código, você encontrará um arquivo chamado hello.txt com o conteúdo “Hello, world!”.

Para cenários mais complexos, como acrescentar a um arquivo ou lidar com dados maiores de forma eficiente, o Rust oferece funcionalidades adicionais. Veja como acrescentar texto a um arquivo existente:

use std::fs::OpenOptions;
use std::io::prelude::*;

fn main() -> std::io::Result<()> {
    let mut file = OpenOptions::new()
        .write(true)
        .append(true)
        .open("hello.txt")?;
        
    file.write_all(b" Adding more text.")?;
    Ok(())
}

Ao executar isso, será adicionado " Adding more text." ao final do hello.txt.

Em alguns casos, o uso de bibliotecas de terceiros pode simplificar as operações de arquivo. A crate serde, combinada com serde_json, por exemplo, permite serializar e desserializar estruturas de dados para e a partir do formato JSON, oferecendo uma abordagem de alto nível para escrever arquivos:

use serde::{Serialize, Deserialize};
use serde_json;
use std::fs::File;

#[derive(Serialize, Deserialize)]
struct User {
    id: u32,
    name: String,
}

fn main() -> std::io::Result<()> {
    let user = User { id: 1, name: "Jane Doe".into() };
    let file = File::create("user.json")?;
    serde_json::to_writer(file, &user)?;
    Ok(())
}

Após executar o código acima, user.json conterá uma representação em JSON da struct User. Note que usar serde e serde_json requer a adição dessas crates ao seu Cargo.toml.

Escrever arquivos de texto em Rust, seja através da biblioteca padrão ou com a ajuda de crates externas, é uma maneira direta, mas poderosa, de gerenciar a persistência de dados em suas aplicações.