Как перебрать все поля структуры в Go? (итерация по полям struct)

Используем пакет reflect для итерации по полям структуры

Да, вы правы — в Go нет встроенной возможности итерироваться по полям структуры как по коллекции. Это сделано намеренно: структуры в Go — это строго типизированные составные типы, а не динамические объекты. Однако для тех случаев, когда вам действительно нужен обход полей (сериализация, логирование, работа с конфигами), в стандартной библиотеке есть пакет reflect.

Вот простое и рабочее решение вашей задачи:

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name  string
    Age   int
    Email string
}

func PrintFields(i interface{}) {
    // Получаем тип и значение переданного объекта
    t := reflect.TypeOf(i)
    v := reflect.ValueOf(i)

    // Убеждаемся, что это структура
    if t.Kind() != reflect.Struct {
        fmt.Println("Ошибка: ожидается структура")
        return
    }

    // Перебираем все поля
    for idx := 0; idx < t.NumField(); idx++ {
        field := t.Field(idx)        // информация о поле (имя, тип, теги)
        value := v.Field(idx)        // значение поля

        fmt.Printf("%s: %v\n", field.Name, value.Interface())
    }
}

func main() {
    user := User{
        Name:  "Алексей",
        Age:   30,
        Email: "alex@example.com",
    }

    PrintFields(user)
}

Объяснение работы кода

• reflect.TypeOf(i) — получает метаинформацию о типе переданного объекта. В нашем случае это структура User.
• reflect.ValueOf(i) — получает доступ к значениям полей. Через него мы можем читать и (при необходимости) изменять поля.
• t.NumField() — возвращает количество полей в структуре.
• t.Field(idx) — возвращает описание поля: его имя, тип, теги (struct tags).
• v.Field(idx) — возвращает значение поля в виде reflect.Value. Метод .Interface() конвертирует его обратно в обычный interface{} для печати.

Важные замечания

• Производительность: рефлексия работает медленнее прямого доступа к полям. Для высоконагруженного кода стоит избегать частого использования reflect.
• Безопасность: если передать не структуру (например, число или указатель), код выдаст ошибку. Добавлена проверка t.Kind() != reflect.Struct.
• Неэкспортируемые поля: если поле начинается с маленькой буквы (приватное), рефлексия может его прочитать, но не изменить без дополнительных ухищрений (через unsafe).
• Вложенные структуры: если поле само является структурой, v.Field(idx).Interface() вернёт вложенную структуру как есть. Если нужно рекурсивно обойти и её, придётся писать дополнительную логику.

Работа с тегами (struct tags)

Часто поля структур содержат теги для сериализации (например, json:"name"). Вы можете их получить через field.Tag.Get("json"):

type Config struct {
    Host string `json:"host"`
    Port int    `json:"port"`
}

// В цикле:
tag := field.Tag.Get("json")
if tag == "" {
    tag = field.Name // если тега нет, используем имя поля
}
fmt.Printf("%s: %v\n", tag, v.Field(idx).Interface())

Этот подход используется во всех популярных библиотеках сериализации (encoding/json, gorm, viper и других).

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

type Fieldser interface {
    Fields() map[string]interface{}
}

func (u User) Fields() map[string]interface{} {
    return map[string]interface{}{
        "Name":  u.Name,
        "Age":   u.Age,
        "Email": u.Email,
    }
}

func PrintFields(f Fieldser) {
    for key, val := range f.Fields() {
        fmt.Printf("%s: %v\n", key, val)
    }
}