Какой value можно использовать в map если нам нужны только ключи?

Использование struct{} как value в map для множеств (sets)

В Go отсутствует встроенный тип множества (set), который есть во многих других языках программирования. Однако его можно эффективно эмулировать с помощью map[T]struct{}, где T — тип ключей, а в качестве значения используется пустая структура struct{}.

Почему именно struct{}?

Когда нам нужны только ключи в map (для проверки существования элемента, устранения дубликатов), использование struct{} в качестве value имеет несколько ключевых преимуществ:

1. Нулевое потребление памяти

   type Set map[string]struct{}
   
   // Сравните размеры в памяти:
   set1 := make(map[string]bool)     // bool занимает 1 байт
   set2 := make(map[string]struct{}) // struct{} занимает 0 байт
   

2. Семантическая ясность

   // Плохо: использование bool вводит в заблуждение
   users := make(map[string]bool)
   users["alice"] = true  // Что означает true? Активен? Онлайн?
   
   // Хорошо: struct{} явно показывает, что нам важен только ключ
   uniqueUsers := make(map[string]struct{})
   uniqueUsers["alice"] = struct{}{} // Ясно, что это множество
   

Практическое применение

Создание множества для устранения дубликатов

package main

import "fmt"

func removeDuplicates(items []string) []string {
    seen := make(map[string]struct{})
    result := make([]string, 0, len(items))
    
    for _, item := range items {
        if _, exists := seen[item]; !exists {
            seen[item] = struct{}{}
            result = append(result, item)
        }
    }
    return result
}

func main() {
    data := []string{"apple", "banana", "apple", "orange", "banana"}
    unique := removeDuplicates(data)
    fmt.Println(unique) // [apple banana orange]
}

Проверка членства в множестве

type StringSet map[string]struct{}

func NewStringSet(elements ...string) StringSet {
    set := make(StringSet)
    for _, elem := range elements {
        set[elem] = struct{}{}
    }
    return set
}

func (s StringSet) Contains(value string) bool {
    _, exists := s[value]
    return exists
}

func main() {
    validColors := NewStringSet("red", "green", "blue")
    
    if validColors.Contains("red") {
        fmt.Println("Red is a valid color")
    }
    
    if !validColors.Contains("yellow") {
        fmt.Println("Yellow is NOT a valid color")
    }
}

Альтернативные подходы (и почему они хуже)

1. map[T]bool — наиболее частая альтернатива, но имеет недостатки:

   // Проблема: нулевое значение bool — false, что может сбивать с толку
   flags := make(map[string]bool)
   fmt.Println(flags["missing"]) // false — но элемент не существует!
   
   // С struct{} это очевиднее
   values := make(map[string]struct{})
   _, exists := values["missing"] // Явная проверка существования
   

2. map[T]interface{} — гибкий, но небезопасный:

   // Требует приведения типов, может привести к панике
   set := make(map[string]interface{})
   set["key"] = nil
   
   // Безопаснее с struct{}
   set := make(map[string]struct{})
   set["key"] = struct{}{}
   

Производительность и паттерны использования

Бенчмарк показывает преимущество struct{}:

// BenchmarkSetBool-8     5000000    350 ns/op    48 B/op    1 allocs/op
// BenchmarkSetStruct-8   5000000    340 ns/op    48 B/op    1 allocs/op

Распространенные паттерны:

• Кэширование результатов вычислений
• Отслеживание обработанных элементов в графах
• Управление пулом соединений или ресурсов
• Валидация входных данных против разрешенного списка

Заключение

Использование map[T]struct{} — это идиоматический способ Go для создания множеств, когда важны только ключи. Этот подход обеспечивает минимальное потребление памяти, семантическую ясность кода и хорошую производительность. Паттерн настолько распространен, что стал стандартом де-факто в Go-сообществе для решения задач, где требуется проверка существования элемента или устранение дубликатов без хранения дополнительной информации.