Проверка равенства двух срезов

Как я могу проверить, равны ли два среза?

Вам нужно перебрать каждый из элементов в срезе и протестировать. Равенство для ломтиков не определено. Однако есть bytes.Equalфункция, если вы сравниваете значения типа []byte.

func testEq(a, b []Type) bool {

    // If one is nil, the other must also be nil.
    if (a == nil) != (b == nil) { 
        return false; 
    }

    if len(a) != len(b) {
        return false
    }

    for i := range a {
        if a[i] != b[i] {
            return false
        }
    }

    return true
}

Вы должны использовать refle.DeepEqual ()

DeepEqual - это рекурсивная релаксация оператора Go's ==.

DeepEqual сообщает, являются ли x и y «глубоко равными», определяется следующим образом. Два значения одинакового типа глубоко равны, если применяется один из следующих случаев. Значения различных типов никогда не бывают глубоко равными.

Значения массива глубоко равны, когда их соответствующие элементы глубоко равны.

Значения структуры глубоко равны, если их соответствующие поля, как экспортированные, так и не экспортированные, глубоко совпадают.

Значения Func глубоко равны, если оба равны нулю; в противном случае они не глубоко равны.

Значения интерфейса глубоко равны, если они содержат глубоко равные конкретные значения.

Значения карты глубоко равны, если они являются одним и тем же объектом карты или имеют одинаковую длину, и их соответствующие ключи (соответствующие с помощью равенства Go) отображаются на глубоко равные значения.

Значения указателя глубоко равны, если они равны с помощью оператора Go's == или если они указывают на глубоко равные значения.

Значения среза глубоко равны, когда все из следующих условий являются истинными: они оба равны нулю или оба не равны нулю, имеют одинаковую длину и либо указывают на одну и ту же начальную запись одного и того же базового массива (то есть & x [0 ] == & y [0]) или соответствующие им элементы (вплоть до длины) глубоко равны. Обратите внимание, что ненулевой пустой слайс и нулевой слайс (например, [] byte {} и [] byte (nil)) не являются глубоко равными.

Другие значения - числа, числа, строки и каналы - очень равны, если они равны с помощью оператора Go ==.

Это всего лишь пример с использованием refle.DeepEqual (), который дан в ответе @ VictorDeryagin.

package main

import (
    "fmt"
    "reflect"
)

func main() {
    a := []int {4,5,6}
    b := []int {4,5,6}
    c := []int {4,5,6,7}

    fmt.Println(reflect.DeepEqual(a, b))
    fmt.Println(reflect.DeepEqual(a, c))

}

Результат:

true
false

Попробуйте в Go Playground

Если у вас есть два []byte, сравните их, используя bytes.Equal . Документация Голанга говорит:

Equal возвращает логическое сообщение о том, что a и b имеют одинаковую длину и содержат одинаковые байты. Нулевой аргумент эквивалентен пустому фрагменту.

Использование:

package main

import (
    "fmt"
    "bytes"
)

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

    fmt.Println(bytes.Equal(a, b))
    fmt.Println(bytes.Equal(a, c))
}

Это напечатает

true
false

А пока вот https://github.com/google/go-cmp, который

предназначен для того, чтобы быть более мощной и безопасной альтернативой reflect.DeepEqualдля сравнения того, являются ли два значения семантически равными.

package main

import (
    "fmt"

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

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

    fmt.Println(cmp.Equal(a, b)) // true
}

В случае, если вы заинтересованы в написании теста, то github.com/stretchr/testify/assertэто ваш друг.

Импортируйте библиотеку в самом начале файла:

import (
    "github.com/stretchr/testify/assert"
)

Затем внутри теста вы делаете:

func TestEquality_SomeSlice (t * testing.T) {
    a := []int{1, 2}
    b := []int{2, 1}
    assert.Equal(t, a, b)
}

Появится сообщение об ошибке:

                Diff:
                --- Expected
                +++ Actual
                @@ -1,4 +1,4 @@
                 ([]int) (len=2) {
                + (int) 1,
                  (int) 2,
                - (int) 2,
                  (int) 1,
Test:           TestEquality_SomeSlice