Как правильно сравнить два среза (slice) в Go на равенство элементов и длины?

Проблема: почему нельзя использовать == для срезов?

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

Есть три основных способа сравнить содержимое двух срезов. Рассмотрим их от самого простого к самому продвинутому.

Способ 1: Использование reflect.DeepEqual (простой, но медленный)

Пакет reflect предоставляет функцию DeepEqual, которая рекурсивно сравнивает любые два значения, включая срезы, карты, структуры. Это самый короткий путь для прототипирования или тестов.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    a := []int{1, 2, 3}
    b := []int{1, 2, 3}
    c := []int{1, 2, 4}

    fmt.Println(reflect.DeepEqual(a, b)) // true
    fmt.Println(reflect.DeepEqual(a, c)) // false
    fmt.Println(reflect.DeepEqual(a, []int{})) // false
    fmt.Println(reflect.DeepEqual([]int{}, []int(nil))) // false (пустой vs nil)
}

Недостатки:

• Производительность: reflect использует рефлексию во время выполнения, что медленнее, чем прямой цикл. На больших срезах (десятки тысяч элементов) разница может быть значительной.
• Типобезопасность: Функция принимает interface{}, поэтому ошибка в типе (например, передать []int и []int32) не отловится на этапе компиляции — просто вернётся false.
• Поведение с nil: reflect.DeepEqual([]int{}, []int(nil)) возвращает false, что может быть неожиданным, если вы считаете пустой срез и nil-срез "одинаковыми".

Способ 2: Написать свою функцию (рекомендуемый, производительный)

Лучший подход для production-кода — написать простую функцию, которая сначала проверяет длину, а затем поэлементно сравнивает значения. Для базовых типов (int, string, float и т.д.) это делается за O(n).

package main

import "fmt"

// EqualInts проверяет, равны ли два среза int по содержимому и порядку.
func EqualInts(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}
    c := []int{1, 2}

    fmt.Println(EqualInts(a, b)) // true
    fmt.Println(EqualInts(a, c)) // false
    // Работает с nil и пустыми срезами:
    fmt.Println(EqualInts(nil, []int{})) // true (len 0 == len 0)
}

Преимущества:

• Максимальная скорость — нет накладных расходов на рефлексию.
• Понятное поведение: nil-срез и пустой срез считаются равными (если длина 0).
• Типобезопасность на этапе компиляции — вы явно указываете тип.

Совет: Если вам нужно сравнивать срезы разных типов (например, []string, []float64), создайте отдельные функции или используйте дженерики (Go 1.18+).

Способ 3: Дженерики (Go 1.18+) — универсальная функция

Начиная с Go 1.18, вы можете написать обобщённую функцию для любых сравнимых типов:

package main

import "fmt"

// EqualSlice сравнивает два среза любого типа, поддерживающего оператор ==.
func EqualSlice[T comparable](a, b []T) bool {
    if len(a) != len(b) {
        return false
    }
    for i := range a {
        if a[i] != b[i] {
            return false
        }
    }
    return true
}

func main() {
    // Можно использовать с любым типом, где есть ==
    fmt.Println(EqualSlice([]int{1,2}, []int{1,2}))   // true
    fmt.Println(EqualSlice([]string{"a"}, []string{"b"})) // false
    fmt.Println(EqualSlice([]float64{1.0}, []float64{1.0})) // true
}

Это идеальный компромисс между производительностью и переиспользованием кода.

Резюме

• Для быстрого прототипирования или тестов — reflect.DeepEqual.
• Для production-кода — напишите свою функцию или используйте дженерики.
• Избегайте преобразования в строку (fmt.Sprintf) — это медленно и ненадёжно.
• Помните про разницу между nil и пустым срезом — выбирайте поведение осознанно.

package main

import (
    "bytes"
    "fmt"
)

func main() {
    a := []byte{0x01, 0x02, 0x03}
    b := []byte{0x01, 0x02, 0x03}
    c := []byte{0x01, 0x02, 0xFF}

    fmt.Println(bytes.Equal(a, b)) // true
    fmt.Println(bytes.Equal(a, c)) // false
    fmt.Println(bytes.Equal(nil, []byte{})) // true (nil и пустой считаются равными)
}