Comprobando la igualdad de dos rebanadas

¿Cómo puedo verificar si dos rebanadas son iguales?

Debe recorrer cada uno de los elementos en el segmento y probar. La igualdad para los cortes no está definida. Sin embargo, hay una bytes.Equalfunción si está comparando valores de tipo []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
}

Debe usar reflect.DeepEqual ()

DeepEqual es una relajación recursiva del operador Go's ==.

DeepEqual informa si xey son "profundamente iguales", definidos de la siguiente manera. Dos valores de tipo idéntico son profundamente iguales si se aplica uno de los siguientes casos. Los valores de distintos tipos nunca son profundamente iguales.

Los valores de matriz son profundamente iguales cuando sus elementos correspondientes son profundamente iguales.

Los valores de estructura son profundamente iguales si sus campos correspondientes, tanto exportados como no exportados, son profundamente iguales.

Los valores de func son profundamente iguales si ambos son nulos; de lo contrario no son profundamente iguales.

Los valores de la interfaz son profundamente iguales si tienen valores concretos profundamente iguales.

Los valores del mapa son profundamente iguales si son el mismo objeto de mapa o si tienen la misma longitud y sus teclas correspondientes (emparejadas usando la igualdad Go) se asignan a valores profundamente iguales.

Los valores del puntero son profundamente iguales si son iguales usando el operador Go == o si apuntan a valores profundamente iguales.

Los valores de corte son profundamente iguales cuando se cumple todo lo siguiente: ambos son nulos o ambos no nulos, tienen la misma longitud y apuntan a la misma entrada inicial de la misma matriz subyacente (es decir, & x [0 ] == & y [0]) o sus elementos correspondientes (hasta la longitud) son profundamente iguales. Tenga en cuenta que un segmento vacío no nulo y un segmento nulo (por ejemplo, [] byte {} y [] byte (nil)) no son profundamente iguales.

Otros valores - números, bools, cadenas y canales - son profundamente iguales si son iguales usando el operador Go's ==.

Este es solo un ejemplo usando reflect.DeepEqual () que se da en la respuesta de @ 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))

}

Resultado:

true
false

Pruébalo en Go Playground

Si tiene dos []byte, compárelos con bytes . Igual . La documentación de Golang dice:

Igual devuelve un booleano que informa si a y b tienen la misma longitud y si contienen los mismos bytes. Un argumento nulo es equivalente a un segmento vacío.

Uso:

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))
}

Esto imprimirá

true
false

Y por ahora, aquí está https://github.com/google/go-cmp que

pretende ser una alternativa más poderosa y segura reflect.DeepEqualpara comparar si dos valores son semánticamente iguales.

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
}

En caso de que esté interesado en escribir una prueba, entonces github.com/stretchr/testify/assertes su amigo.

Importe la biblioteca al principio del archivo:

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

Luego dentro de la prueba que haces:

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

El error solicitado será:

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