检查两个切片的相等性

您需要遍历切片中的每个元素并进行测试。未定义切片的相等性。但是，如果您要比较 .bytes.Equal[]byte

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

您应该使用 reflect。DeepEqual（） （）

DeepEqual 是 Go 的 == 运算符的递归松弛。

DeepEqual 报告 x 和 y 是否“深度相等”，定义为 遵循。如果 以下情况适用。不同类型的价值观从来都不是深刻的 平等。

当数组值的相应元素为 高度平等。

如果结构值的对应字段，则结构值深度相等，两者 出口和未出口，是高度平等的。

如果两者均为零，则函数值基本相等;否则他们不是 高度平等。

如果界面值具有深度相等的具体值，则它们非常相等 值。

如果映射值是相同的映射对象，或者如果它们 具有相同的长度及其对应的键（使用 Go 匹配 平等）映射到深度平等的价值观。

如果指针值相等，则使用 Go 的 == 运算符，或者如果它们指向深度相等的值。

当满足以下所有条件时，切片值基本相等：它们 既为 nil 或两者都为 non，它们的长度相同，并且 它们指向同一基础数组的相同初始条目 （即 &x[0] == &y[0]） 或其对应的元素（最多 长度）非常相等。请注意，非 nil 空切片和 nil slice（例如，[]byte{} 和 []byte（nil））并不相等。

其他值 - 数字、布尔值、字符串和通道 - 很深 如果使用 Go 的 == 运算符相等，则相等。

这只是使用 reflect 的示例。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 中试用

如果有两个，请使用字节比较它们。相等。Golang 文档说：[]byte

Equal 返回一个布尔值，报告 a 和 b 的长度是否相同，是否包含相同的字节。nil 参数等效于空切片。

用法：

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

如果你有兴趣写一个测试，那么 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

就目前而言，这是 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
}

想到了一个巧妙的技巧，我想我会分享。

如果您想知道两个切片是否相同（即它们别名相同的数据区域），而不仅仅是相等（一个切片的每个索引的值等于另一个切片的相同索引中的值），那么您可以通过以下方式有效地比较它们：

foo := []int{1,3,5,7,9,11,13,15,17,19}

// these two slices are exactly identical
subslice1 := foo[3:][:4]
subslice2 := foo[:7][3:]

slicesEqual := &subslice1[0]  == &subslice2[0]   && 
               len(subslice1) == len(subslice2)

这种比较有一些注意事项，特别是你不能以这种方式比较空切片，并且不比较切片的容量，所以这个“相同性”属性只有在从切片读取或切片一个严格较窄的子切片时才真正有用，因为任何增加切片的尝试都会受到切片容量的影响。尽管如此，能够有效地声明“这两个巨大的内存块实际上是同一个块，是或否”是还是非常有用的。

你不能将 或 与切片一起使用，但如果你可以将它们与元素一起使用，那么 Go 1.18 有一个新功能，可以轻松比较两个切片、切片。相等：==!=

Equal 报告两个切片是否相等：长度相同且所有元素相等。如果长度不同，则 Equal 返回 false。否则，将按递增索引顺序比较元素，并且比较在第一个不相等对处停止。浮点 NaN 不被认为是相等的。

包导入路径为 golang.org/x/exp/slices。包内的代码是实验性的，还不稳定。它最终将被移动到 Go 1.19 中的标准库中。slicesexp

不过，您可以在 Go 1.18（playground)

    sliceA := []int{1, 2}
    sliceB := []int{1, 2}
    equal := slices.Equal(sliceA, sliceB)
    fmt.Println(equal) // true

    type data struct {
        num   float64
        label string
    }

    sliceC := []data{{10.99, "toy"}, {500.49, "phone"}}
    sliceD := []data{{10.99, "toy"}, {200.0, "phone"}}
    equal = slices.Equal(sliceC, sliceD)
    fmt.Println(equal) // true

如果切片的元素不允许 和 ，则可以使用切片。EqualFunc 并定义对元素类型有意义的任何比较器函数。==!=

要获得一套完整的答案：这是一个泛型的解决方案。

func IsEqual[A comparable](a, b []A) bool {
    // Can't be equal if length differs
    if len(a) != len(b) {
        return false
    }

    // Empty arrays trivially equal
    if len(a) == 0 {
        return true
    }

    // Two pointers going towards each other at every iteration
    left := 0
    right := len(a) - 1

    for left <= right {
        if a[left] != b[left] || a[right] != b[right] {
            return false
        }

        left++
        right--
    }

    return true
}

代码使用“两个指针”的策略，这带来了运行时的复杂度，然而，这仍然比逐个线性检查少两倍。n / 2O(n)

更新：根据@doublethink13修复了相等检查错误

有函数断言。ElementsMatch（t， [1， 3， 2， 3]， [1， 3， 3， 2]） 用于检查切片。

感谢 Aaron 的评论，这并不明显，所以我添加突出显示此断言需要 lib “github.com/stretchr/testify/assert”

Go 语言为此提供了内置的支持实现。Golang 中的函数用于检查 x 和 y 是否“深度相等”。要访问此功能，需要在程序中导入 reflect 包。reflect.DeepEqual()

语法：func DeepEqual(x, y interface{}) bool

参数：此函数采用两个参数，其值为任意类型，即 x、y。

返回值：此函数返回布尔值。

例如： 如果要检查map_1和map_2是否相等

result := reflect.DeepEqual(map_1, map_2)

如果 map_1 和 map_2 相等，则 result 将为 true，如果 map_1 和 map_2 不相等，则 result 将为 false。

Golang 引入了一个包 Slices，其中包含各种功能，可用于任何类型的 Slices。我们可以使用 Equal 函数来报告两个切片是否相等。

https://cs.opensource.google/go/x/exp/+/06a737ee:slices/slices.go;l=22

// Equal reports whether two slices are equal: the same length and all
// elements equal. If the lengths are different, Equal returns false.
// Otherwise, the elements are compared in increasing index order, and the
// comparison stops at the first unequal pair.
// Floating point NaNs are not considered equal.
func Equal[E comparable](s1, s2 []E) bool {
    if len(s1) != len(s2) {
        return false
    }
    for i := range s1 {
        if s1[i] != s2[i] {
            return false
        }
    }
    return true
}

法典

package main

import (
    "fmt"

    "golang.org/x/exp/slices"
)

func main() {
    s1 := []int{1, 2}
    s2 := []int{1, 2}

    equal := slices.Equal(s1, s2)
    fmt.Println("Is Equal ? ", equal)
}

从 Go 1.21 开始，您可以使用标准库中的泛型函数：slices.Equal()

package main

import (
    "fmt"
    "slices"
)

func main() {
    s1 := []int{1, 4, 1, 4, 2, 1, 3, 5, 6, 2}
    s2 := []int{1, 4, 1, 4, 2, 1, 3, 5, 6, 2}

    fmt.Println(slices.Equal(s1, s2))

    s3 := []string{"foo", "bar"}
    s4 := []string{"foo", "baz"}

    fmt.Println(slices.Equal(s3, s4))
}

游乐场： https://go.dev/play/p/_WwU0BSwN2P