2.6 📁 Работа с файлами и вводом-выводом

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

🎯 Зачем Go разработчику нужно уметь работать с файлами?

В современной разработке на Go файловые операции используются повсеместно:

Веб-приложения: Загрузка и обработка файлов от пользователей
Системные утилиты: Обработка логов, конфигурационных файлов
DevOps инструменты: Парсинг конфигураций, генерация отчётов
Data processing: Обработка CSV, JSON файлов с данными
Бэкапы и архивация: Создание резервных копий

Go особенно популярен для создания утилит командной строки именно благодаря удобной работе с файлами. Инструменты как Docker, Kubernetes, Terraform используют файловые операции в своей основе.

📚 Основные пакеты для работы с файлами

os — основной пакет

Пакет os предоставляет платформо-независимый интерфейс к операционной системе. Содержит основные функции для работы с файлами и директориями.

Ключевые функции:

os.Open() — открытие файла для чтения
os.Create() — создание нового файла
os.ReadFile() — чтение всего файла в память
os.WriteFile() — запись данных в файл

io — интерфейсы ввода-вывода

Пакет io определяет основные интерфейсы для операций ввода-вывода в Go. Он предоставляет абстракции, которые работают с любыми источниками данных.

Основные интерфейсы:

io.Reader — чтение данных
io.Writer — запись данных
io.Closer — закрытие ресурсов

bufio — буферизованный ввод-вывод

Пакет bufio предоставляет буферизованные операции ввода-вывода, которые более эффективны при работе с большими файлами.

📖 Чтение файлов: теория и практика

Простое чтение всего файла

Самый простой способ прочитать файл — загрузить его содержимое полностью в память с помощью os.ReadFile(). Этот метод идеален для небольших файлов (до нескольких мегабайт), таких как конфигурационные файлы, JSON настройки или короткие текстовые документы.

Преимущества: Простота использования, весь файл доступен сразу
Недостатки: Может потреблять много памяти для больших файлов

data, err := os.ReadFile("config.txt")
if err != nil {
    fmt.Printf("Ошибка: %v\n", err)
    return
}
fmt.Printf("Содержимое: %s\n", string(data))

Когда использовать: Небольшие конфигурационные файлы, JSON/YAML настройки, короткие текстовые файлы.

Построчное чтение для больших файлов

Для обработки больших файлов (гигабайты логов, массивные CSV файлы) лучше читать их построчно с помощью bufio.Scanner. Это позволяет обрабатывать файлы любого размера, используя минимум памяти.

Ключевые особенности:

Память: Используется только для текущей строки
Производительность: Эффективно для больших файлов
Гибкость: Можно обрабатывать данные в реальном времени
Применение: Анализ логов, обработка CSV, парсинг больших текстовых файлов

func readFileByLines(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return fmt.Errorf("не удалось открыть: %w", err)
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        fmt.Println(scanner.Text())
        // Обработка каждой строки
    }
    return scanner.Err()
}

Когда использовать: Большие лог-файлы, CSV данные, текстовые файлы размером в гигабайты.

✍️ Запись файлов: от простого к сложному

Простая запись данных

Для записи небольших объёмов данных используйте os.WriteFile() — самый простой способ создать файл с содержимым. Эта функция автоматически создаёт файл (или перезаписывает существующий), записывает данные и закрывает файл.

Особенности os.WriteFile():

Атомарность: Операция выполняется полностью или не выполняется вообще
Перезапись: Существующий файл будет полностью перезаписан
Права доступа: Можно задать права доступа к файлу (например, 0644)
Безопасность: Автоматическое управление ресурсами

content := "server_port=8080\ndatabase_url=postgresql://localhost/myapp"
err := os.WriteFile("config.txt", []byte(content), 0644)
if err != nil {
    return fmt.Errorf("ошибка записи: %w", err)
}

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

Добавление данных в конец файла

Часто в приложениях нужно дописывать данные в существующий файл, не перезаписывая его содержимое. Это критически важно для логирования, ведения истории операций, сбора метрик и других сценариев накопления данных.

Флаги для os.OpenFile():

os.O_APPEND — добавлять данные в конец файла
os.O_CREATE — создать файл, если он не существует
os.O_WRONLY — открыть только для записи
os.O_RDWR — открыть для чтения и записи

Такой подход гарантирует, что новые данные не потеряются и не перезапишут существующую информацию.

func appendToLogFile(message string) error {
    file, err := os.OpenFile("app.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        return err
    }
    defer file.Close()
    
    timestamp := time.Now().Format("15:04:05")
    _, err = file.WriteString(fmt.Sprintf("[%s] %s\n", timestamp, message))
    return err
}

Флаги открытия файла:

os.O_APPEND — добавлять в конец
os.O_CREATE — создать если не существует
os.O_WRONLY — только для записи

⌨️ Работа с пользовательским вводом

Чтение ввода пользователя

Интерактивные консольные приложения часто требуют ввода данных от пользователя. Go предлагает несколько подходов для работы с пользовательским вводом, каждый со своими преимуществами.

Выбор метода ввода:

bufio.Reader — для сложного ввода, многострочного текста, обработки пробелов
fmt.Scan() — для простого ввода отдельных значений (числа, простые строки)
fmt.Scanln() — для ввода до конца строки
fmt.Scanf() — для форматированного ввода по шаблону

reader := bufio.NewReader(os.Stdin)
fmt.Print("Имя: ")
name, _ := reader.ReadString('\n')
name = strings.TrimSpace(name)
fmt.Printf("Привет, %s!\n", name)

Простой ввод с fmt.Scan

Для простых случаев можно использовать fmt.Scan():

var name string
var age int
fmt.Print("Имя: ")
fmt.Scan(&name)
fmt.Print("Возраст: ")
fmt.Scan(&age)
fmt.Printf("%s, %d лет\n", name, age)

🔍 Работа с файловой системой

Проверка существования файлов и папок

Перед операциями с файлами критически важно проверить их существование, чтобы избежать ошибок и неожиданного поведения программы. Go предоставляет удобные функции для этого.

Функция os.Stat() возвращает информацию о файле или папке. Если объект не существует, возвращается специальная ошибка, которую можно проверить с помощью os.IsNotExist().

Практическое применение:

Проверка конфигурационных файлов перед запуском приложения
Создание резервных копий только существующих файлов
Валидация путей перед копированием или перемещением файлов

func checkFileExists(filename string) bool {
    info, err := os.Stat(filename)
    if os.IsNotExist(err) {
        return false
    }
    return !info.IsDir()
}

if checkFileExists("data.txt") {
    fmt.Println("✅ Файл существует")
}

Создание директорий

// Создание одной папки
err := os.Mkdir("logs", 0755)

// Создание вложенной структуры
err = os.MkdirAll("data/backups/2025", 0755)

Получение списка файлов

entries, err := os.ReadDir(".")
if err != nil {
    return err
}

for _, entry := range entries {
    if entry.IsDir() {
        fmt.Printf("📁 %s/\n", entry.Name())
    } else {
        fmt.Printf("📄 %s\n", entry.Name())
    }
}

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

Правильная обработка ошибок критически важна при работе с файлами, так как множество вещей может пойти не так.

Типичные ошибки и их обработка

data, err := os.ReadFile(filename)
if err != nil {
    if os.IsNotExist(err) {
        return fmt.Errorf("файл не существует")
    }
    if os.IsPermission(err) {
        return fmt.Errorf("нет прав доступа")
    }
    return err
}
fmt.Printf("Прочитано %d байт\n", len(data))

Отложенное закрытие файлов

Всегда используйте defer для закрытия файлов:

file, err := os.Open(filename)
if err != nil {
    return err
}
defer file.Close() // ✅ Гарантированное закрытие
// Работа с файлом...

🏗️ Практический пример: Простой анализатор логов

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

Что делает анализатор:

Читает большой лог-файл построчно (эффективное использование памяти)
Подсчитывает различные типы сообщений (ERROR, WARN, INFO)
Собирает статистику по IP-адресам
Использует структуру данных для организации результатов
Демонстрирует обработку ошибок и работу с файловыми ресурсами

type LogStats struct {
    TotalLines, ErrorCount, WarningCount int
    UniqueIPs map[string]int
}

func analyzeLogFile(filename string) (*LogStats, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    stats := &LogStats{UniqueIPs: make(map[string]int)}
    scanner := bufio.NewScanner(file)
    
    for scanner.Scan() {
        line := scanner.Text()
        stats.TotalLines++
        
        if strings.Contains(line, "ERROR") {
            stats.ErrorCount++
        } else if strings.Contains(line, "WARN") {
            stats.WarningCount++
        }
        
        // Простое извлечение IP
        parts := strings.Fields(line)
        if len(parts) > 0 {
            stats.UniqueIPs[parts[0]]++
        }
    }
    return stats, scanner.Err()
}

💡 Лучшие практики работы с файлами в Go

1. Всегда проверяйте ошибки

Никогда не игнорируйте ошибки при работе с файлами. Используйте if err != nil для корректной обработки.

2. Используйте defer для закрытия ресурсов

defer file.Close() гарантирует, что файл будет закрыт даже при возникновении ошибки.

3. Выбирайте правильный метод для размера файла

Маленькие файлы (<1MB): os.ReadFile()
Большие файлы: bufio.Scanner с построчным чтением
Огромные файлы: потоковая обработка с io.Reader

4. Используйте правильные права доступа

0644 — владелец читает/пишет, остальные только читают
0755 — для директорий и исполняемых файлов
0600 — только владелец имеет доступ

5. Проверяйте существование перед операциями

Используйте os.Stat() для проверки существования файлов и папок перед операциями с ними.

🚀 Что изучать дальше

После освоения базовых файловых операций изучите:

Работа с JSON/XML файлами — сериализация структур данных
Архивация — пакеты archive/zip, compress/gzip
Файловые шаблоны — пакет text/template
Мониторинг файлов — отслеживание изменений в реальном времени
Работа с CSV — пакет encoding/csv

🔍 Проверь себя

В чём разница между os.ReadFile() и построчным чтением?
Зачем использовать defer file.Close()?
Как проверить существование файла?
Какие права доступа 0644 означают?
Как добавить данные в конец существующего файла?

📌 Главное из главы

os.ReadFile() для небольших файлов, bufio.Scanner для больших
Всегда закрывайте файлы с помощью defer file.Close()
Проверяйте ошибки — файловые операции часто завершаются неудачей
Используйте правильные флаги при открытии файлов для записи
Файловые операции в Go безопасны и кроссплатформенны

Работа с файлами — основа для создания полезных утилит и приложений на Go!

🎯 Зачем Go разработчику нужно уметь работать с файлами?#

📚 Основные пакеты для работы с файлами#

os — основной пакет#

io — интерфейсы ввода-вывода#

bufio — буферизованный ввод-вывод#

📖 Чтение файлов: теория и практика#

Простое чтение всего файла#

Построчное чтение для больших файлов#

✍️ Запись файлов: от простого к сложному#

Простая запись данных#

Добавление данных в конец файла#

⌨️ Работа с пользовательским вводом#

Чтение ввода пользователя#

Простой ввод с fmt.Scan#

🔍 Работа с файловой системой#

Проверка существования файлов и папок#

Создание директорий#

Получение списка файлов#

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

Типичные ошибки и их обработка#

Отложенное закрытие файлов#

🏗️ Практический пример: Простой анализатор логов#

💡 Лучшие практики работы с файлами в Go#

1. Всегда проверяйте ошибки#

2. Используйте defer для закрытия ресурсов#

3. Выбирайте правильный метод для размера файла#

4. Используйте правильные права доступа#

5. Проверяйте существование перед операциями#

🚀 Что изучать дальше#

🔍 Проверь себя#

📌 Главное из главы#