Сравнение struct, slice и map в Go: полный разбор

Сравнение struct, slice и map в Go: от новичка до профи

Вы когда-нибудь писали на Go код, который должен был сравнить две структуры, два слайса или две мапы, и получали ошибку компиляции: invalid operation: cannot compare? Если да — вы не одиноки. Это один из самых популярных вопросов на Stack Overflow (десятки тысяч просмотров!), который ставит в тупик даже опытных разработчиков, перешедших на Go из других языков.

В этой статье мы раз и навсегда разберемся, как правильно сравнивать составные типы данных в Go. Вы узнаете, почему == не всегда работает, когда нужно использовать reflect.DeepEqual, и как написать свою эффективную функцию сравнения. Поехали!

Почему простое сравнение через == не всегда работает?

В Go оператор == работает только для сравнимых типов (comparable). К ним относятся:

• Базовые типы: int, string, bool, float и т.д.
• Указатели (pointer)
• Каналы (channel)
• Интерфейсы (если динамические типы сравнимы)
• Структуры, все поля которых являются сравнимыми
• Массивы (array), если элемент массива сравним

А вот слайсы (slice) и мапы (map) — не сравнимы напрямую через ==. Попытка сделать это приведет к ошибке компиляции. Почему? Потому что слайс — это ссылочный тип, который включает указатель на данные, длину и емкость. Два слайса могут быть "равны" по содержимому, но иметь разные внутренние структуры.

package main

import "fmt"

func main() {
    a := []int{1, 2, 3}
    b := []int{1, 2, 3}
    
    // Ошибка компиляции!
    // fmt.Println(a == b) 
    
    fmt.Println("Работает только с nil:")
    fmt.Println(a == nil) // false
    fmt.Println(b == nil) // false
}

То же самое касается мап. Единственное, что вы можете проверить через == — это равенство nil.

Сравнение структур (struct) в Go

Сравнение структур — самый коварный случай. Если все поля вашей структуры являются сравнимыми типами, то == работает!

type Person struct {
    Name string
    Age  int
}

func main() {
    p1 := Person{"Alice", 30}
    p2 := Person{"Alice", 30}
    
    fmt.Println(p1 == p2) // true — работает!
}

Но беда приходит, когда в структуре есть слайс или мапа:

type PersonWithHobbies struct {
    Name    string
    Age     int
    Hobbies []string  // слайс — не сравнимый тип
}

func main() {
    p1 := PersonWithHobbies{"Bob", 25, []string{"reading", "coding"}}
    p2 := PersonWithHobbies{"Bob", 25, []string{"reading", "coding"}}
    
    // Ошибка компиляции!
    // fmt.Println(p1 == p2)
}

В этом случае компилятор Go выдаст ошибку: struct containing []string cannot be compared.

Решение №1: reflect.DeepEqual — универсальный, но медленный

Самый простой способ сравнить любые сложные типы — использовать функцию reflect.DeepEqual из стандартной библиотеки Go. Она рекурсивно обходит структуры, слайсы, мапы и сравнивает их содержимое.

import (
    "fmt"
    "reflect"
)

func main() {
    // Сравнение слайсов
    a := []int{1, 2, 3}
    b := []int{1, 2, 3}
    fmt.Println(reflect.DeepEqual(a, b)) // true
    
    // Сравнение мап
    m1 := map[string]int{"a": 1, "b": 2}
    m2 := map[string]int{"a": 1, "b": 2}
    fmt.Println(reflect.DeepEqual(m1, m2)) // true
    
    // Сравнение структур с не сравнимыми полями
    p1 := PersonWithHobbies{"Bob", 25, []string{"reading"}}
    p2 := PersonWithHobbies{"Bob", 25, []string{"reading"}}
    fmt.Println(reflect.DeepEqual(p1, p2)) // true
}

Плюсы:

• Работает для любых типов
• Не нужно писать свой код сравнения
• Рекурсивно обходит вложенные структуры

Минусы:

• Медленный (использует рефлексию)
• Не различает типы: int(1) != int8(1) вернет false
• Может паниковать на циклических ссылках
• Не подходит для hot-path в продакшене

Решение №2: Кастомное сравнение — быстро и точно

Если производительность критична, или вам нужно тонкое управление сравнением (например, игнорировать порядок элементов), лучше написать свою функцию.

Сравнение слайсов

func slicesEqual(a, b []int) bool {
    if len(a) != len(b) {
        return false
    }
    for i := range a {
        if a[i] != b[i] {
            return false
        }
    }
    return true
}

func main() {
    a := []int{1, 2, 3}
    b := []int{1, 2, 3}
    fmt.Println(slicesEqual(a, b)) // true
}

Если порядок не важен — сначала отсортируйте слайсы, потом сравнивайте.

Сравнение мап

func mapsEqual(a, b map[string]int) bool {
    if len(a) != len(b) {
        return false
    }
    for k, v := range a {
        if bv, ok := b[k]; !ok || bv != v {
            return false
        }
    }
    return true
}

Для структур с не сравнимыми полями просто добавьте метод:

func (p PersonWithHobbies) Equal(other PersonWithHobbies) bool {
    if p.Name != other.Name || p.Age != other.Age {
        return false
    }
    if len(p.Hobbies) != len(other.Hobbies) {
        return false
    }
    for i := range p.Hobbies {
        if p.Hobbies[i] != other.Hobbies[i] {
            return false
        }
    }
    return true
}

Решение №3: Использование библиотеки go-cmp (рекомендуется)

Для продакшен-кода я настоятельно рекомендую библиотеку github.com/google/go-cmp. Она создана командой Google и решает почти все проблемы сравнения:

• Человекочитаемый diff при несовпадении
• Возможность игнорировать поля
• Сравнение с учетом экспортируемых/неэкспортируемых полей
• Настраиваемые опции

import (
    "fmt"
    "github.com/google/go-cmp/cmp"
)

func main() {
    p1 := PersonWithHobbies{"Bob", 25, []string{"reading"}}