Sprawdzanie równości dwóch plasterków

Jak mogę sprawdzić, czy dwa plasterki są równe?

Musisz zapętlić każdy element w plasterku i przetestować. Równość plasterków nie jest zdefiniowana. Istnieje jednak bytes.Equalfunkcja, jeśli porównujesz wartości typu []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
}

Powinieneś użyć reflect.DeepEqual ()

DeepEqual to rekurencyjna relaksacja operatora Go = =.

DeepEqual informuje, czy xiy są „głęboko równe”, zdefiniowane w następujący sposób. Dwie wartości tego samego typu są głęboko równe, jeśli ma zastosowanie jeden z następujących przypadków. Wartości różnych typów nigdy nie są głęboko równe.

Wartości tablic są głęboko równe, gdy odpowiadające im elementy są głęboko równe.

Wartości struktur są głęboko równe, jeśli odpowiadające im pola, zarówno eksportowane, jak i nie eksportowane, są głęboko równe.

Wartości Func są głęboko równe, jeśli oba są równe zero; w przeciwnym razie nie są głęboko równi.

Wartości interfejsów są głęboko równe, jeśli zawierają głęboko równe konkretne wartości.

Wartości map są głęboko równe, jeśli są tym samym obiektem mapy lub mają taką samą długość, a odpowiadające im klucze (dopasowane przy użyciu Go równości) mapują na głęboko równe wartości.

Wartości wskaźnika są głęboko równe, jeśli są równe za pomocą operatora Go == lub jeśli wskazują na głęboko równe wartości.

Wartości wycinków są głęboko równe, gdy spełnione są wszystkie poniższe warunki: oba są zerowe lub oba nie-zerowe, mają tę samą długość i albo wskazują na ten sam początkowy wpis tej samej podstawowej tablicy (to jest, & x [0 ] == i y [0]) lub odpowiadające im elementy (do długości) są głęboko równe. Zauważ, że pusty pusty plasterek i zerowy plasterek (na przykład [] bajt {} i [] bajt (zero)) nie są głęboko równe.

Inne wartości - liczby, boole, ciągi i kanały - są głęboko równe, jeśli są równe za pomocą operatora Go = =.

To tylko przykład użycia reflect.DeepEqual () podanego w odpowiedzi @ 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))

}

Wynik:

true
false

Wypróbuj Go Playground

Jeśli masz dwa []byte, porównaj je za pomocą bytes.Equal . Dokumentacja Golanga mówi:

Równe zwraca wartość logiczną raportującą, czy aib mają tę samą długość i zawierają te same bajty. Argument zerowy jest równoważny pustemu wycinkowi.

Stosowanie:

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

To zostanie wydrukowane

true
false

A na razie tutaj jest https://github.com/google/go-cmp które

ma być silniejszą i bezpieczniejszą alternatywą do reflect.DeepEqualporównywania, czy dwie wartości są semantycznie równe.

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
}

Jeśli jesteś zainteresowany pisaniem testu, to github.com/stretchr/testify/assertjest twój przyjaciel.

Zaimportuj bibliotekę na samym początku pliku:

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

Następnie w ramach testu wykonujesz:

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

Zgłoszony błąd to:

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