Déterminer si deux tranches sont égales dans Golang

                                                     

La colonne tutorielle suivante de golang vous présentera comment juger si deux tranches sont égales et si les tableaux sous la valeur sont égaux en golang, j'espère. cela sera utile aux amis qui en ont besoin !

En golang, nous pouvons facilement utiliser == pour déterminer si deux tableaux sont égaux, mais malheureusement, slice n'a pas d'opérateurs associés lorsque nous devons déterminer si deux tranches sont. égal, nous ne pouvons trouver qu'un autre raccourci.

Définition de l'égalité des tranches

Nous choisissons l'exigence la plus courante, c'est-à-dire lorsque le type et la longueur de deux tranches sont les mêmes, et les valeurs de les indices égaux sont également égaux, par exemple :

a := []int{1, 2, 3}b := []int{1, 2, 3}c := []int{1, 2}d := []int{1, 3, 2}

Dans le code ci-dessus, a et b sont égaux, c n'est pas égal car la longueur est différente de a et d c'est parce que l'ordre des éléments est différent de a Donc ils ne sont pas égaux non plus.

Déterminer si deux []octets sont égaux

Pourquoi devons-nous lister []octets séparément ?

Étant donné que la bibliothèque standard fournit un schéma de comparaison optimisé, nous n'avons plus besoin de réinventer la roue :

package mainimport (
    "bytes"
    "fmt")func main() {
    a := []byte{0, 1, 3, 2}
    b := []byte{0, 1, 3, 2}
    c := []byte{1, 1, 3, 2}

    fmt.Println(bytes.Equal(a, b))
    fmt.Println(bytes.Equal(a, c))}

Utilisez la réflexion pour déterminer si les tranches (tableaux) sont égales

Lors du jugement de tranches dont le type n'est pas []byte, nous pouvons également utiliser reflect.DeepEqual, qui est utilisé pour comparer en profondeur deux objets, y compris les éléments qu'ils contiennent, pour voir s'ils sont égaux :

func DeepEqual(x, y interface{}) bool

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 des tranches sont profondément égales lorsque toutes les conditions suivantes sont vraies : elles sont toutes deux nulles ou toutes deux non nulles, elles ont la même longueur, et soit elles pointent vers la même entrée initiale du même le 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, []byte{). } et []byte(nil)) ne sont pas profondément égaux.

La signification de ce passage n'est pas difficile à comprendre. C'est le même principe que la façon de déterminer l'égalité des tranches comme nous l'avons discuté au début. début de cet article, sauf qu'il utilise un peu de magie de "piratage" à l'exécution".

Regardez l'exemple :

package mainimport (
    "fmt"
    "reflect")func main() {
    a := []int{1, 2, 3, 4}
    b := []int{1, 3, 2, 4}
    c := []int{1, 2, 3, 4}
    fmt.Println(reflect.DeepEqual(a, b))
    fmt.Println(reflect.DeepEqual(a, c))}

Jugement d'écriture

L'utilisation de Reflect dans Golang nécessite généralement un coût de performance Si nous déterminons le type de tranche, alors il n'est absolument pas si difficile d'implémenter vous-même le jugement d'égalité des tranches :

func testEq(a, b []int) 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}

Code de test :

package main import "fmt" func main() {    a := []int{1, 2, 3, 4}    b := []int{1, 3, 2, 4}    c := []int{1, 2, 3, 4}    fmt.Println(testEq(a, b))    fmt.Println(testEq(a, c))}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!