Приведи примеры данных, которые можно хранить в Nested

Примеры вложенных (Nested) данных в Go

В Go под вложенными данными обычно понимают структуры, содержащие другие структуры, срезы, массивы или карты, что позволяет моделировать сложные иерархические отношения. Вот несколько практических примеров с акцентом на JSON-сериализацию, так как вложенные структуры часто используются для работы с API и конфигурациями.

1. Вложенные структуры для профиля пользователя

Моделируем профиль пользователя с адресом и контактами как отдельными вложенными структурами.

package main

import (
    "encoding/json"
    "fmt"
)

// Вложенная структура для адреса
type Address struct {
    City    string `json:"city"`
    Street  string `json:"street"`
    ZipCode string `json:"zip_code"`
}

// Вложенная структура для контактов
type Contact struct {
    Email string `json:"email"`
    Phone string `json:"phone"`
}

// Родительская структура с вложениями
type UserProfile struct {
    Name      string   `json:"name"`
    Age       int      `json:"age"`
    Address   Address  `json:"address"`   // Вложенная структура
    Contact   Contact  `json:"contact"`   // Вложенная структура
    IsActive  bool     `json:"is_active"`
}

func main() {
    // Создание экземпляра с вложенными данными
    user := UserProfile{
        Name: "Иван Петров",
        Age:  30,
        Address: Address{
            City:    "Москва",
            Street:  "ул. Ленина, д. 10",
            ZipCode: "101000",
        },
        Contact: Contact{
            Email: "ivan@example.com",
            Phone: "+79161234567",
        },
        IsActive: true,
    }

    // Сериализация в JSON (читаемый формат с отступами)
    jsonData, err := json.MarshalIndent(user, "", "  ")
    if err != nil {
        panic(err)
    }
    fmt.Println(string(jsonData))
}

Вывод JSON:

{
  "name": "Иван Петров",
  "age": 30,
  "address": {
    "city": "Москва",
    "street": "ул. Ленина, д. 10",
    "zip_code": "101000"
  },
  "contact": {
    "email": "ivan@example.com",
    "phone": "+79161234567"
  },
  "is_active": true
}

2. Сложные вложения: срез вложенных структур

Модель заказа в интернет-магазине, где каждый заказ содержит список товаров (вложенный срез структур).

type OrderItem struct {
    ProductID   int     `json:"product_id"`
    ProductName string  `json:"product_name"`
    Quantity    int     `json:"quantity"`
    Price       float64 `json:"price"`
}

type Order struct {
    OrderID     int         `json:"order_id"`
    CustomerID  int         `json:"customer_id"`
    Items       []OrderItem `json:"items"`       // Вложенный срез структур
    TotalAmount float64     `json:"total_amount"`
}

func main() {
    order := Order{
        OrderID:    1001,
        CustomerID: 5001,
        Items: []OrderItem{
            {ProductID: 1, ProductName: "Ноутбук", Quantity: 1, Price: 75000.50},
            {ProductID: 2, ProductName: "Мышь", Quantity: 2, Price: 1500.00},
        },
        TotalAmount: 78000.50,
    }

    jsonData, _ := json.MarshalIndent(order, "", "  ")
    fmt.Println(string(jsonData))
}

3. Вложенные карты (map)

Конфигурация приложения, где настройки разбиты по модулям с динамическими ключами.

type AppConfig struct {
    AppName  string            `json:"app_name"`
    Version  string            `json:"version"`
    Settings map[string]string `json:"settings"`          // Карта строк
    Modules  map[string]map[string]interface{} `json:"modules"` // Вложенная карта
}

func main() {
    config := AppConfig{
        AppName: "MyApp",
        Version: "1.0.0",
        Settings: map[string]string{"env": "production", "log_level": "info"},
        Modules: map[string]map[string]interface{}{
            "database": {
                "host": "localhost",
                "port": 5432,
                "ssl":  true,
            },
            "cache": {
                "max_size": 1024,
                "ttl":      3600,
            },
        },
    }

    jsonData, _ := json.MarshalIndent(config, "", "  ")
    fmt.Println(string(jsonData))
}

4. Глубокое вложение: структура в структуре в структуре

Модель организации с отделами, сотрудниками и их проектами.

type Project struct {
    ProjectName string `json:"project_name"`
    Deadline    string `json:"deadline"`
}

type Employee struct {
    EmpID    int      `json:"emp_id"`
    EmpName  string   `json:"emp_name"`
    Projects []Project `json:"projects"` // Вложение среза структур
}

type Department struct {
    DeptName   string     `json:"dept_name"`
    Employees  []Employee `json:"employees"` // Ещё один уровень вложения
}

func main() {
    dept := Department{
        DeptName: "Разработка",
        Employees: []Employee{
            {
                EmpID:   1,
                EmpName: "Алексей",
                Projects: []Project{
                    {ProjectName: "Миграция в облако", Deadline: "2024-12-01"},
                    {ProjectName: "Новый API", Deadline: "2024-10-15"},
                },
            },
            {
                EmpID:   2,
                EmpName: "Мария",
                Projects: []Project{
                    {ProjectName: "Обновление UI", Deadline: "2024-11-20"},
                },
            },
        },
    }

    jsonData, _ := json.MarshalIndent(dept, "", "  ")
    fmt.Println(string(jsonData))
}

Ключевые преимущества вложенных структур:

• Чёткая организация данных — логическое группирование связанных полей.
• Соответствие доменной модели — отражает реальные иерархии (пользователь → адрес → город).
• Удобство сериализации — легко конвертировать в/из JSON, XML или YAML.
• Типобезопасность — компилятор Go проверяет типы на всех уровнях вложения.
• Читаемость кода — явные структуры вместо анонимных map[string]interface{}.

Важные замечания по использованию:

• Для опциональных вложенных полей используйте указатели (например, *Address), чтобы отличать отсутствие значения от нулевого.
• При работе с глубоко вложенными данными учитывайте производительность рекурсивных операций.
• Всегда проверяйте циклические ссылки при сериализации, чтобы избежать бесконечной рекурсии.

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