Vérification de l'égalité de deux tranches

Comment puis-je vérifier si deux tranches sont égales?

Vous devez parcourir chacun des éléments de la tranche et tester. L'égalité pour les tranches n'est pas définie. Cependant, il existe une bytes.Equalfonction si vous comparez des valeurs de type []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
}

Vous devez utiliser reflect.DeepEqual ()

DeepEqual est une relaxation récursive de l'opérateur == de Go.

DeepEqual indique si x et y sont «profondément égaux», définis comme suit. Deux valeurs de type identique sont profondément égales si l'un des cas suivants s'applique. Les valeurs de types distincts ne sont jamais profondément égales.

Les valeurs de tableau sont profondément égales lorsque leurs éléments correspondants sont profondément égaux.

Les valeurs de structure sont profondément égales si leurs champs correspondants, à la fois exportés et non exportés, sont profondément égaux.

Les valeurs de Func sont profondément égales si les deux sont nulles; sinon, ils ne sont pas profondément égaux.

Les valeurs d'interface sont profondément égales si elles contiennent des valeurs concrètes profondément égales.

Les valeurs de carte sont profondément égales si elles sont le même objet de carte ou si elles ont la même longueur et leurs clés correspondantes (appariées en utilisant l'égalité Go) correspondent à des valeurs profondément égales.

Les valeurs du pointeur sont profondément égales si elles sont égales à l'aide de l'opérateur Go == ou si elles pointent vers des valeurs profondément égales.

Les valeurs de tranche sont profondément égales lorsque toutes les conditions suivantes sont vraies: elles sont toutes les deux nulles ou non nulles, elles ont la même longueur, et soit elles pointent vers la même entrée initiale du même tableau sous-jacent (c'est-à-dire, & x [0 ] == & y [0]) ou leurs éléments correspondants (jusqu'à la longueur) sont profondément égaux. Notez qu'une tranche vide non nulle et une tranche nulle (par exemple, [] octet {} et [] octet (nul)) ne sont pas profondément égales.

D'autres valeurs - nombres, bools, chaînes et canaux - sont profondément égales si elles sont égales en utilisant l'opérateur == de Go.

C'est juste un exemple en utilisant reflect.DeepEqual () qui est donné dans la réponse 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))

}

Résultat:

true
false

Essayez-le dans Go Playground

Si vous en avez deux []byte, comparez-les en utilisant bytes.Equal . La documentation de Golang dit:

Equal renvoie un booléen indiquant si a et b ont la même longueur et contiennent les mêmes octets. Un argument nil équivaut à une tranche vide.

Usage:

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

Cela imprimera

true
false

Et pour l'instant, voici https://github.com/google/go-cmp qui

est destiné à être une alternative plus puissante et plus sûre reflect.DeepEqualpour comparer si deux valeurs sont sémantiquement égales.

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
}

Dans le cas où vous êtes intéressé à écrire un test, alors github.com/stretchr/testify/assertc'est votre ami.

Importez la bibliothèque au tout début du fichier:

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

Ensuite, à l'intérieur du test, vous effectuez:

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

L'erreur demandée sera:

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