питон либ луна питонлиб солнце progerlib цветок

Changer le thème

Connexion Inscription
🐹 Go

Travailler avec les fichiers en Go (Golang) : guide détaillé

Leçon 20 / 35 • Lecture complète de la théorie

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

Представьте, что вы — библиотекарь. У вас есть огромное количество книг (данных). Когда вы хотите что-то запомнить или передать другому человеку, вы записываете это на лист бумаги и кладёте в папку. Потом, когда нужно вспомнить, вы открываете папку, берёте лист и читаете. Точно так же работает компьютер: чтобы сохранить информацию надолго (даже после выключения питания), он записывает её в файл на жёсткий диск или SSD. А чтобы потом эту информацию использовать, он её читает из файла.

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

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

В этой статье мы научимся читать файлы на языке Go (Golang). Мы разберёмся, как открыть файл, прочитать его содержимое целиком или по частям, и как правильно закрыть файл, чтобы не тратить ресурсы компьютера впустую.

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

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

Шаг 1: Запрос к операционной системе

Ваша программа (на Go) не может сама «потрогать» жёсткий диск. Она обращается к операционной системе (Windows, Linux, macOS) с просьбой: «Дай мне доступ к файлу с таким-то именем». Операционная система — это главный управляющий компьютером, который знает, где что лежит.

Шаг 2: Поиск файла

Операционная система ищет файл по указанному пути. Путь может быть абсолютным (начинается от корня диска, например, C:UsersИмяDocumentsdata.txt в Windows или /home/user/data.txt в Linux) или относительным (относительно текущей папки, где запущена программа, например, data.txt или folder/data.txt).

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

Если файл найден, операционная система создаёт специальный «номерок» — дескриптор файла (file descriptor). Это просто число, которое программа будет использовать для общения с файлом. Представьте, что вы пришли в гардероб, сдали куртку и получили номерок. Пока вы не вернёте номерок, куртка ваша. Точно так же, пока программа не «закроет» дескриптор, файл считается занятым.

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

Теперь программа может читать данные. Она читает их не по одному байту (это было бы слишком медленно), а блоками (обычно по 4 или 8 килобайт). Данные попадают в буфер — временное хранилище в оперативной памяти. Из буфера программа уже берёт данные и обрабатывает их.

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

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

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

Синтаксис в Go (Golang): все формы и варианты

В Go работа с файлами сосредоточена в пакете os (для базовых операций) и bufio (для буферизированного чтения). Также есть удобная функция os.ReadFile для чтения всего файла сразу. Давайте разберём все основные варианты.

1. Самый простой способ: os.ReadFile

Это функция, которая открывает файл, читает всё его содержимое в память и закрывает файл. Идеально для небольших файлов (до нескольких мегабайт).

// Читаем весь файл в переменную data (тип []byte)
data, err := os.ReadFile("myfile.txt")
if err != nil {
    // Если произошла ошибка (файл не найден, нет прав доступа и т.д.)
    log.Fatal(err)
}
// Преобразуем байты в строку и выводим
fmt.Println(string(data))

2. Классический способ: os.Open + Read

Этот способ даёт больше контроля. Вы открываете файл, получаете дескриптор, читаете данные в свой буфер, а потом закрываете файл.

// Открываем файл
file, err := os.Open("myfile.txt")
if err != nil {
    log.Fatal(err)
}
// Важно: закрываем файл, когда закончим
defer file.Close()

// Создаём буфер для чтения (массив байт)
buffer := make([]byte, 1024) // читаем по 1 КБ
for {
    n, err := file.Read(buffer) // n — сколько байт реально прочитано
    if err == io.EOF { // EOF — End Of File, конец файла
        break
    }
    if err != nil {
        log.Fatal(err)
    }
    // Обрабатываем прочитанные байты (первые n байт из buffer)
    fmt.Print(string(buffer[:n]))
}

3. Буферизированное чтение: bufio

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

file, err := os.Open("myfile.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

// Создаём буферизированного читателя
reader := bufio.NewReader(file)

// Читаем файл построчно
for {
    line, err := reader.ReadString('
') // читаем до символа новой строки
    if err == io.EOF {
        break // конец файла
    }
    if err != nil {
        log.Fatal(err)
    }
    fmt.Print(line) // выводим строку
}

4. Чтение с помощью сканера: bufio.Scanner

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

file, err := os.Open("myfile.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

scanner := bufio.NewScanner(file)
for scanner.Scan() {
    line := scanner.Text() // получаем текущую строку
    fmt.Println(line)
}
// Проверяем, не было ли ошибки при сканировании
if err := scanner.Err(); err != nil {
    log.Fatal(err)
}

5. Чтение с произвольной позиции: Seek

Иногда нужно прочитать не сначала, а с определённого места. Например, вы хотите прочитать последние 100 байт файла. Для этого используется метод Seek.

file, err := os.Open("myfile.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

// Перемещаем указатель чтения на 10 байт от начала файла
_, err = file.Seek(10, io.SeekStart)
if err != nil {
    log.Fatal(err)
}

// Теперь читаем 5 байт, начиная с 10-й позиции
buffer := make([]byte, 5)
_, err = file.Read(buffer)
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(buffer)) // выведет символы с 10 по 14

6. Чтение с помощью ioutil.ReadAll (устаревший, но встречается)

Раньше для чтения всего файла использовали ioutil.ReadAll, но начиная с Go 1.16, рекомендуется использовать os.ReadFile. Однако в старых проектах вы можете встретить этот код.

file, err := os.Open("myfile.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

data, err := ioutil.ReadAll(file)
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(data))

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

Теперь давайте закрепим теорию на практике. Мы напишем 7 примеров, каждый из которых решает свою задачу. Все примеры рабочие, вы можете скопировать их и запустить.

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

Самый простой случай: у нас есть файл hello.txt с текстом «Привет, мир!». Мы хотим вывести его на экран.

package main

import (
    "fmt"
    "os"
)

func main() {
    // Читаем файл целиком
    data, err := os.ReadFile("hello.txt")
    if err != nil {
        // Если файла нет, программа не упадёт, а сообщит об ошибке
        fmt.Println("Ошибка чтения файла:", err)
        return
    }
    // Выводим содержимое как строку
    fmt.Println(string(data))
}

Объяснение: os.ReadFile делает всё за нас: открывает, читает, закрывает. Если файла нет, мы получаем ошибку и сообщаем о ней пользователю.

Пример 2: Построчное чтение с помощью сканера

У нас есть файл students.txt со списком имён (каждое имя на новой строке). Выведем всех учеников.

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("students.txt")
    if err != nil {
        fmt.Println("Ошибка открытия файла:", err)
        return
    }
    // Отложенное закрытие файла — выполнится перед выходом из main
    defer file.Close()

    scanner := bufio.NewScanner(file)
    fmt.Println("Список учеников:")
    for scanner.Scan() {
        line := scanner.Text()
        fmt.Println("-", line)
    }
    // Проверяем, не было ли ошибки при чтении
    if err := scanner.Err(); err != nil {
        fmt.Println("Ошибка чтения:", err)
    }
}

Объяснение: bufio.NewScanner создаёт сканер, который по умолчанию разбивает файл на строки. Цикл for scanner.Scan() читает строку за строкой, пока не дойдёт до конца. Метод Text() возвращает текущую строку без символа переноса.

Пример 3: Чтение с буфером фиксированного размера

Представьте, что файл очень большой (например, 10 ГБ). Мы не можем прочитать его целиком — не хватит памяти. Читаем по кусочкам.

package main

import (
    "fmt"
    "io"
    "os"
)

func main() {
    file, err := os.Open("bigfile.dat")
    if err != nil {
        fmt.Println("Ошибка:", err)
        return
    }
    defer file.Close()

    // Буфер на 512 байт
    buffer := make([]byte, 512)
    fmt.Println("Читаем файл по 512 байт:")
    for {
        n, err := file.Read(buffer)
        if err == io.EOF {
            break // Дошли до конца
        }
        if err != nil {
            fmt.Println("Ошибка чтения:", err)
            return
        }
        // Выводим только то, что реально прочитали (n байт)
        fmt.Print(string(buffer[:n]))
    }
}

Объяснение: Мы создаём буфер — массив байт размером 512. В цикле читаем в него данные. file.Read возвращает количество реально прочитанных байт (n). Если n меньше 512, значит, это был последний кусок. Когда err == io.EOF, файл закончился.

Пример 4: Чтение определённого количества байт с начала

Нам нужно прочитать только первые 100 байт файла, чтобы, например, проверить его заголовок.

package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("image.png")
    if err != nil {
        fmt.Println("Ошибка:", err)
        return
    }
    defer file.Close()

    // Читаем ровно 8 байт (обычно это сигнатура PNG-файла)
    header := make([]byte, 8)
    _, err = file.Read(header)
    if err != nil {
        fmt.Println("Ошибка чтения заголовка:", err)
        return
    }
    fmt.Printf("Первые 8 байт файла: %x
", header)
    // Вывод в шестнадцатеричном формате: 89 50 4E 47 0D 0A 1A 0A
}

Объяснение: Мы создаём буфер нужного размера и читаем в него. Если файл меньше 8 байт, Read вернёт ошибку io.EOF (или io.ErrUnexpectedEOF).

Пример 5: Чтение с конца файла (хвост файла)

Хотим прочитать последние 50 байт лог-файла, чтобы увидеть последние записи.

package main

import (
    "fmt"
    "io"
    "os"
)

func main() {
    file, err := os.Open("server.log")
    if err != nil {
        fmt.Println("Ошибка:", err)
        return
    }
    defer file.Close()

    // Узнаём размер файла
    fileInfo, err := file.Stat()
    if err != nil {
        fmt.Println("Ошибка получения информации о файле:", err)
        return
    }
    fileSize := fileInfo.Size()

    // Сколько байт хотим прочитать с конца
    tailSize := int64(50)
    // Если файл меньше 50 байт, читаем весь файл
    if fileSize < tailSize {
        tailSize = fileSize
    }

    // Перемещаем указатель чтения на (fileSize - tailSize) байт от начала
    _, err = file.Seek(fileSize-tailSize, io.SeekStart)
    if err != nil {
        fmt.Println("Ошибка Seek:", err)
        return
    }

    // Читаем хвост
    buffer := make([]byte, tailSize)
    _, err = file.Read(buffer)
    if err != nil {
        fmt.Println("Ошибка чтения:", err)
        return
    }
    fmt.Println("Последние", tailSize, "байт файла:")
    fmt.Println(string(buffer))
}

Объяснение: Сначала получаем размер файла через file.Stat(). Затем с помощью Seek перемещаемся на позицию fileSize - tailSize (отсчитываем от начала). После этого читаем нужное количество байт.

Пример 6: Чтение CSV-файла (табличные данные)

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

package main

import (
    "encoding/csv"
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("data.csv")
    if err != nil {
        fmt.Println("Ошибка:", err)
        return
    }
    defer file.Close()

    // Создаём CSV-ридер
    reader := csv.NewReader(file)
    // Читаем все записи сразу
    records, err := reader.ReadAll()
    if err != nil {
        fmt.Println("Ошибка чтения CSV:", err)
        return
    }

    // Выводим таблицу
    for _, row := range records {
        for _, col := range row {
            fmt.Printf("%s	", col) // табуляция для красоты
        }
        fmt.Println() // новая строка
    }
}

Объяснение: Пакет encoding/csv умеет читать CSV-файлы. reader.ReadAll() возвращает срез срезов строк ([][]string). Каждый внутренний срез — это строка таблицы.

Пример 7: Чтение JSON-файла (структурированные данные)

JSON — популярный формат для обмена данными. В Go есть встроенная поддержка.

package main

import (
    "encoding/json"
    "fmt"
    "os"
)

// Структура, соответствующая JSON-данным
type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    file, err := os.Open("person.json")
    if err != nil {
        fmt.Println("Ошибка:", err)
        return
    }
    defer file.Close()

    // Читаем весь файл
    data, err := os.ReadFile("person.json")
    if err != nil {
        fmt.Println("Ошибка чтения:", err)
        return
    }

    // Распарсиваем JSON в структуру
    var person Person
    err = json.Unmarshal(data, &person)
    if err != nil {
        fmt.Println("Ошибка парсинга JSON:", err)
        return
    }

    fmt.Printf("Имя: %s, Возраст: %d
", person.Name, person.Age)
}

Объяснение: Мы определяем структуру Person с тегами json, которые указывают, какому полю JSON соответствует поле структуры. json.Unmarshal преобразует массив байт (содержимое файла) в структуру.

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

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

Операция Python Go
Чтение всего файла with open('file.txt') as f: data = f.read() data, _ := os.ReadFile("file.txt")
Построчное чтение for line in f: print(line) scanner := bufio.NewScanner(f); for scanner.Scan() { ... }
Чтение с буфером while chunk := f.read(1024): process(chunk) buffer := make([]byte, 1024); for { n, err := f.Read(buffer) ... }
Автоматическое закрытие with (контекстный менеджер) defer f.Close()
Обработка ошибок Исключения (try/except) Возврат ошибки (if err != nil)
Чтение CSV import csv; reader = csv.reader(f) import encoding/csv; reader := csv.NewReader(f)
Чтение JSON import json; data = json.load(f) import encoding/json; json.Unmarshal(data, &struct)

Основные отличия:

  • Обработка ошибок: В Python вы используете исключения (try/except), а в Go — проверку возвращаемого значения (if err != nil). Это делает код более явным, но и более многословным.
  • Закрытие файла: В Python конструкция with гарантирует закрытие файла даже при ошибке. В Go для этого используется defer, который откладывает выполнение функции до выхода из текущей функции.
  • Типизация: Go — строго типизированный язык. При чтении JSON вы обязаны определить структуру, в которую будут распарсены данные. В Python можно просто получить словарь.
  • Производительность: Go обычно быстрее Python при работе с файлами, особенно при больших объёмах данных, благодаря компиляции в машинный код.

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

Даже опытные программисты иногда допускают ошибки при работе с файлами. Вот список самых распространённых проблем и способов их избежать.

1. Забыли закрыть файл

Самая частая ошибка новичков. Если вы открыли файл и не закрыли его, дескриптор остаётся занятым. В долго работающих программах (например, веб-серверах) это может привести к исчерпанию лимита открытых файлов.

// ❌ Плохо: файл не закрыт
file, _ := os.Open("data.txt")
// ... работаем с файлом
// Забыли закрыть!

// ✅ Хорошо: используем defer сразу после открытия
file, err := os.Open("data.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close() // закроется при выходе из функции

2. Не проверяете ошибки

В Go ошибка — это значение. Если вы её игнорируете (присваиваете _), программа может работать непредсказуемо.

// ❌ Плохо: игнорируем ошибку
data, _ := os.ReadFile("config.txt")

// ✅ Хорошо: проверяем ошибку
data, err := os.ReadFile("config.txt")
if err != nil {
    fmt.Println("Не удалось прочитать конфиг:", err)
    // Можно использовать значение по умолчанию
    data = []byte("default")
}

3. Предполагаете, что файл существует

Файл может быть удалён, перемещён или у программы может не быть прав на его чтение. Всегда обрабатывайте случай, когда файла нет.

file, err := os.Open("important.txt")
if os.IsNotExist(err) {
    fmt.Println("Файл не найден. Создаём новый...")
    // Создаём файл
} else if err != nil {
    fmt.Println("Другая ошибка:", err)
}

4. Чтение всего файла в память без необходимости

Если файл размером 10 ГБ, а вы читаете его целиком с помощью os.ReadFile, программа может упасть с ошибкой out of memory. Используйте буферизированное чтение для больших файлов.

5. Путаница с путями (Windows vs Linux)

В Windows пути пишутся через обратную косую черту (), а в Linux и macOS — через прямую (/). Go умеет работать с обоими, но лучше использовать прямую черту или функцию filepath.Join.

// ✅ Правильно: используем filepath.Join
path := filepath.Join("folder", "subfolder", "file.txt")
// На Windows получится: foldersubfolderfile.txt
// На Linux: folder/subfolder/file.txt

6. Не учитываете кодировку файла

Go по умолчанию работает с UTF-8. Если файл в другой кодировке (например, Windows-1251), строки будут отображаться как кракозябры. Для работы с другими кодировками используйте пакет golang.org/x/text/encoding.

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

Теперь, когда вы знаете, как читать файлы и какие ошибки могут возникнуть, давайте разберём, как делать это правильно и эффективно.

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

Это золотое правило Go. defer гарантирует, что файл закроется, даже если в функции произойдёт паника или ошибка.

func readFile(path string) ([]byte, error) {
    f, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer f.Close() // закроется перед возвратом из функции
    return os.ReadFile(path) // но это уже другой вызов!
}

2. Для больших файлов используйте bufio

Буферизированное чтение значительно быстрее, чем чтение по одному байту. bufio.Scanner или bufio.NewReader — ваш выбор для больших текстовых файлов.

3. Используйте os.ReadFile для маленьких файлов

Если файл меньше 10 МБ, os.ReadFile — самый простой и быстрый способ. Не усложняйте код без необходимости.

4. Обрабатывайте ошибки осмысленно

Не пишите просто log.Fatal(err) в библиотечном коде. Возвращайте ошибку вызывающему коду, чтобы он мог решить, что делать.

// ❌ Плохо: убиваем программу
func loadConfig() {
    data, err := os.ReadFile("config.json")
    if err != nil {
        log.Fatal(err) // программа завершится
    }
    // ...
}

// ✅ Хорошо: возвращаем ошибку
func loadConfig() (Config, error) {
    data, err := os.ReadFile("config.json")
    if err != nil {
        return Config{}, fmt.Errorf("не удалось загрузить конфиг: %w", err)
    }
    // ...
}

5. Используйте filepath для работы с путями

Никогда не склеивайте пути вручную через +. Используйте filepath.Join — он корректно обработает слеши на любой ОС.

6. Проверяйте права доступа

Перед чтением файла можно проверить, есть ли у программы права на чтение, с помощью os.IsPermission.

7. Используйте io.ReadAll для чтения из io.Reader

Если у вас есть любой io.Reader (не обязательно файл), вы можете прочитать из него всё содержимое с помощью io.ReadAll.

Вопросы для самопроверки

Проверьте, как вы усвоили материал. Постарайтесь ответить на вопросы, не подглядывая в код.

  1. Вопрос: Какая функция в Go позволяет прочитать весь файл одной строкой?
    Ответ: os.ReadFile("filename"). Она открывает, читает и закрывает файл автоматически.
  2. Вопрос: Что такое дескриптор файла и зачем его закрывать?
    Ответ: Дескриптор — это номер, который операционная система выдаёт программе для доступа к файлу. Если его не закрыть, произойдёт утечка ресурсов, и программа может исчерпать лимит открытых файлов.
  3. Вопрос: Как в Go обрабатывается ситуация, когда файл не найден?
    Ответ: Функции открытия/чтения возвращают ошибку. Её можно проверить с помощью os.IsNotExist(err).
  4. Вопрос: Чем отличается bufio.Scanner от bufio.NewReader?
    Ответ: Scanner удобен для построчного чтения (или по словам). NewReader даёт больше контроля (можно читать до определённого разделителя, например, до запятой).
  5. Вопрос: Как прочитать только первые 100 байт файла?
    Ответ: Создать буфер на 100 байт и вызвать file.Read(buffer). Если файл меньше 100 байт, будет прочитано меньше.
  6. Вопрос: Что делает defer file.Close()?
    Ответ: Откладывает вызов file.Close() до момента выхода из текущей функции. Это гарантирует
← Précédent Gestion des erreurs et exceptions en Go (Golang) : Suivant → Méthodes de chaînes — guide complet en Go (Golang)