Часть 5. Типы и абстракцииУрок 15# go# структуры# ооп# собеседование

Структуры

ООП в Go, методы и получатели, встраивание, теги, конструкторы

Цели главы

  • Объяснить, как в Go устроено ООП — частый вопрос собеседования.
  • Объявлять структуры, создавать их пятью способами, читать и менять поля.
  • Писать методы и выбирать получатель: по значению или по указателю.
  • Использовать встраивание, анонимные и пустые структуры, теги.
  • Писать функции-конструкторы.

Зачем структуры

До сих пор мы работали с переменными, функциями, слайсами и мапами. Но в GoFlix фильм — это не строка, а набор свойств: название, год, рейтинг. Подписчик — не просто имя, а ещё email и тариф; сессия просмотра хранит время начала, фильм и статус. Обновлять рейтинг, когда данные лежат в несвязанных переменных, неудобно. Нужен тип, который свяжет данные, — структура.

ООП в Go

Во многих языках ООП строится вокруг классов, наследования и полиморфизма. Go идёт другим путём:

Идея ООП Как в Go
Класс структура + методы
Инкапсуляция заглавная буква — экспортировано (как public), строчная — приватно для пакета (как private)
Наследование нет; вместо него — композиция: встраивание одной структуры в другую
Полиморфизм через интерфейсы — 16 — Интерфейсы
Зависимости передаются явно: через параметры и поля (Dependency Injection)

Для повторного использования кода структуры встраивают друг в друга, а не строят иерархии наследования.

Объявление и создание

Структура — набор именованных полей, у каждого свой тип. Объявляется через type Имя struct { … }. Поля одного типа можно записать в одну строку: Lat, Lng float64.

Способы создать структуру:

  1. var — все поля получают нулевые значения.
  2. Именованная инициализация — явно указываем, какое поле чему равно. Самый безопасный и читаемый способ, его рекомендуют официальные руководства.
  3. Позиционная — значения по порядку полей. Добавят поле — код сломается; годится только для очень простых структур.
  4. Частичная — часть полей явно, остальные получат нулевые значения.
  5. new(T) — указатель на структуру с нулевыми полями.
go
package main

import "fmt"

// Film — описание фильма в GoFlix.
type Film struct {
    Title    string
    Year     int
    Rating   float64
    Genre    string
    Duration int // минуты
}

func main() {
    var f1 Film                                              // все поля — нулевые значения
    f2 := Film{Title: "Дюна", Year: 2021, Rating: 8.1}       // именованная и частичная
    f3 := Film{"Интерстеллар", 2014, 8.6, "Фантастика", 169} // позиционная: все поля по порядку
    f4 := new(Film)                                          // указатель на структуру

    fmt.Printf("%+v\n%+v\n%+v\n%+v\n", f1, f2, f3, f4)
}
stdout // вывод программы
{Title: Year:0 Rating:0 Genre: Duration:0}
{Title:Дюна Year:2021 Rating:8.1 Genre: Duration:0}
{Title:Интерстеллар Year:2014 Rating:8.6 Genre:Фантастика Duration:169}
&{Title: Year:0 Rating:0 Genre: Duration:0}

%+v печатает структуру с именами полей — незаменимо при отладке.

Поля и указатели

К полю обращаются через точку: film.Title, sub.Email — как достать нужную вещь из коробки. Поле со строчной буквы не видно из других пакетов, поэтому публичные поля пишут с заглавной.

Структуры бывают объёмными, и копировать их дорого. К тому же изменить поля из функции можно только через указатель. Поэтому структуры часто передают по указателю — и обращаются к полям так же через точку: Go сам разыменует указатель (11 — Указатели → Указатели на структуры).

go
package main

import "fmt"

type Subscriber struct {
    Name  string
    Email string
    Age   int
    Plan  string
}

func main() {
    sub := Subscriber{Name: "Алексей", Email: "alex@goflix.ru", Age: 28, Plan: "Premium"}
    fmt.Println(sub.Name, sub.Plan) // чтение через точку
    sub.Plan = "Standard"           // запись

    p := &sub
    p.Age = 29 // через указатель меняем оригинал

    copied := sub
    copied.Name = "Копия" // копия — отдельная коробка
    fmt.Println(sub.Plan, sub.Age, sub.Name, copied.Name)
}
stdout // вывод программы
Алексей Premium
Standard 29 Алексей Копия

Аналогия: структура — коробка с вещами. Копия — отдельная коробка с тем же содержимым: меняешь её, оригинал не трогаешь. Указатель — бирка с местом хранения оригинальной коробки на складе: по ней находишь ту самую коробку и меняешь вещи прямо в ней.

Методы

Метод — функция, привязанная к типу. Тип указывают между func и именем метода — это получатель (receiver). Методы связывают поведение с данными.

go
package main

import "fmt"

type FilmCard struct {
    Title     string
    Year      int
    Rating    float64
    Watched   bool
    ViewCount int
}

// Info — получатель по значению: работает с копией и только читает поля.
func (f FilmCard) Info() string {
    return fmt.Sprintf("%s (%d), рейтинг %.1f", f.Title, f.Year, f.Rating)
}

// Watch — получатель по указателю: меняет исходную структуру.
func (f *FilmCard) Watch() {
    f.Watched = true
    f.ViewCount++
}

// RenameCopy пытается переименовать фильм через получатель по значению — не выйдет.
func (f FilmCard) RenameCopy(title string) {
    f.Title = title
}

func main() {
    card := FilmCard{Title: "Довод", Year: 2020, Rating: 7.8}
    card.Watch() // Go сам возьмёт адрес: (&card).Watch()
    card.Watch()
    card.RenameCopy("Tenet")
    fmt.Println(card.Info(), card.Watched, card.ViewCount)
}
stdout // вывод программы
Довод (2020), рейтинг 7.8 true 2

Как выбрать получатель:

По указателю (f *T) По значению (f T)
метод меняет состояние метод только читает поля
структура большая — копировать дорого структура маленькая
в структуре есть поле, которое нельзя копировать, например sync.Mutex тип по смыслу — значение: координаты, деньги

Встраивание — композиция вместо наследования

Наследования в Go нет, но одну структуру можно встроить в другую: записать тип без имени поля. Поля и методы встроенной структуры становятся доступны напрямую у внешней — их «продвигают» наверх. Аналогия — матрёшка: внутри AdminUser лежит Subscriber.

go
package main

import "fmt"

type Subscriber struct {
    Name  string
    Email string
    Plan  string
}

func (s Subscriber) Contact() string {
    return s.Name + " <" + s.Email + ">"
}

// AdminUser встраивает Subscriber: его поля и методы доступны напрямую.
type AdminUser struct {
    Subscriber
    AccessLevel string
    Department  string
}

func main() {
    admin := AdminUser{
        Subscriber:  Subscriber{Name: "Елена", Email: "e@goflix.ru", Plan: "Premium"},
        AccessLevel: "superadmin",
        Department:  "Billing",
    }
    fmt.Println(admin.Name)            // поле Subscriber доступно напрямую
    fmt.Println(admin.Subscriber.Plan) // полный путь тоже работает
    fmt.Println(admin.Contact())       // и методы тоже
}
stdout // вывод программы
Елена
Premium
Елена <e@goflix.ru>

Новая структура собирается из готовых частей и дополняется своими полями.

Анонимные структуры

Иногда данные нужно временно сгруппировать, а заводить отдельный тип незачем — его больше нигде не используют. Тогда структуру объявляют прямо на месте. Два частых сценария: разовая конфигурация и табличные тесты (table-driven tests), где каждый элемент слайса — входные данные и ожидаемый результат.

go
package main

import "fmt"

func discount(plan string) int {
    switch plan {
    case "Premium":
        return 20
    case "Standard":
        return 10
    default:
        return 0
    }
}

func main() {
    config := struct {
        Host string
        Port int
    }{Host: "api.goflix.ru", Port: 443}
    fmt.Printf("%s:%d\n", config.Host, config.Port)

    tests := []struct {
        plan string
        want int
    }{
        {"Premium", 20},
        {"Standard", 10},
        {"Free", 0},
    }
    for _, tt := range tests {
        got := discount(tt.plan)
        fmt.Printf("%-8s → %2d%% ok=%t\n", tt.plan, got, got == tt.want)
    }
}
stdout // вывод программы
api.goflix.ru:443
Premium  → 20% ok=true
Standard → 10% ok=true
Free     →  0% ok=true

Табличные тесты компактны и легко расширяются: новый случай — новая строка. В настоящих тестах такой цикл живёт в функции TestXxx и запускается командой go test — пример в 18 — Backend — HTTP-сервер → Тестирование хендлеров.

Пустая структура

У struct{} нет ни одного поля, поэтому она не хранит данных и занимает 0 байт. Её используют там, где важен сам факт наличия, а не данные. Самый частый пример — множество: map[string]struct{} вместо map[string]bool экономит память. Ещё один — сигнальные каналы (17 — Конкурентность — горутины и каналы → Сигнальный канал).

go
package main

import (
    "fmt"
    "maps"
    "slices"
    "unsafe"
)

func main() {
    fmt.Println(unsafe.Sizeof(struct{}{})) // размер в байтах

    genres := map[string]struct{}{"Фантастика": {}, "Драма": {}, "Комедия": {}}
    genres["Боевик"] = struct{}{} // добавить
    if _, exists := genres["Драма"]; exists {
        fmt.Println("Драма есть в наборе")
    }
    delete(genres, "Комедия") // удалить
    fmt.Println(slices.Sorted(maps.Keys(genres)))
}
stdout // вывод программы
0
Драма есть в наборе
[Боевик Драма Фантастика]

Теги

Тег — строка в обратных кавычках после типа поля. На саму структуру теги не влияют, это подсказки для библиотек. Самый известный пример — сериализация в JSON: тег json:"id" говорит пакету encoding/json, как называть поле. Тег db:"item_id" — подсказка библиотекам для работы с базой данных. В коде к полям по-прежнему обращаются по обычным именам: item.ID, item.Title.

go
package main

import (
    "encoding/json"
    "fmt"
)

type CatalogItem struct {
    ID        int     `json:"id" db:"item_id"`
    Title     string  `json:"title" db:"title"`
    Price     float64 `json:"price" db:"price"`
    Available bool    `json:"available" db:"is_available"`
    Internal  string  `json:"-"`              // не попадёт в JSON
    Note      string  `json:"note,omitempty"` // пустое значение пропускается
}

func main() {
    item := CatalogItem{ID: 1, Title: "Интерстеллар", Price: 12.99, Available: true, Internal: "служебное"}
    data, err := json.Marshal(item)
    if err != nil {
        fmt.Println("ошибка:", err)
        return
    }
    fmt.Println(string(data))
    fmt.Println(item.Title) // в коде — обычные имена полей
}
stdout // вывод программы
{"id":1,"title":"Интерстеллар","price":12.99,"available":true}
Интерстеллар

Сравнение и копирование

  • Структуры можно сравнивать ==, если все их поля сравнимы; сравнение идёт по каждому полю. Структуру со слайсом внутри сравнить нельзя: invalid operation: a == b (struct containing []string cannot be compared).
  • Присваивание структуры создаёт копию: изменения копии не затрагивают оригинал — это было видно на примере с copied выше.

Структуры в Go по умолчанию ведут себя как значения: и сравнение, и присваивание работают с содержимым, а не со ссылкой.

Конструкторы

Встроенных конструкторов, как в Java или C#, в Go нет. Есть идиома: функция NewТип(...) возвращает готовый экземпляр. В ней ставят значения по умолчанию, проверяют входные данные и инициализируют сложные поля — время старта, мьютекс. Обычно конструктор возвращает указатель: с объектом дальше работают без лишнего копирования.

go
package main

import (
    "errors"
    "fmt"
    "time"
)

type StreamSession struct {
    UserName  string
    MovieName string
    StartedAt time.Time
    IsActive  bool
}

// NewStreamSession проверяет данные и ставит значения по умолчанию.
func NewStreamSession(user, movie string) (*StreamSession, error) {
    if user == "" || movie == "" {
        return nil, errors.New("нужны пользователь и фильм")
    }
    return &StreamSession{
        UserName:  user,
        MovieName: movie,
        StartedAt: time.Now(),
        IsActive:  true,
    }, nil
}

func main() {
    s, err := NewStreamSession("Алексей", "Интерстеллар")
    if err != nil {
        fmt.Println("ошибка:", err)
        return
    }
    fmt.Println(s.UserName, s.MovieName, s.IsActive, !s.StartedAt.IsZero())

    _, err = NewStreamSession("", "Дюна")
    fmt.Println("ошибка:", err)
}
stdout // вывод программы
Алексей Интерстеллар true true
ошибка: нужны пользователь и фильм

Практика

Домашнее задание

  1. Профиль. Структура Profile: UserName, Email (string), Age (int), Country (string), Premium (bool). Создай заполненный профиль и выведи поля; затем профиль без инициализации; затем профиль, где заданы только UserName и Email.
  2. Устройство. Структура Device: Name, Type (string), Active (bool). Методы Info() string, Activate(), Deactivate(). Создай устройство, выведи состояние, активируй, выведи, деактивируй, выведи.
  3. Подписка. Структура Subscription: Plan (string), Price (float64), AutoRenew (bool). Конструктор NewSubscription(plan string, price float64) *Subscription ставит AutoRenew = true. Методы CancelAutoRenew() и PrintDetails(). Создай подписку, выведи, отключи автопродление, выведи снова.
  4. История просмотра. Episode с полями Title, Season, Duration и JSON-тегами title, season, duration. WatchHistory с полями Profile, Episode, WatchedPercent, LastPositionMin. Выведи имя, email, название эпизода, процент и позицию; переведи Episode в JSON.
  5. Избранное. FavoriteList со слайсом Titles []string. Методы Add(title string), PrintAll() и PrintUnique() — уникальные названия через map[string]struct{}. В main создай анонимную структуру статистики с полями Owner string и ItemsCount int.
решениеЭталонное решение
go
package main

import (
    "encoding/json"
    "fmt"
)

// Задание 1: профиль пользователя.
type Profile struct {
    UserName string
    Email    string
    Age      int
    Country  string
    Premium  bool
}

// Задание 2: устройство просмотра.
type Device struct {
    Name   string
    Type   string
    Active bool
}

func (d *Device) Info() string {
    status := "неактивно"
    if d.Active {
        status = "активно"
    }
    return fmt.Sprintf("%s (%s): %s", d.Name, d.Type, status)
}

func (d *Device) Activate() { d.Active = true }

func (d *Device) Deactivate() { d.Active = false }

// Задание 3: подписка с конструктором.
type Subscription struct {
    Plan      string
    Price     float64
    AutoRenew bool
}

func NewSubscription(plan string, price float64) *Subscription {
    return &Subscription{Plan: plan, Price: price, AutoRenew: true}
}

func (s *Subscription) CancelAutoRenew() { s.AutoRenew = false }

func (s *Subscription) PrintDetails() {
    fmt.Printf("подписка %s: %.2f руб., автопродление: %t\n", s.Plan, s.Price, s.AutoRenew)
}

// Задание 4: история просмотра.
type Episode struct {
    Title    string `json:"title"`
    Season   int    `json:"season"`
    Duration int    `json:"duration"`
}

type WatchHistory struct {
    Profile         Profile
    Episode         Episode
    WatchedPercent  int
    LastPositionMin int
}

// Задание 5: избранное.
type FavoriteList struct {
    Titles []string
}

func (f *FavoriteList) Add(title string) { f.Titles = append(f.Titles, title) }

func (f *FavoriteList) PrintAll() { fmt.Println("все:", f.Titles) }

func (f *FavoriteList) PrintUnique() {
    seen := make(map[string]struct{})
    var unique []string
    for _, t := range f.Titles {
        if _, ok := seen[t]; !ok {
            seen[t] = struct{}{}
            unique = append(unique, t)
        }
    }
    fmt.Println("уникальные:", unique)
}

func main() {
    // 1
    profile := Profile{UserName: "alex", Email: "alex@goflix.ru", Age: 28, Country: "RU", Premium: true}
    var empty Profile
    partial := Profile{UserName: "maria", Email: "maria@goflix.ru"}
    fmt.Printf("%+v\n%+v\n%+v\n", profile, empty, partial)

    // 2
    tv := Device{Name: "Гостиная", Type: "Smart TV"}
    fmt.Println(tv.Info())
    tv.Activate()
    fmt.Println(tv.Info())
    tv.Deactivate()
    fmt.Println(tv.Info())

    // 3
    sub := NewSubscription("Premium", 999)
    sub.PrintDetails()
    sub.CancelAutoRenew()
    sub.PrintDetails()

    // 4
    history := WatchHistory{
        Profile:         profile,
        Episode:         Episode{Title: "Пилот", Season: 1, Duration: 52},
        WatchedPercent:  75,
        LastPositionMin: 39,
    }
    fmt.Println(history.Profile.UserName, history.Profile.Email, history.Episode.Title,
        history.WatchedPercent, history.LastPositionMin)
    data, err := json.Marshal(history.Episode)
    if err != nil {
        fmt.Println("ошибка:", err)
        return
    }
    fmt.Println(string(data))

    // 5
    var fav FavoriteList
    for _, t := range []string{"Дюна", "Матрица", "Дюна"} {
        fav.Add(t)
    }
    fav.PrintAll()
    fav.PrintUnique()
    stats := struct {
        Owner      string
        ItemsCount int
    }{Owner: profile.UserName, ItemsCount: len(fav.Titles)}
    fmt.Printf("%+v\n", stats)
}
stdout // вывод программы
{UserName:alex Email:alex@goflix.ru Age:28 Country:RU Premium:true}
{UserName: Email: Age:0 Country: Premium:false}
{UserName:maria Email:maria@goflix.ru Age:0 Country: Premium:false}
Гостиная (Smart TV): неактивно
Гостиная (Smart TV): активно
Гостиная (Smart TV): неактивно
подписка Premium: 999.00 руб., автопродление: true
подписка Premium: 999.00 руб., автопродление: false
alex alex@goflix.ru Пилот 75 39
{"title":"Пилот","season":1,"duration":52}
все: [Дюна Матрица Дюна]
уникальные: [Дюна Матрица]
{Owner:alex ItemsCount:3}

Тренировка: предскажи вывод

go
package main

import "fmt"

type Counter struct{ n int }

func (c Counter) IncValue() { c.n++ }

func (c *Counter) IncPointer() { c.n++ }

func main() {
    var c Counter
    c.IncValue()
    c.IncPointer()
    c.IncPointer()
    fmt.Println(c.n)
}
самопроверкаОтвет
text
2

IncValue увеличил копию, оригинал не изменился. Два вызова IncPointer изменили сам c.

Проверь себя

вопросКак в Go реализовано ООП?

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

вопросКакие способы создать структуру ты знаешь и какой самый безопасный?

var s T, именованный литерал T{Field: v}, позиционный T{v1, v2}, частичный литерал, new(T). Самый безопасный — именованный: он не ломается при добавлении полей.

вопросЧем получатель по значению отличается от получателя по указателю?

По значению метод получает копию и не может изменить оригинал. По указателю — меняет исходную структуру и не копирует её.

вопросЧто даёт встраивание структуры?

Поля и методы встроенной структуры доступны напрямую у внешней. Это композиция, а не наследование: тип внешней структуры не становится типом встроенной.

вопросСколько памяти занимает struct{} и где её применяют?

0 байт. Во множествах map[T]struct{} и в сигнальных каналах chan struct{}.

вопросЗачем нужны теги и какие поля видит encoding/json?

Теги — подсказки библиотекам: как назвать поле в JSON или в базе, пропускать ли пустое. encoding/json видит только экспортированные поля.

вопросМожно ли сравнить две структуры через ==?

Да, если все их поля сравнимы: сравнение идёт по каждому полю. Со слайсом, мапой или функцией внутри — ошибка компиляции.

вопросЧто такое конструктор в Go?

Обычная функция NewТип(...), которая возвращает готовый экземпляр — как правило указатель — с проверенными данными и значениями по умолчанию.


Ключевые выводы

  • 🧱 Структура связывает данные: один тип вместо разрозненных переменных.
  • 🧭 ООП в Go: методы и инкапсуляция есть, наследования нет — композиция и интерфейсы.
  • 🏷️ Именованная инициализация — самый безопасный способ создать структуру.
  • ✏️ Получатель по указателю меняет оригинал, по значению — работает с копией.
  • 🪆 Встраивание поднимает поля и методы наверх, но не делает типы взаимозаменяемыми.
  • 🏭 Конструктор NewX ставит значения по умолчанию и проверяет данные.
// связанные темы и шпаргалки