Как сравнить две структуры, срезы или карты (map) в Go на равенство?

Проблема сравнения сложных типов в Go

В Go оператор == работает только для сравнимых типов: числа, строки, булевы значения, указатели, каналы и структуры, состоящие только из сравнимых полей. Срезы и карты не являются сравнимыми — их можно сравнивать только с nil. Это сделано намеренно, чтобы избежать неоднозначности (например, как сравнивать карты с разными порядками ключей?).

Решение: reflect.DeepEqual

Стандартный способ — использовать reflect.DeepEqual из пакета reflect. Он рекурсивно сравнивает значения любой сложности, включая вложенные структуры, срезы, карты и даже циклические ссылки (с защитой от бесконечной рекурсии).

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
    Tags []string
}

func main() {
    // Сравнение структур
    p1 := Person{Name: "Alice", Age: 30, Tags: []string{"dev", "go"}}
    p2 := Person{Name: "Alice", Age: 30, Tags: []string{"dev", "go"}}
    fmt.Println("Структуры равны?", reflect.DeepEqual(p1, p2)) // true

    // Сравнение срезов
    slice1 := []int{1, 2, 3}
    slice2 := []int{1, 2, 3}
    fmt.Println("Срезы равны?", reflect.DeepEqual(slice1, slice2)) // true

    // Сравнение карт
    map1 := map[string]int{"a": 1, "b": 2}
    map2 := map[string]int{"b": 2, "a": 1}
    fmt.Println("Карты равны?", reflect.DeepEqual(map1, map2)) // true (порядок не важен)

    // Вложенные структуры
    type Nested struct {
        Data map[int]string
    }
    n1 := Nested{Data: map[int]string{1: "one"}}
    n2 := Nested{Data: map[int]string{1: "one"}}
    fmt.Println("Вложенные равны?", reflect.DeepEqual(n1, n2)) // true
}

Важные нюансы reflect.DeepEqual

• Производительность: reflect.DeepEqual использует рефлексию, что медленнее прямого сравнения. Для критичных к скорости участков кода лучше написать свою функцию сравнения.
• Типы должны совпадать: DeepEqual вернёт false, если типы разные (например, int32 vs int64).
• Пустые vs nil срезы: []int{} (пустой) и []int(nil) (nil) считаются разными, хотя их длина одинакова. Если это важно, обработайте отдельно.
• Циклические структуры: DeepEqual корректно обрабатывает циклические ссылки (не уходит в бесконечный цикл).

Альтернативы: ручное сравнение

Для простых случаев или когда нужна максимальная скорость, можно написать свою функцию:

func equalSlices(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 equalMaps(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
}

Для структур можно использовать ==, если все поля сравнимы. Если есть срез или карта — придётся писать свою логику или использовать DeepEqual.

Рекомендация

Для большинства случаев используйте reflect.DeepEqual — он прост и надёжен. Если важна производительность или нужен особый порядок сравнения (например, игнорировать порядок в срезе), напишите свою реализацию.

import "github.com/google/go-cmp/cmp"

p1 := Person{Name: "Alice", Age: 30}
p2 := Person{Name: "Alice", Age: 31}

fmt.Println(cmp.Diff(p1, p2)) // Выведет разницу: Age: -30, +31

opt := cmp.FilterPath(func(p cmp.Path) bool {
    return p.Last().String() == ".Age"
}, cmp.Ignore())

if !cmp.Equal(p1, p2, opt) {
    fmt.Println("Структуры различаются (кроме возраста)")
}