Цели главы
- Объяснить, как в Go устроено ООП — частый вопрос собеседования.
- Объявлять структуры, создавать их пятью способами, читать и менять поля.
- Писать методы и выбирать получатель: по значению или по указателю.
- Использовать встраивание, анонимные и пустые структуры, теги.
- Писать функции-конструкторы.
Зачем структуры
До сих пор мы работали с переменными, функциями, слайсами и мапами. Но в GoFlix фильм — это не строка, а набор свойств: название, год, рейтинг. Подписчик — не просто имя, а ещё email и тариф; сессия просмотра хранит время начала, фильм и статус. Обновлять рейтинг, когда данные лежат в несвязанных переменных, неудобно. Нужен тип, который свяжет данные, — структура.
ООП в Go
Во многих языках ООП строится вокруг классов, наследования и полиморфизма. Go идёт другим путём:
| Идея ООП | Как в Go |
|---|---|
| Класс | структура + методы |
| Инкапсуляция | заглавная буква — экспортировано (как public), строчная — приватно для пакета (как private) |
| Наследование | нет; вместо него — композиция: встраивание одной структуры в другую |
| Полиморфизм | через интерфейсы — 16 — Интерфейсы |
| Зависимости | передаются явно: через параметры и поля (Dependency Injection) |
Для повторного использования кода структуры встраивают друг в друга, а не строят иерархии наследования.
Объявление и создание
Структура — набор именованных полей, у каждого свой тип. Объявляется через type Имя struct { … }. Поля одного типа можно записать в одну строку: Lat, Lng float64.
Способы создать структуру:
var— все поля получают нулевые значения.- Именованная инициализация — явно указываем, какое поле чему равно. Самый безопасный и читаемый способ, его рекомендуют официальные руководства.
- Позиционная — значения по порядку полей. Добавят поле — код сломается; годится только для очень простых структур.
- Частичная — часть полей явно, остальные получат нулевые значения.
new(T)— указатель на структуру с нулевыми полями.
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)
}{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 — Указатели → Указатели на структуры).
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)
}Алексей Premium
Standard 29 Алексей КопияАналогия: структура — коробка с вещами. Копия — отдельная коробка с тем же содержимым: меняешь её, оригинал не трогаешь. Указатель — бирка с местом хранения оригинальной коробки на складе: по ней находишь ту самую коробку и меняешь вещи прямо в ней.
Методы
Метод — функция, привязанная к типу. Тип указывают между func и именем метода — это получатель (receiver). Методы связывают поведение с данными.
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)
}Довод (2020), рейтинг 7.8 true 2Как выбрать получатель:
По указателю (f *T) |
По значению (f T) |
|---|---|
| метод меняет состояние | метод только читает поля |
| структура большая — копировать дорого | структура маленькая |
в структуре есть поле, которое нельзя копировать, например sync.Mutex |
тип по смыслу — значение: координаты, деньги |
Встраивание — композиция вместо наследования
Наследования в Go нет, но одну структуру можно встроить в другую: записать тип без имени поля. Поля и методы встроенной структуры становятся доступны напрямую у внешней — их «продвигают» наверх. Аналогия — матрёшка: внутри AdminUser лежит Subscriber.
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()) // и методы тоже
}Елена
Premium
Елена <e@goflix.ru>Новая структура собирается из готовых частей и дополняется своими полями.
Анонимные структуры
Иногда данные нужно временно сгруппировать, а заводить отдельный тип незачем — его больше нигде не используют. Тогда структуру объявляют прямо на месте. Два частых сценария: разовая конфигурация и табличные тесты (table-driven tests), где каждый элемент слайса — входные данные и ожидаемый результат.
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)
}
}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 — Конкурентность — горутины и каналы → Сигнальный канал).
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)))
}0
Драма есть в наборе
[Боевик Драма Фантастика]Теги
Тег — строка в обратных кавычках после типа поля. На саму структуру теги не влияют, это подсказки для библиотек. Самый известный пример — сериализация в JSON: тег json:"id" говорит пакету encoding/json, как называть поле. Тег db:"item_id" — подсказка библиотекам для работы с базой данных. В коде к полям по-прежнему обращаются по обычным именам: item.ID, item.Title.
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) // в коде — обычные имена полей
}{"id":1,"title":"Интерстеллар","price":12.99,"available":true}
ИнтерстелларСравнение и копирование
- Структуры можно сравнивать
==, если все их поля сравнимы; сравнение идёт по каждому полю. Структуру со слайсом внутри сравнить нельзя:invalid operation: a == b (struct containing []string cannot be compared). - Присваивание структуры создаёт копию: изменения копии не затрагивают оригинал — это было видно на примере с
copiedвыше.
Структуры в Go по умолчанию ведут себя как значения: и сравнение, и присваивание работают с содержимым, а не со ссылкой.
Конструкторы
Встроенных конструкторов, как в Java или C#, в Go нет. Есть идиома: функция NewТип(...) возвращает готовый экземпляр. В ней ставят значения по умолчанию, проверяют входные данные и инициализируют сложные поля — время старта, мьютекс. Обычно конструктор возвращает указатель: с объектом дальше работают без лишнего копирования.
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)
}Алексей Интерстеллар true true
ошибка: нужны пользователь и фильмПрактика
Домашнее задание
- Профиль. Структура
Profile:UserName,Email(string),Age(int),Country(string),Premium(bool). Создай заполненный профиль и выведи поля; затем профиль без инициализации; затем профиль, где заданы толькоUserNameиEmail. - Устройство. Структура
Device:Name,Type(string),Active(bool). МетодыInfo() string,Activate(),Deactivate(). Создай устройство, выведи состояние, активируй, выведи, деактивируй, выведи. - Подписка. Структура
Subscription:Plan(string),Price(float64),AutoRenew(bool). КонструкторNewSubscription(plan string, price float64) *SubscriptionставитAutoRenew = true. МетодыCancelAutoRenew()иPrintDetails(). Создай подписку, выведи, отключи автопродление, выведи снова. - История просмотра.
Episodeс полямиTitle,Season,Durationи JSON-тегамиtitle,season,duration.WatchHistoryс полямиProfile,Episode,WatchedPercent,LastPositionMin. Выведи имя, email, название эпизода, процент и позицию; переведиEpisodeв JSON. - Избранное.
FavoriteListсо слайсомTitles []string. МетодыAdd(title string),PrintAll()иPrintUnique()— уникальные названия черезmap[string]struct{}. Вmainсоздай анонимную структуру статистики с полямиOwner stringиItemsCount int.
решениеЭталонное решение
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)
}{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}Тренировка: предскажи вывод
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)
}самопроверкаОтвет
2IncValue увеличил копию, оригинал не изменился. Два вызова 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ставит значения по умолчанию и проверяет данные.
