web-dev-qa-db-fra.com

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

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

gogo-reflect
232
wei2912

Vous devez passer en boucle sur chacun des éléments de la tranche et tester. L'égalité pour les tranches n'est pas définie. Cependant, il existe une fonction bytes.Equal 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
}
136
Stephen Weinberg

Vous devriez utiliser reflect.DeepEqual ()

DeepEqual est un relâchement récursif 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, exportés et non exportés, sont profondément égaux.

Les valeurs Func sont profondément égales si les deux sont nuls; 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 (mises en correspondance avec l'égalité de Go) correspondent à des valeurs très égales.

Les valeurs de pointeur sont profondément égales si elles sont égales à l'aide de l'opérateur == de 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 nulles ou non-nulles, elles ont la même longueur et 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 non vide et une tranche nulle (par exemple, [] byte {} et [] byte (nil)) ne sont pas profondément égales.

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

236
Victor Deryagin

Ceci est juste un exemple d'utilisation de 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
35
Akavall

Si vous avez deux []byte, comparez-les en utilisant bytes.Equal . La documentation 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 nul é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 va imprimer

true
false
17
KeksArmee

Si vous êtes intéressé par un test, alors github.com/stretchr/testify/assert est votre ami.

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

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

Ensuite, dans le test que vous faites:


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
2
Gabriel Furstenheim

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

se veut une alternative plus puissante et plus sûre à reflect.DeepEqual pour 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
}
0
lk_vc