Verificando a igualdade de duas fatias

Como posso verificar se duas fatias são iguais?

Você precisa fazer um loop sobre cada um dos elementos na fatia e testar. A igualdade para fatias não está definida. No entanto, existe uma bytes.Equalfunção se você estiver comparando valores do 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
}

Você deve usar reflect.DeepEqual ()

DeepEqual é um relaxamento recursivo do operador Go ==.

O DeepEqual relata se xey são "profundamente iguais", definidos da seguinte maneira. Dois valores do tipo idêntico são profundamente iguais se um dos seguintes casos se aplicar. Valores de tipos distintos nunca são profundamente iguais.

Os valores da matriz são profundamente iguais quando seus elementos correspondentes são profundamente iguais.

Os valores de estrutura são profundamente iguais se seus campos correspondentes, exportados e não exportados, forem profundamente iguais.

Os valores de função são profundamente iguais se ambos forem nulos; caso contrário, eles não são profundamente iguais.

Os valores da interface são profundamente iguais se mantiverem valores concretos profundamente iguais.

Os valores do mapa são profundamente iguais se tiverem o mesmo objeto de mapa ou se tiverem o mesmo comprimento e suas chaves correspondentes (correspondidas usando a igualdade Go) são mapeadas para valores profundamente iguais.

Os valores do ponteiro são profundamente iguais se forem iguais usando o operador Go's == ou se apontarem para valores profundamente iguais.

Os valores das fatias são profundamente iguais quando tudo o que se segue é verdadeiro: ambos são nulos ou não são nulos, têm o mesmo comprimento e apontam para a mesma entrada inicial da mesma matriz subjacente (ou seja, x [0 ] == & y [0]) ou seus elementos correspondentes (até o comprimento) são profundamente iguais. Observe que uma fatia vazia não nula e uma fatia nula (por exemplo, [] byte {} e [] byte (nil)) não são profundamente iguais.

Outros valores - números, bools, strings e canais - são profundamente iguais se forem iguais usando o operador Go's ==.

Este é apenas um exemplo usando reflect.DeepEqual () que é dado na resposta 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

Experimente no Go Playground

Se você tiver dois []byte, compare-os usando bytes.Equal . A documentação de Golang diz:

Igual retorna um valor booleano que informa se aeb têm o mesmo comprimento e contêm os mesmos bytes. Um argumento nulo é equivalente a uma fatia vazia.

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

Isso imprimirá

true
false

E, por enquanto, aqui está https://github.com/google/go-cmp, que

pretende ser uma alternativa mais poderosa e segura reflect.DeepEqualpara comparar se dois valores são semanticamente iguais.

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
}

Caso você esteja interessado em escrever um teste, então github.com/stretchr/testify/asserté seu amigo.

Importe a biblioteca no início do arquivo:

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

Então, dentro do teste, você faz:

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

O erro solicitado será:

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