Verifica dell'uguaglianza di due sezioni

Come posso verificare se due sezioni sono uguali?

È necessario eseguire il ciclo su ciascuno degli elementi nella sezione e testare. L'uguaglianza per le sezioni non è definita. Tuttavia, esiste una bytes.Equalfunzione se si confrontano valori di 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
}

È necessario utilizzare reflection.DeepEqual ()

DeepEqual è un rilassamento ricorsivo dell'operatore == di Go.

DeepEqual riporta se xey sono "profondamente uguali", definito come segue. Due valori di tipo identico sono profondamente uguali se si applica uno dei seguenti casi. I valori di tipi distinti non sono mai profondamente uguali.

I valori di matrice sono profondamente uguali quando i loro elementi corrispondenti sono profondamente uguali.

I valori di Struct sono profondamente uguali se i loro campi corrispondenti, sia esportati che non esportati, sono profondamente uguali.

I valori di Func sono profondamente uguali se entrambi sono nulli; altrimenti non sono profondamente uguali.

I valori dell'interfaccia sono profondamente uguali se contengono valori concreti profondamente uguali.

I valori della mappa sono profondamente uguali se sono lo stesso oggetto mappa o se hanno la stessa lunghezza e le loro chiavi corrispondenti (abbinate usando Go uguaglianza) mappano a valori profondamente uguali.

I valori del puntatore sono profondamente uguali se sono uguali usando l'operatore Go == o se indicano valori profondamente uguali.

I valori di sezione sono profondamente uguali quando sono vere tutte le seguenti condizioni: sono entrambe nulle o entrambe non nulle, hanno la stessa lunghezza e indicano entrambe la stessa voce iniziale dello stesso array sottostante (ovvero & x [0 ] == & y [0]) o i loro elementi corrispondenti (fino alla lunghezza) sono profondamente uguali. Si noti che una sezione vuota non nulla e una sezione zero (ad esempio, [] byte {} e [] byte (zero)) non sono profondamente uguali.

Altri valori - numeri, bool, stringhe e canali - sono profondamente uguali se sono uguali usando l'operatore Go ==.

Questo è solo un esempio dell'utilizzo di reflection.DeepEqual () riportato nella risposta di @ 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))

}

Risultato:

true
false

Provalo in Go Playground

Se ne hai due []byte, confrontali usando bytes.Equal . La documentazione di Golang dice:

Uguale restituisce un valore booleano che indica se aeb hanno la stessa lunghezza e contengono gli stessi byte. Un argomento nullo equivale a una sezione vuota.

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

Questo stamperà

true
false

E per ora, ecco https://github.com/google/go-cmp che

intende essere un'alternativa più potente e più sicura reflect.DeepEqualper confrontare se due valori sono semanticamente uguali.

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
}

Nel caso in cui tu sia interessato a scrivere un test, allora github.com/stretchr/testify/assertè tuo amico.

Importa la libreria all'inizio del file:

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

Quindi all'interno del test fai:

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

L'errore richiesto sarà:

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