🦀 Rust

Trabalhando com Arquivos em Rust: Um Guia Detalhado

Lição 20 / 35 • Leitura completa da teoria

Что это такое и зачем? (аналогия из реальной жизни)

Представь, что ты пишешь сочинение в тетради. Пока ты пишешь — информация живёт у тебя в голове и на кончике ручки. Но как только ты закрываешь тетрадь и убираешь её в рюкзак — информация сохраняется. Завтра ты можешь открыть тетрадь снова и продолжить писать. То же самое происходит в программировании: когда программа работает, все данные живут в оперативной памяти (как в голове). Но как только программа закрывается — память очищается. Чтобы данные остались навсегда, их нужно сохранить в файл (как в тетрадь).

Работа с файлами — это умение программы:

Читать информацию из файлов (открыть тетрадь и прочитать)
Записывать информацию в файлы (написать в тетради)
Дополнять файлы (дописать на новой строке)
Удалять и перемещать файлы (вырвать страницу или переложить тетрадь в другую папку)

Зачем это нужно в реальной жизни? Представь игру, которая сохраняет твой прогресс. Или текстовый редактор, в котором ты печатаешь эту статью. Или приложение для заметок на телефоне. Всё это — работа с файлами. Без неё любая программа была бы как рыба, которая забывает всё через секунду.

💡 Важно понять: Файлы бывают разные. Текстовые (.txt, .md, .html), бинарные (.png, .mp3, .exe), структурированные (.json, .csv). В этой статье мы научимся работать с текстовыми файлами — это основа основ.

Теория: как это работает изнутри

Когда программа хочет прочитать файл, происходит целая цепочка событий. Давай разберём её по шагам, как механизм часов.

Шаг 1: Путь к файлу

Сначала программа должна знать, где лежит файл. Это как адрес дома. Путь бывает:

Абсолютный: полный адрес от корня диска. Например, C:UsersИмяDocumentsfile.txt (Windows) или /home/user/file.txt (Linux/Mac).
Относительный: адрес относительно текущей папки, где запущена программа. Например, data/file.txt — значит, в папке data рядом с программой.

Шаг 2: Открытие файла (дескриптор)

Программа просит операционную систему: «Открой мне этот файл!». Операционная система проверяет: существует ли файл? Есть ли права на чтение? Если всё хорошо — она даёт программе специальный номерок, который называется дескриптор файла. Это как номерок в гардеробе: по нему ты потом получишь свою куртку обратно.

Шаг 3: Буферизация

Чтение с диска — очень медленное (по меркам процессора). Представь, что ты читаешь книгу, но каждую букву нужно идти в библиотеку за новой страницей. Глупо, правда? Поэтому программа читает файл кусками — буферами. Она загружает в оперативную память сразу большой кусок файла, а потом уже из него берёт данные по мере необходимости.

Шаг 4: Чтение данных

Теперь программа может читать данные из буфера. Она может читать:

Целиком: весь файл одной командой (удобно для маленьких файлов)
По строкам: одну строку за другой (удобно для логов, конфигов)
По байтам: по одному символу или кусочку (для бинарных файлов)

Шаг 5: Закрытие файла

Когда программа закончила читать, она должна сказать операционной системе: «Всё, я закончил, забери номерок». Это называется закрытие файла. Если этого не сделать, может произойти утечка ресурсов — как если бы ты брал номерки в гардеробе и не возвращал их. Рано или поздно номерки закончатся.

⚠️ Важно: В Rust закрытие файла происходит автоматически, когда переменная с файлом выходит из области видимости. Но лучше не полагаться на это и закрывать явно, когда это возможно.

Ошибки при работе с файлами

Файловые операции — это одна из самых ненадёжных вещей в программировании. Почему? Потому что многое зависит от внешнего мира:

Файл может не существовать
Файл может быть занят другой программой
Может не быть прав доступа
Диск может быть переполнен
Файл может быть повреждён

Поэтому в Rust работа с файлами всегда возвращает Result — специальный тип, который говорит: «Или получилось, или произошла ошибка». Игнорировать ошибки нельзя — программа должна быть готова к любым сюрпризам.

Синтаксис в Rust: все формы и варианты

Rust — язык строгий и безопасный. Он не позволит тебе просто так взять и прочитать файл. Нужно явно указать: «Я хочу прочитать этот файл, и я знаю, что может пойти не так». Давай разберём все инструменты для чтения файлов.

Основные модули и типы

Модуль/Тип	Описание	Когда использовать
`std::fs`	Модуль для работы с файловой системой	Всегда, когда работаешь с файлами
`std::fs::File`	Структура, представляющая открытый файл	Когда нужно точное управление чтением
`std::io::Read`	Трейт (интерфейс) для чтения	Когда читаешь из любого источника (файл, сеть, буфер)
`std::io::BufRead`	Трейт для буферизированного чтения	Когда читаешь по строкам
`std::io::BufReader`	Обёртка для буферизированного чтения	Почти всегда, когда читаешь большие файлы

Методы для чтения файлов

Метод	Описание	Возвращает
`File::open(path)`	Открывает файл только для чтения	`Result<File>`
`file.read_to_string(&mut buffer)`	Читает весь файл в строку	`Result<usize>` (количество прочитанных байт)
`file.read(&mut buffer)`	Читает порцию данных в байтовый буфер	`Result<usize>`
`BufReader::new(file)`	Создаёт буферизированного читателя	`BufReader<File>`
`reader.read_line(&mut line)`	Читает одну строку	`Result<usize>`
`reader.lines()`	Возвращает итератор по строкам	`Lines<BufReader>`
`std::fs::read_to_string(path)`	Удобная функция: открыть и прочитать целиком	`Result<String>`
`std::fs::read(path)`	Прочитать файл как байты	`Result<Vec<u8>>`

Обработка ошибок: unwrap, expect, match, ?

В Rust есть несколько способов обработать ошибку при чтении файла:

Способ	Пример	Что происходит при ошибке
`unwrap()`	`File::open("file.txt").unwrap()`	Программа паникует (аварийно завершается) с сообщением об ошибке
`expect("сообщение")`	`File::open("file.txt").expect("Не удалось открыть файл")`	То же, но с твоим сообщением
`match`	`match File::open("file.txt") { Ok(file) => ..., Err(e) => ... }`	Полный контроль над ошибкой
`?` (оператор)	`let file = File::open("file.txt")?;`	Ошибка передаётся наверх (функция должна возвращать Result)

🎯 Совет для новичков: Пока учишься — используй expect(). Он даёт понятное сообщение об ошибке. В серьёзных проектах используй match или оператор ?.

Примеры кода — от простого к сложному

Пример 1: Чтение всего файла одной строкой (самый простой способ)

// Самая простая программа для чтения файла
// Используем удобную функцию read_to_string из модуля std::fs

use std::fs;

fn main() {
    // Пытаемся прочитать файл "hello.txt"
    // Если файла нет — программа упадёт с ошибкой
    let contents = fs::read_to_string("hello.txt")
        .expect("Не удалось прочитать файл hello.txt");
    
    // Выводим содержимое файла на экран
    println!("Содержимое файла:
{}", contents);
}

Объяснение:

use std::fs; — подключаем модуль для работы с файловой системой
fs::read_to_string("hello.txt") — открывает файл и читает всё содержимое в строку
.expect(...) — если произошла ошибка, программа завершится с этим сообщением
println! — выводим содержимое на экран

Пример 2: Чтение с обработкой ошибок через match

// Показываем, как правильно обрабатывать ошибки
// без аварийного завершения программы

use std::fs;

fn main() {
    // Пытаемся прочитать файл
    let result = fs::read_to_string("config.txt");
    
    // Используем match для обработки двух вариантов
    match result {
        Ok(contents) => {
            // Всё хорошо — файл прочитан
            println!("Конфигурация загружена:");
            println!("{}", contents);
        }
        Err(error) => {
            // Произошла ошибка — сообщаем пользователю
            println!("Ошибка при чтении файла: {}", error);
            println!("Будем использовать стандартные настройки.");
        }
    }
}

Объяснение:

match result — проверяем, что вернула функция
Ok(contents) — если всё хорошо, contents содержит строку с файлом
Err(error) — если ошибка, error содержит описание проблемы
Программа не падает — она просто сообщает об ошибке и продолжает работу

Пример 3: Чтение файла по строкам (для больших файлов)

// Когда файл большой (например, лог на 1 ГБ),
// читать его целиком — плохая идея.
// Читаем построчно!

use std::fs::File;
use std::io::{BufRead, BufReader};

fn main() {
    // Открываем файл
    let file = File::open("large_log.txt")
        .expect("Файл large_log.txt не найден");
    
    // Создаём буферизированного читателя
    // Он будет читать файл кусками, а не по одному байту
    let reader = BufReader::new(file);
    
    // lines() возвращает итератор по строкам
    // Каждая строка — это Result
    for (line_number, line_result) in reader.lines().enumerate() {
        // Обрабатываем каждую строку
        match line_result {
            Ok(line) => {
                // Выводим номер строки и её содержимое
                println!("Строка {}: {}", line_number + 1, line);
            }
            Err(error) => {
                // Если строка не прочиталась — сообщаем об ошибке
                println!("Ошибка при чтении строки {}: {}", line_number + 1, error);
            }
        }
    }
}

Объяснение:

BufReader::new(file) — оборачиваем файл в буферизированного читателя
reader.lines() — получаем итератор, который выдаёт строки одну за другой
.enumerate() — добавляем номер строки (начинается с 0)
Файл не загружается в память целиком — экономим ресурсы

Пример 4: Чтение бинарного файла (байты)

// Не все файлы — текстовые. Картинки, музыка, видео — это байты.
// Читаем файл как набор байтов.

use std::fs;

fn main() {
    // Читаем файл как вектор байтов (Vec)
    let bytes = fs::read("image.png")
        .expect("Не удалось прочитать файл image.png");
    
    // Выводим информацию о файле
    println!("Размер файла: {} байт", bytes.len());
    println!("Первый байт: {}", bytes[0]);
    println!("Последний байт: {}", bytes[bytes.len() - 1]);
    
    // Проверяем, похоже ли это на PNG-файл
    // PNG-файлы начинаются с байтов: 137, 80, 78, 71
    if bytes.len() >= 4 && bytes[0] == 137 && bytes[1] == 80 
        && bytes[2] == 78 && bytes[3] == 71 {
        println!("Это похоже на PNG-изображение!");
    } else {
        println!("Это не PNG-файл (или файл слишком маленький)");
    }
}

Объяснение:

fs::read() — читает файл как вектор байтов
Vec<u8> — это динамический массив беззнаковых 8-битных чисел (0-255)
Мы можем проверять отдельные байты, чтобы определить тип файла

Пример 5: Чтение с использованием трейта Read (гибкий подход)

// Трейт Read — это интерфейс для чтения из любого источника.
// Файл, сетевой сокет, буфер в памяти — всё это можно читать одинаково.

use std::fs::File;
use std::io::Read;

fn main() {
    // Открываем файл
    let mut file = File::open("data.bin")
        .expect("Файл data.bin не найден");
    
    // Создаём буфер на 1024 байта (1 КБ)
    let mut buffer = [0u8; 1024];
    
    // Читаем порцию данных в буфер
    // read() возвращает количество реально прочитанных байт
    let bytes_read = file.read(&mut buffer)
        .expect("Ошибка при чтении файла");
    
    println!("Прочитано {} байт", bytes_read);
    println!("Первые 10 байт: {:?}", &buffer[..10]);
    
    // Можно читать ещё, пока не закончится файл
    // read() вернёт Ok(0), когда файл закончится
    let mut total_bytes = bytes_read;
    loop {
        let bytes = file.read(&mut buffer)
            .expect("Ошибка при чтении");
        if bytes == 0 {
            break; // Файл закончился
        }
        total_bytes += bytes;
        println!("Прочитано ещё {} байт (всего: {})", bytes, total_bytes);
    }
}

Объяснение:

let mut file — файл должен быть изменяемым, потому что чтение меняет его внутреннее состояние
[0u8; 1024] — создаём массив из 1024 нулевых байт
file.read(&mut buffer) — читаем данные в буфер, возвращает количество прочитанных байт
Цикл loop читает файл кусками, пока не закончится

Пример 6: Чтение CSV-файла (простой парсинг)

// CSV — это формат, где данные разделены запятыми.
// Часто используется для таблиц и баз данных.

use std::fs::File;
use std::io::{BufRead, BufReader};

fn main() {
    let file = File::open("students.csv")
        .expect("Файл students.csv не найден");
    let reader = BufReader::new(file);
    
    println!("Список студентов:");
    println!("{:<20} {:<10} {:<5}", "Имя", "Группа", "Оценка");
    println!("{}", "-".repeat(37));
    
    // Пропускаем первую строку (заголовок)
    for (index, line_result) in reader.lines().enumerate() {
        let line = line_result.expect("Ошибка при чтении строки");
        
        // Пропускаем заголовок (первую строку)
        if index == 0 {
            continue;
        }
        
        // Разделяем строку по запятым
        let fields: Vec<&str> = line.split(',').collect();
        
        // Проверяем, что у нас есть все три поля
        if fields.len() >= 3 {
            let name = fields[0].trim();
            let group = fields[1].trim();
            let grade = fields[2].trim();
            
            println!("{:<20} {:<10} {:<5}", name, group, grade);
        } else {
            println!("Ошибка в строке {}: неверный формат", index + 1);
        }
    }
}

Объяснение:

line.split(',') — разбиваем строку на части по запятой
.collect() — собираем части в вектор
.trim() — удаляем лишние пробелы вокруг данных
Проверяем, что в строке достаточно полей, чтобы избежать ошибок

Пример 7: Чтение конфигурационного файла (с обработкой ошибок)

// Реальная задача: прочитать конфигурационный файл
// и извлечь из него настройки.

use std::fs;
use std::collections::HashMap;

fn main() {
    // Пытаемся прочитать конфиг
    let config = match fs::read_to_string("config.txt") {
        Ok(content) => content,
        Err(error) => {
            println!("Не удалось прочитать конфиг: {}", error);
            println!("Используем настройки по умолчанию.");
            String::new() // Пустая строка — нет конфига
        }
    };
    
    // Парсим конфиг в HashMap (словарь)
    let settings = parse_config(&config);
    
    // Получаем значения с значениями по умолчанию
    let host = settings.get("host").map(|s| s.as_str()).unwrap_or("localhost");
    let port: u16 = settings.get("port")
        .and_then(|s| s.parse().ok())
        .unwrap_or(8080);
    let debug: bool = settings.get("debug")
        .map(|s| s == "true")
        .unwrap_or(false);
    
    println!("Настройки:");
    println!("  Хост: {}", host);
    println!("  Порт: {}", port);
    println!("  Отладка: {}", debug);
}

// Функция для парсинга конфига
// Формат: ключ = значение (по одному на строку)
fn parse_config(content: &str) -> HashMap {
    let mut map = HashMap::new();
    
    for line in content.lines() {
        let line = line.trim();
        
        // Пропускаем пустые строки и комментарии
        if line.is_empty() || line.starts_with('#') {
            continue;
        }
        
        // Ищем знак равенства
        if let Some(pos) = line.find('=') {
            let key = line[..pos].trim().to_string();
            let value = line[pos + 1..].trim().to_string();
            map.insert(key, value);
        } else {
            println!("Предупреждение: строка '{}' имеет неверный формат", line);
        }
    }
    
    map
}

Объяснение:

HashMap — словарь, где ключи — названия настроек, значения — их значения
.map() и .unwrap_or() — безопасно получаем значение или используем значение по умолчанию
.and_then() — цепочка операций, где каждая может вернуть None
Функция parse_config разбирает текст и игнорирует комментарии и пустые строки

Сравнение с Python: чем похоже и чем отличается

Если ты уже знаешь Python, тебе будет проще понять Rust. Но есть важные отличия, которые нужно запомнить.

Операция	Python	Rust
Чтение всего файла	`with open('file.txt') as f: content = f.read()`	`fs::read_to_string("file.txt")`
Чтение по строкам	`for line in f: print(line)`	`for line in reader.lines() { println!("{}", line); }`
Обработка ошибок	`try-except` (исключения)	`match` или `?` (Result)
Закрытие файла	Автоматически (with block)	Автоматически (при выходе из области видимости)
Буферизация	Автоматически (встроена)	Явно через BufReader
Чтение байтов	`f.read()` (возвращает строку или байты)	`fs::read()` (всегда байты)

Главные отличия:

Безопасность: Rust заставляет тебя обрабатывать все ошибки. В Python ты можешь забыть про try-except, и программа упадёт. В Rust компилятор не даст тебе забыть.
Явность: В Rust нужно явно указывать, буферизированное чтение тебе нужно или нет. В Python это скрыто внутри.
Производительность: Rust-код будет работать быстрее, но его нужно писать аккуратнее.
Сложность: Простые задачи в Python решаются одной строкой. В Rust — двумя-тремя. Но зато ты точно знаешь, что происходит.

🔑 Ключевая мысль: Python — это как велосипед: быстро учишься, легко ездить. Rust — как гоночный автомобиль: сложнее научиться, но больше контроля и скорости.

Типичные ошибки и подводные камни

Ошибка 1: Файл не найден

Самая частая ошибка новичков. Ты указываешь путь к файлу, а файла там нет. Или ты думаешь, что файл лежит рядом с программой, а на самом деле программа запускается из другой папки.

// ❌ Неправильно: программа упадёт, если файла нет
let content = fs::read_to_string("data.txt").unwrap();

// ✅ Правильно: обрабатываем ошибку
let content = match fs::read_to_string("data.txt") {
    Ok(c) => c,
    Err(e) => {
        eprintln!("Файл data.txt не найден: {}", e);
        String::new()
    }
};

Ошибка 2: Проблемы с кодировкой

Файлы могут быть в разных кодировках: UTF-8, UTF-16, Windows-1251. Rust по умолчанию читает как UTF-8. Если файл в другой кодировке — получишь ошибку.

// ❌ Неправильно: если файл в Windows-1251, будет ошибка
let content = fs::read_to_string("russian.txt").unwrap();

// ✅ Правильно: читаем как байты и конвертируем
use std::fs;
let bytes = fs::read("russian.txt").unwrap();
let content = String::from_utf8_lossy(&bytes); // Заменяет плохие символы на �

Ошибка 3: Забыли про права доступа

На Linux и Mac файлы могут быть защищены от чтения. Программа не сможет прочитать файл, если у неё нет прав.

// Ошибка: "Permission denied" (доступ запрещён)
// Решение: проверить права на файл или запустить программу от администратора
let content = fs::read_to_string("/etc/shadow").expect("Нет доступа");

Ошибка 4: Файл слишком большой

Попытка прочитать файл размером 10 ГБ в память — плохая идея. Программа либо упадёт с ошибкой "out of memory", либо замедлит весь компьютер.

// ❌ Неправильно для больших файлов
let content = fs::read_to_string("huge_file.log").unwrap();

// ✅ Правильно: читать по частям
let file = File::open("huge_file.log").unwrap();
let reader = BufReader::new(file);
for line in reader.lines() {
    // Обрабатываем каждую строку отдельно
}

Ошибка 5: Файл уже открыт другой программой

На Windows некоторые файлы блокируются, когда их открывает другая программа. Rust не сможет прочитать такой файл.

// Ошибка: "The process cannot access the file because it is being used by another process"
// Решение: закрыть программу, которая использует файл

Ошибка 6: Игнорирование ошибок через unwrap

Использовать unwrap() везде — плохая привычка. В учебных примерах это нормально, но в реальном коде программа не должна падать из-за отсутствия файла.

// ❌ Плохо: любая ошибка убьёт программу
let data = fs::read_to_string("config.txt").unwrap();

// ✅ Хорошо: программа сообщит об ошибке и продолжит работу
let data = fs::read_to_string("config.txt").unwrap_or_default();

Лучшие практики и советы профессионалов

1. Всегда используй BufReader для больших файлов

Если файл больше 1 МБ — используй буферизированное чтение. Это ускоряет работу в десятки раз.

// Плохо: читаем большой файл целиком
let content = fs::read_to_string("big_file.txt").unwrap();

// Хорошо: читаем через буфер
let file = File::open("big_file.txt").unwrap();
let reader = BufReader

← Anterior Tratamento de Erros e Exceções em Rust: Um Guia De Próximo → Métodos de Strings — Um Guia Completo em Rust: Um