Если вы перешли на Go с других языков программирования (как я), таких как C#, Java или Python, вы наверняка заметили, что Go не имеет встроенной поддержки перечислений (enumerations). Это может стать серьезным препятствием, когда нужно работать с фиксированным набором значений, обеспечивая при этом типобезопасность и читаемость кода.
Представьте: вы разрабатываете приложение, где пользователи могут иметь различные роли — "администратор", "пользователь", "гость". В C# вы бы просто написали:
| C# | 1
2
3
4
5
6
| enum UserRole
{
Admin,
User,
Guest
} |
|
"Почему в Go нет енумов?" — вопрос, который можно услышать от многих разработчиков. Причина кроется в философии языка: Go стремится к простоте и минимализму в своих конструкциях. Создатели языка решили, что существующие примитивы — константы, типы и подходящие идиомы — достаточны для реализации большинства сценариев использования перечислений. Я сам, перейдя с C# на Go, испытывал некоторую ностальгию по мощным енумам, которые позволяли компилятору ловить множество ошибок на этапе сборки. В C# перечисления были полноценными типами, которые нельзя было спутать с другими. В Go же мне пришлось искать пути реализации привычной функциональности.
Базовый подход к перечислениям
Классический способ эмулировать перечисления в Go — использование именованных констант. Это самый простой, но не лишенный недостатков подход. Рассмотрим его на примере:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| package main
import "fmt"
const (
StatusPending = "PENDING"
StatusApproved = "APPROVED"
StatusRejected = "REJECTED"
)
func ProcessStatus(status string) {
fmt.Printf("Processing status: %s\n", status)
}
func main() {
ProcessStatus(StatusPending)
ProcessStatus("CANCELLED") // Ничто не мешает передать любую строку
} |
|
ProcessStatus принимает любое строковое значение, даже если оно не определено в нашем "перечислении". Компилятор не выдаст никакой ошибки при передаче произвольной строки. Давайте попробуем улучшить ситуацию, введя пользовательский тип:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| package main
import "fmt"
type Status string
const (
StatusPending Status = "PENDING"
StatusApproved Status = "APPROVED"
StatusRejected Status = "REJECTED"
)
func ProcessStatus(status Status) {
fmt.Println(status)
}
func main() {
ProcessStatus(StatusPending)
ProcessStatus("CANCELLED") // Компилятор неявно приводит строку к типу Status
} |
|
Status, поскольку оба имеют одинаковый базовый тип string.
Что касается производительности различных подходов, простые константы и типы на их основе практически не создают дополнительных накладных расходов. Поскольку преобразования типов в Go выполняются во время компиляции, а не выполнения, такой подход не влияет на скорость работы программы. Кроме того если использовать string или int в качестве базового типа перечисления, компилятор Go не сможет защитить нас от передачи неправильных значений. Как видно из листинга 1, мы легко можем передать строку "CUSTOMER", которая не входит в определенный набор ролей.
| Go | 1
2
3
4
5
6
7
8
| func PrintRole(r Role) {
fmt.Println(r)
}
func main() {
PrintRole(RoleAdmin) // Работает как ожидалось
PrintRole("CUSTOMER") // Компилятор разрешает это, хотя такой роли нет!
} |
|
| Go | 1
2
3
4
5
6
7
| type Role struct {
name string
}
func (r Role) Name() string {
return r.name
} |
|
1. Компилятор Go не позволит неявно преобразовывать строку в Role.
2. Мы получаем инкапсуляцию - поле name скрыто от прямого доступа.
3. Метод Name() контролирует доступ к значению перечисления.
Определив набор допустимых значений, мы используем переменные вместо констант:
| Go | 1
2
3
4
| var (
RoleAdmin = Role{"ADMIN"}
RoleUser = Role{"USER"}
) |
|
Role, вызовет ошибку компиляции:
| Go | 1
| cannot use "CUSTOMER" (untyped string constant) as Role value in argument to PrintRole |
|
Role, которое не входит в определённый набор. Второй – использование переменных вместо констант, что позволяет теоретически изменить значения перечислений извне пакета:
| Go | 1
2
| var r user.Role // Создаст нулевое значение
user.RoleAdmin = user.Role{"CHANGED"} // Может изменить определённое значение |
|
| Go | 1
2
3
4
5
6
7
8
9
| // Проверяет, является ли роль допустимым значением из определённого набора
func IsValidRole(r Role) bool {
for _, validRole := range []Role{RoleAdmin, RoleUser} {
if r == validRole {
return true
}
}
return false
} |
|
Role вне определённого набора значений. Для этого можно использовать функцию-конструктор, проверяющую значение по карте допустимых значений:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
| var roles = map[string]Role{
RoleAdmin.name: RoleAdmin,
RoleUser.name: RoleUser,
}
func ParseRole(value string) (Role, error) {
role, exists := roles[value]
if !exists {
return Role{}, fmt.Errorf("invalid role %q", value)
}
return role, nil
} |
|
Найти сумму перечислений в запросе Объём перечислений
Как найти сумму перечислений в запросе объём перечислений? Преимущества перечислений
В чем заключаются преимущества перечислений по сравнению со справочниками? Диапазон перечислений
Как узнать диапазон перечислений?
enum e2 {a = 3, b = 9};
В книге написано диапазон перечислений равен (0; 15)
Говорится что вычисляется... Сериализация перечислений
Существует ли простой способ использовать для сериализации пользовательскую функцию? Например, я хочу, чтобы enum или bool сериализовались как числа,...
Продвинутые техники
Еще один полезный подход в работе с перечислениями — это использование техники "строгой типизации с iota". Она хорошо подходит для случаев, когда фактическое значение перечисления имеет меньшее значение, чем сам тип, но требуется последовательная нумерация:
| Go | 1
2
3
4
5
6
7
8
| type Direction int
const (
North Direction = iota
East
South
West
) |
|
Role мы можем расширить функциональность, добавив методы, которые позволят сравнивать роли без доступа к внутреннему состоянию:
| Go | 1
2
3
4
5
6
7
8
9
10
11
| func (r Role) Is(other Role) bool {
return r.name == other.name
}
func (r Role) IsAdmin() bool {
return r.Is(RoleAdmin)
}
func (r Role) IsUser() bool {
return r.Is(RoleUser)
} |
|
| Go | 1
2
3
| func CanModifySettings(r Role) bool {
return r.IsAdmin() // Семантически ясно и безопасно
} |
|
| Go | 1
2
3
4
5
6
7
| func AllRoles() []Role {
var result []Role
for _, role := range roles {
result = append(result, role)
}
return result
} |
|
Кастомная валидация значений перечислений может быть особенно полезна в сложных сценариях. Например, мы можем добавить валидацию по бизнес-правилам:
| Go | 1
2
3
4
5
6
| func IsRoleAllowedForProduct(r Role, productType string) bool {
if productType == "enterprise" {
return r.IsAdmin()
}
return true // В других случаях любая роль подходит
} |
|
| Go | 1
2
3
4
5
6
| func (r Role) HasPrivilegesOf(other Role) bool {
if r.IsAdmin() {
return true // Администратор имеет все привилегии
}
return r == other // Другие роли имеют только свои привилегии
} |
|
Role.
Практические примеры
Начнём с реализации типобезопасного перечисления, которое будем использовать в различных контекстах.
Представим, что разрабатываем систему управления заказами с различными статусами. Нам нужен тип OrderStatus, который будет использоваться для отслеживания состояния заказа:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| package order
import (
"encoding/json"
"fmt"
)
type OrderStatus struct {
name string
}
func (s OrderStatus) Name() string {
return s.name
}
var (
StatusNew = OrderStatus{"NEW"}
StatusPaid = OrderStatus{"PAID"}
StatusShipping = OrderStatus{"SHIPPING"}
StatusDelivered = OrderStatus{"DELIVERED"}
StatusCanceled = OrderStatus{"CANCELED"}
)
var statuses = map[string]OrderStatus{
StatusNew.name: StatusNew,
StatusPaid.name: StatusPaid,
StatusShipping.name: StatusShipping,
StatusDelivered.name: StatusDelivered,
StatusCanceled.name: StatusCanceled,
}
func ParseOrderStatus(value string) (OrderStatus, error) {
status, exists := statuses[value]
if !exists {
return OrderStatus{}, fmt.Errorf("неверный статус заказа %q", value)
}
return status, nil
} |
|
Сериализация и десериализация
Для корректной работы нашего типа с форматами вроде JSON, XML или другими текстовыми представлениями, реализуем интерфейсы TextMarshaler и TextUnmarshaler:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
| func (s OrderStatus) MarshalText() ([]byte, error) {
return []byte(s.name), nil
}
func (s *OrderStatus) UnmarshalText(data []byte) error {
status, err := ParseOrderStatus(string(data))
if err != nil {
return err
}
*s = status
return nil
} |
|
json, xml и другие. Проверим, как это работает:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
| func ExampleOrderStatus_JSON() {
order := struct {
ID string
Status OrderStatus
Items int
}{
ID: "ORD-12345",
Status: StatusPaid,
Items: 3,
}
// Сериализуем в JSON
data, err := json.Marshal(order)
if err != nil {
fmt.Println("Ошибка сериализации:", err)
return
}
fmt.Println("JSON:", string(data))
// Десериализуем из JSON
var newOrder struct {
ID string
Status OrderStatus
Items int
}
input := []byte(`{"ID":"ORD-54321","Status":"SHIPPING","Items":5}`)
if err := json.Unmarshal(input, &newOrder); err != nil {
fmt.Println("Ошибка десериализации:", err)
return
}
fmt.Printf("Десериализовано: ID=%s, Status=%s, Items=%d\n",
newOrder.ID, newOrder.Status.Name(), newOrder.Items)
// Попробуем десериализовать неверный статус
input = []byte(`{"ID":"ORD-99999","Status":"WRONG","Items":1}`)
if err := json.Unmarshal(input, &newOrder); err != nil {
fmt.Println("Ожидаемая ошибка:", err)
}
// Вывод:
// JSON: {"ID":"ORD-12345","Status":"PAID","Items":3}
// Десериализовано: ID=ORD-54321, Status=SHIPPING, Items=5
// Ожидаемая ошибка: неверный статус заказа "WRONG"
} |
|
Обработка ошибок
В высоконагруженных системах обработка ошибок не менее важна, чем сама бизнес-логика. Для наших перечислений могут потребоваться специализированные механизмы обработки ошибок. Например, создадим тип ошибки, предназначенный для проблем, связанных со статусом заказа:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| type StatusError struct {
Value string
AllowedTo []OrderStatus
Message string
}
func (e *StatusError) Error() string {
var allowed []string
for _, s := range e.AllowedTo {
allowed = append(allowed, s.Name())
}
return fmt.Sprintf("%s: значение '%s', допустимые статусы: %s",
e.Message, e.Value, strings.Join(allowed, ", "))
}
// Создаёт ошибку перехода в недопустимый статус
func NewStatusTransitionError(from, to OrderStatus, allowedTo ...OrderStatus) *StatusError {
return &StatusError{
Value: to.Name(),
AllowedTo: allowedTo,
Message: fmt.Sprintf("недопустимый переход из статуса '%s'", from.Name()),
}
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| func (o *Order) UpdateStatus(newStatus OrderStatus) error {
switch o.Status {
case StatusNew:
// Из статуса NEW можем перейти только в PAID или CANCELED
if newStatus != StatusPaid && newStatus != StatusCanceled {
return NewStatusTransitionError(o.Status, newStatus,
StatusPaid, StatusCanceled)
}
case StatusPaid:
// Из PAID только в SHIPPING или CANCELED
if newStatus != StatusShipping && newStatus != StatusCanceled {
return NewStatusTransitionError(o.Status, newStatus,
StatusShipping, StatusCanceled)
}
// ... другие правила перехода между статусами
default:
return fmt.Errorf("неизвестный исходный статус: %s", o.Status.Name())
}
o.Status = newStatus
return nil
} |
|
Интеграция с внешними API
При интеграции с внешними API часто нужно преобразовывать внутренние перечисления в форматы, понятные другим системам, и наоборот. Например, в RESTful API часто используют строковые значения для статусов, а в базах данных — числа. Добавим методы для интеграции с БД:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| // Сопоставление статусов с кодами в БД
var statusToDBCode = map[OrderStatus]int{
StatusNew: 1,
StatusPaid: 2,
StatusShipping: 3,
StatusDelivered: 4,
StatusCanceled: 5,
}
var dbCodeToStatus = map[int]OrderStatus{
1: StatusNew,
2: StatusPaid,
3: StatusShipping,
4: StatusDelivered,
5: StatusCanceled,
}
// Преобразует статус в код для БД
func (s OrderStatus) ToDBCode() (int, error) {
code, exists := statusToDBCode[s]
if !exists {
return 0, fmt.Errorf("не удалось преобразовать статус %s в код БД", s.Name())
}
return code, nil
}
// Создаёт статус из кода БД
func StatusFromDBCode(code int) (OrderStatus, error) {
status, exists := dbCodeToStatus[code]
if !exists {
return OrderStatus{}, fmt.Errorf("неизвестный код статуса в БД: %d", code)
}
return status, nil
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| // Сопоставление с форматом партнёрского API
var statusToPartnerFormat = map[OrderStatus]string{
StatusNew: "order_created",
StatusPaid: "payment_received",
StatusShipping: "in_transit",
StatusDelivered: "completed",
StatusCanceled: "order_canceled",
}
var partnerFormatToStatus = map[string]OrderStatus{
"order_created": StatusNew,
"payment_received": StatusPaid,
"in_transit": StatusShipping,
"completed": StatusDelivered,
"order_canceled": StatusCanceled,
}
func (s OrderStatus) ToPartnerFormat() (string, error) {
format, exists := statusToPartnerFormat[s]
if !exists {
return "", fmt.Errorf("не удалось преобразовать статус %s в формат партнёра", s.Name())
}
return format, nil
}
func StatusFromPartnerFormat(format string) (OrderStatus, error) {
status, exists := partnerFormatToStatus[format]
if !exists {
return OrderStatus{}, fmt.Errorf("неизвестный формат статуса партнёра: %s", format)
}
return status, nil
} |
|
Нестандартные решения
Стандартный подход к перечислениям в Go весьма практичен, но иногда требуются более сложные или специализированные решения. Предлагаю исследовать несколько необычных, но полезных способов реализации перечислений для особых случаев.
Перечисления с поведением
Иногда нам нужно, чтобы перечисления обладали не только данными, но и поведением. Представьте систему расчёта стоимости доставки с разными стратегиями:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
| package shipping
import "fmt"
// Стратегия доставки
type DeliveryMethod struct {
name string
calculate func(weight float64, distance int) float64
}
func (d DeliveryMethod) Name() string {
return d.name
}
// Расчёт стоимости доставки
func (d DeliveryMethod) Calculate(weight float64, distance int) float64 {
return d.calculate(weight, distance)
}
// Определяем доступные методы доставки с их логикой расчёта
var (
Standard = DeliveryMethod{
name: "STANDARD",
calculate: func(weight float64, distance int) float64 {
return weight*0.5 + float64(distance)*0.1
},
}
Express = DeliveryMethod{
name: "EXPRESS",
calculate: func(weight float64, distance int) float64 {
return weight*0.75 + float64(distance)*0.15 + 10
},
}
NextDay = DeliveryMethod{
name: "NEXT_DAY",
calculate: func(weight float64, distance int) float64 {
return weight*1.0 + float64(distance)*0.2 + 25
},
}
)
// Карта для валидации и десериализации
var methods = map[string]DeliveryMethod{
Standard.name: Standard,
Express.name: Express,
NextDay.name: NextDay,
}
func ParseDeliveryMethod(name string) (DeliveryMethod, error) {
method, exists := methods[name]
if !exists {
return DeliveryMethod{}, fmt.Errorf("неизвестный метод доставки: %q", name)
}
return method, nil
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
| func CalculateShipping(items []Item, method DeliveryMethod, distance int) float64 {
var totalWeight float64
for _, item := range items {
totalWeight += item.Weight
}
return method.Calculate(totalWeight, distance)
}
// Пример вызова
price := CalculateShipping(orderItems, shipping.Express, 150)
fmt.Printf("Стоимость доставки: %.2f\n", price) |
|
Динамически создаваемые перечисления
В некоторых ситуациях нам может потребоваться создавать значения перечислений динамически, например, когда список допустимых значений загружается из конфигурации или внешней системы. Рассмотрим пример с категориями товаров, которые могут меняться:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
| package category
import (
"fmt"
"sync"
)
type Category struct {
id int
name string
}
func (c Category) ID() int {
return c.id
}
func (c Category) Name() string {
return c.name
}
// Потокобезопасное хранилище категорий
type categoryRegistry struct {
mu sync.RWMutex
categories map[string]Category
nextID int
}
var registry = &categoryRegistry{
categories: make(map[string]Category),
nextID: 1,
}
// Регистрирует новую категорию или возвращает существующую
func Register(name string) Category {
registry.mu.Lock()
defer registry.mu.Unlock()
if category, exists := registry.categories[name]; exists {
return category
}
category := Category{
id: registry.nextID,
name: name,
}
registry.nextID++
registry.categories[name] = category
return category
}
// Получает категорию по имени
func Get(name string) (Category, error) {
registry.mu.RLock()
defer registry.mu.RUnlock()
category, exists := registry.categories[name]
if !exists {
return Category{}, fmt.Errorf("категория не найдена: %q", name)
}
return category, nil
}
// Получает все зарегистрированные категории
func All() []Category {
registry.mu.RLock()
defer registry.mu.RUnlock()
result := make([]Category, 0, len(registry.categories))
for _, category := range registry.categories {
result = append(result, category)
}
return result
}
// Предопределенные категории (опционально)
var (
Electronics = Register("Electronics")
Clothing = Register("Clothing")
Books = Register("Books")
) |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
| // Динамическая регистрация категорий из конфига
func LoadCategoriesFromConfig(categoryNames []string) {
for _, name := range categoryNames {
Register(name)
}
}
// Использование
sportCategory := category.Register("Sports")
// Получение всех категорий
allCategories := category.All()
fmt.Printf("Всего категорий: %d\n", len(allCategories)) |
|
Битовые маски как альтернатива классическим перечислениям
Для случаев, когда нужно хранить комбинацию флагов или разрешений, обычные перечисления могут быть не самым удобным решением. Вместо этого можно использовать битовые маски:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
| package permission
import "strings"
// Тип разрешений
type Permission uint32
// Определяем базовые разрешения (степени двойки)
const (
None Permission = 0
Read Permission = 1 << iota // 1
Write // 2
Execute // 4
Delete // 8
Admin // 16
)
// Предопределенные комбинации
const (
ReadOnly = Read
ReadWrite = Read | Write
Full = Read | Write | Delete | Execute
Super = Full | Admin
)
// Проверяет наличие всех указанных разрешений
func (p Permission) Has(perm Permission) bool {
return p&perm == perm
}
// Проверяет наличие хотя бы одного из указанных разрешений
func (p Permission) HasAny(perm Permission) bool {
return p&perm != 0
}
// Добавляет разрешения
func (p Permission) Grant(perm Permission) Permission {
return p | perm
}
// Отзывает разрешения
func (p Permission) Revoke(perm Permission) Permission {
return p &^ perm
}
// Возвращает строковое представление
func (p Permission) String() string {
if p == None {
return "None"
}
var perms []string
if p.Has(Read) {
perms = append(perms, "Read")
}
if p.Has(Write) {
perms = append(perms, "Write")
}
if p.Has(Execute) {
perms = append(perms, "Execute")
}
if p.Has(Delete) {
perms = append(perms, "Delete")
}
if p.Has(Admin) {
perms = append(perms, "Admin")
}
return strings.Join(perms, "|")
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| // Задаём разрешения пользователю
userPerms := permission.ReadWrite.Grant(permission.Execute)
// Проверяем разрешения
if userPerms.Has(permission.Read) {
fmt.Println("Пользователь может читать")
}
if !userPerms.Has(permission.Admin) {
fmt.Println("Пользователь не администратор")
}
// Отзываем разрешение
userPerms = userPerms.Revoke(permission.Write)
fmt.Printf("Разрешения пользователя: %s\n", userPerms) // "Read|Execute" |
|
Комбинирование с другими паттернами
Перечисления можно комбинировать с другими паттернами, создавая более сложные и гибкие системы. Например, объединим перечисление и фабрику:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
| package notification
import (
"fmt"
"io"
)
// Интерфейс отправки уведомлений
type Sender interface {
Send(recipient string, message string) error
}
// Тип канала уведомлений
type Channel struct {
name string
createFn func() (Sender, error)
}
func (c Channel) Name() string {
return c.name
}
// Создаёт отправителя для данного канала
func (c Channel) CreateSender() (Sender, error) {
return c.createFn()
}
// Предопределённые каналы
var (
Email = Channel{
name: "EMAIL",
createFn: func() (Sender, error) {
return &emailSender{}, nil
},
}
SMS = Channel{
name: "SMS",
createFn: func() (Sender, error) {
return &smsSender{}, nil
},
}
Push = Channel{
name: "PUSH",
createFn: func() (Sender, error) {
return &pushSender{}, nil
},
}
)
var channels = map[string]Channel{
Email.name: Email,
SMS.name: SMS,
Push.name: Push,
}
func ParseChannel(name string) (Channel, error) {
channel, exists := channels[name]
if !exists {
return Channel{}, fmt.Errorf("неизвестный канал уведомлений: %q", name)
}
return channel, nil
}
// Реализации отправителей (для примера)
type emailSender struct{}
func (s *emailSender) Send(recipient, message string) error {
fmt.Printf("[EMAIL] Отправка %q на %s\n", message, recipient)
return nil
}
type smsSender struct{}
func (s *smsSender) Send(recipient, message string) error {
fmt.Printf("[SMS] Отправка %q на %s\n", message, recipient)
return nil
}
type pushSender struct{}
func (s *pushSender) Send(recipient, message string) error {
fmt.Printf("[PUSH] Отправка %q на %s\n", message, recipient)
return nil
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| func SendNotification(channel Channel, recipient, message string) error {
sender, err := channel.CreateSender()
if err != nil {
return fmt.Errorf("ошибка создания отправителя: %w", err)
}
return sender.Send(recipient, message)
}
// Использование
err := SendNotification(notification.SMS, "+7123456789", "Ваш заказ отправлен")
if err != nil {
log.Fatalf("Ошибка отправки уведомления: %v", err)
} |
|
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
| package transaction
import (
"fmt"
"time"
)
// Тип триггера для автоматического перехода между статусами
type TransitionTrigger struct {
description string
checkFn func(tx *Transaction) bool
}
// Тип статуса транзакции с возможными переходами
type Status struct {
name string
transitions map[string]TransitionTrigger
}
func (s Status) Name() string {
return s.name
}
// Проверяет, должна ли транзакция перейти в другой статус
func (s Status) CheckTransitions(tx *Transaction) (Status, bool) {
for nextStatusName, trigger := range s.transitions {
if trigger.checkFn(tx) {
if nextStatus, err := ParseStatus(nextStatusName); err == nil {
return nextStatus, true
}
}
}
return s, false
}
// Предопределённые статусы
var (
Pending = Status{
name: "PENDING",
transitions: map[string]TransitionTrigger{
"COMPLETED": {
description: "Транзакция подтверждена",
checkFn: func(tx *Transaction) bool {
return tx.IsConfirmed && !tx.IsRefunded
},
},
"FAILED": {
description: "Истекло время ожидания",
checkFn: func(tx *Transaction) bool {
return time.Since(tx.CreatedAt) > tx.Timeout && !tx.IsConfirmed
},
},
},
}
Completed = Status{
name: "COMPLETED",
transitions: map[string]TransitionTrigger{
"REFUNDED": {
description: "Запрошен возврат",
checkFn: func(tx *Transaction) bool {
return tx.IsRefunded
},
},
},
}
Failed = Status{
name: "FAILED",
transitions: map[string]TransitionTrigger{},
}
Refunded = Status{
name: "REFUNDED",
transitions: map[string]TransitionTrigger{},
}
)
// Для удобства валидации и десериализации
var statuses = map[string]Status{
Pending.name: Pending,
Completed.name: Completed,
Failed.name: Failed,
Refunded.name: Refunded,
}
func ParseStatus(name string) (Status, error) {
status, exists := statuses[name]
if !exists {
return Status{}, fmt.Errorf("неизвестный статус транзакции: %q", name)
}
return status, nil
}
// Простая модель транзакции для примера
type Transaction struct {
ID string
Amount float64
Status Status
IsConfirmed bool
IsRefunded bool
CreatedAt time.Time
Timeout time.Duration
}
// Обновляет статус по правилам переходов
func (tx *Transaction) UpdateStatus() bool {
newStatus, changed := tx.Status.CheckTransitions(tx)
if changed {
tx.Status = newStatus
}
return changed
} |
|
Многоуровневые перечисления
Иногда нам требуется иерархическая структура для перечислений. Например, для классификации товаров в интернет-магазине:
| Go | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
| package product
type Category struct {
name string
parent *Category
children []*Category
}
func (c *Category) Name() string {
return c.name
}
func (c *Category) FullPath() string {
if c.parent == nil {
return c.name
}
return c.parent.FullPath() + " > " + c.name
}
func (c *Category) AddChild(name string) *Category {
child := &Category{
name: name,
parent: c,
}
c.children = append(c.children, child)
return child
}
// Корневые категории
var (
Electronics = &Category{name: "Electronics"}
Clothing = &Category{name: "Clothing"}
Food = &Category{name: "Food"}
)
// Инициализируем подкатегории
func init() {
// Электроника
Phones := Electronics.AddChild("Phones")
Phones.AddChild("Smartphones")
Phones.AddChild("Feature phones")
Computers := Electronics.AddChild("Computers")
Computers.AddChild("Laptops")
Computers.AddChild("Desktops")
// Одежда и т.д.
} |
|
Заключение и рекомендации
Язык Go не имеет встроенных перечислений, но предоставляет гибкие инструменты для их моделирования. Выбор конкретного подхода должен основываться на балансе между типобезопасностью, удобством использования и производительностью. Для простых случаев, где достаточно использовать несколько именованных значений, подойдут константы с базовым типом:
| Go | 1
2
3
4
5
6
7
8
| type Direction int
const (
North Direction = iota
East
South
West
) |
|
| Go | 1
2
3
4
5
6
7
8
| type Role struct {
name string
}
var (
RoleAdmin = Role{"ADMIN"}
RoleUser = Role{"USER"}
) |
|
При выборе между string и int в качестве базового типа:- Используйте
string, если значения перечисления должны быть человекочитаемыми или передаются через API.
- Предпочтите
int с iota, когда важна производительность и компактность хранения.
Для сложных сценариев, когда перечисления должны содержать поведение или бизнес-логику, обратите внимание на подход с встраиванием функций в структуру перечисления или комбинирование с паттерном "Стратегия". Битовые маски идеально подходят для представления набора флагов или разрешений, особенно когда значения могут комбинироваться. В этом случае используйте константы со степенями двойки и битовые операторы.
Нет универсального "правильного" подхода — выбор зависит от конкретной ситуации. Главное правило: чем выше риск ошибок и чем важнее типобезопасность, тем более строгую реализацию следует выбрать.
Хранение перечислений в БД
Как лучше сделать, для каждого типа перечисления создавать таблицу, или хранить все в одной? Оформление перечислений
Добрый день, участники киберфорума.
Вопрос мой про оформление перечисления. У меня есть некий класс. Допустим Logger. В нем есть перечисление... Форматирование перечислений
Здравствуйте!
Подскажите, пожалуйста, почему в данном примере если у перечисления убрать атрибут Flags спецификатор формата: "F"... Возможен ли массив перечислений?
Можно ли определить массив, элементами которого будут различные перечисления из некоторого числа определенных?
Поскольку различные конкретные... Форма редактирования перечислений
Привет, возможно ли сделать форму для редактирования перечислений (удалить, добавить, редактировать)? Знаю есть стандартные
... Вопрос по синтаксису перечислений
Какой из наборов перечисляемых значений записан правильно:
1. enum {a, b = 3, c, d }
2. enum { a, b, 3, 4 }
3. enum { a, b = 3, c = 4, 3 }
... Обход ограниечения перечислений
Здравствуйте. Помогите пожалуйста решить следующую задачу. Необходимо обойти ограничение перечислений, которое не позволяет кроме численного значения... Подсчет перечислений в отчете
подскажите пожалуйста,у меня в бд есть перечисление,в нем 2 варианта,как мне сделать подсчет 1 варианта перечисления,в отчете Генерация диста из двух перечислений
Привет всем!
Есть два перечисления, условно масти и значения. Подскажите пожалуйста в общем как можно сделать так чтобы автоматически... Заполнение свойств класса из перечислений
Добрый вечер. Такой вопрос:
Есть класс с работниками, в котором надо разработать метод для случайного заполнения свойств класса (имя, фамилия, пол,... Программирование с использованием перечислений, структур
Вывести список на экран, упорядочив названия пункта назначение рейсов в алфавитном порядке
После ввода название пункта , номер рейса, тип самолета... Переписать класс с использованием перечислений
Подскажите как переписать класс с использованием перечислений
public class Material {
private final String NAME;
//private double densite; ...
|
