Überprüfen der Gleichheit zweier Scheiben

Wie kann ich überprüfen, ob zwei Scheiben gleich sind?

Sie müssen jedes der Elemente im Slice durchlaufen und testen. Gleichheit für Slices ist nicht definiert. Es gibt jedoch eine bytes.EqualFunktion, wenn Sie Werte vom Typ vergleichen []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
}

Sie sollten Reflect.DeepEqual () verwenden.

DeepEqual ist eine rekursive Entspannung des Operators == von Go.

DeepEqual gibt an, ob x und y "zutiefst gleich" sind, wie folgt definiert. Zwei Werte identischen Typs sind zutiefst gleich, wenn einer der folgenden Fälle zutrifft. Werte unterschiedlicher Typen sind niemals zutiefst gleich.

Array-Werte sind tief gleich, wenn ihre entsprechenden Elemente tief gleich sind.

Strukturwerte sind zutiefst gleich, wenn die entsprechenden Felder, sowohl exportiert als auch nicht exportiert, sehr gleich sind.

Funktionswerte sind zutiefst gleich, wenn beide Null sind; sonst sind sie nicht zutiefst gleich.

Schnittstellenwerte sind zutiefst gleich, wenn sie zutiefst gleiche konkrete Werte enthalten.

Kartenwerte sind zutiefst gleich, wenn sie dasselbe Kartenobjekt sind oder wenn sie dieselbe Länge haben und ihre entsprechenden Schlüssel (mit Go-Gleichheit abgeglichen) sehr gleichen Werten zugeordnet sind.

Zeigerwerte sind zutiefst gleich, wenn sie mit dem Operator == von Go gleich sind oder wenn sie auf tief gleiche Werte verweisen.

Slice-Werte sind zutiefst gleich, wenn alle der folgenden Bedingungen erfüllt sind: Sie sind beide null oder beide nicht null, sie haben dieselbe Länge und entweder zeigen sie auf denselben Anfangseintrag desselben zugrunde liegenden Arrays (dh & x [0) ] == & y [0]) oder ihre entsprechenden Elemente (bis zur Länge) sind zutiefst gleich. Beachten Sie, dass ein nicht-Null-Leer-Slice und ein Null-Slice (z. B. [] Byte {} und [] Byte (Null)) nicht tief gleich sind.

Andere Werte - Zahlen, Bools, Strings und Kanäle - sind zutiefst gleich, wenn sie mit dem Operator == von Go gleich sind.

Dies ist nur ein Beispiel für die Verwendung von Reflect.DeepEqual () , das in der Antwort von @ VictorDeryagin angegeben ist.

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

}

Ergebnis:

true
false

Probieren Sie es auf dem Go Playground aus

Wenn Sie zwei haben []byte, vergleichen Sie sie mit bytes.Equal . Die Golang-Dokumentation sagt:

Equal gibt einen Booleschen Wert zurück, der angibt, ob a und b dieselbe Länge haben und dieselben Bytes enthalten. Ein Null-Argument entspricht einem leeren Slice.

Verwendungszweck:

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

Dies wird gedruckt

true
false

Und im Moment ist hier https://github.com/google/go-cmp welche

soll eine leistungsfähigere und sicherere Alternative zum reflect.DeepEqualVergleich sein, ob zwei Werte semantisch gleich sind.

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
}

Wenn Sie daran interessiert sind, einen Test zu schreiben, dann github.com/stretchr/testify/assertist Ihr Freund.

Importieren Sie die Bibliothek ganz am Anfang der Datei:

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

Dann machen Sie im Test:

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

Der angeforderte Fehler lautet:

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