Golang de base - Comparaison d'égalité

Cet article fait partie d'une série dans laquelle j'ai l'intention de partager les bases essentielles pour développer avec GoLang.

Les comparaisons logiques utilisant les opérateurs == ou != n'ont pas beaucoup de mystère. Ou votre code compare si les valeurs sont identiques ou différentes.
Mais il y a quelques détails importants à connaître sur ce que vous comparez.

Interface comparable

La première chose est de savoir ce qui peut être comparé avec ces opérateurs, l'endroit le plus évident pour le savoir est la documentation Go : section sur les comparateurs

Et une autre option consiste à examiner l'interface comparable, qui a été ajoutée avec l'implémentation des génériques de Go, tous les types qui implémentent cette interface sont comparables.

Donc, fondamentalement, tous les types primitifs définis par Go sont comparables, tels que : chaîne, nombres (int, float, complexe), bool.

Comparaison de types complexes

Certains types ont des conditions pour être comparables ou non. C'est le cas de : struct, slices et canaux.
Ils ne sont comparables que si leurs éléments sont également comparables.
Ce qui est intéressant, c'est que Go valide cela au niveau de la compilation, vous aidant ainsi à éviter les erreurs d'exécution, par exemple :

//Esse código compila e a comparação funciona:
func main() {
    test1 := struct {
        name       string
    }{}
    test2 := struct {
        name       string
    }{}
    if test1 == test2 {
        fmt.Println("Funciona")
    }
}

Dans le code ci-dessus, je crée deux structures avec des attributs équivalents et la comparaison fonctionne.

//Esse código não compila
func main() {
    test1 := struct {
        name       string
        attributes map[string]string
    }{}
    test2 := struct {
        name       string
        attributes map[string]string
    }{}
    if test1 == test2 {
        fmt.Println("Cade?")
    }
}

Ce code ne pourra pas être compilé avec l'erreur d'opération invalide.

Cela se produit parce que la carte n'est pas un type comparable dans Go.

Détails sur les structures et la carte

Il est très pratique de pouvoir comparer des structures avec ==, puisque ce sont les types avec lesquels nous personnalisons notre modélisation.
Mais même lorsque vous utilisez un type non comparable, il existe des moyens de simplifier le code, et savoir cela vous évitera d'écrire des conditions vraiment ennuyeuses.

Eh bien, imaginons que nous travaillons dans un système scolaire et que nous ayons la structure non comparable suivante :

type student struct {
    ID         int
    name       string
    age        int
    course     string
    attributes map[string]string
}

La bonne partie, cette structure a un champ ID, ce qui rend les choses beaucoup plus faciles si vous travaillez avec des données persistantes.

Imaginez maintenant si vous travaillez avec des données encore transitoires, par exemple si vous lisez un fichier et devez effectuer un certain type de traitement avant de conserver ces données.

Vous aurez toujours la possibilité de comparer champ par champ, ce n'est pas pratique du tout, mais ça marche. Mais vous pouvez utiliser la composition struct comme suit :

func main() {
    type identity struct {
        name   string
        age    int
        course string
    }
    type student struct {
        ID int
        identity
        attributes map[string]string
    }

    s1 := student{
        identity: identity{
            name:   "Chuck",
            age:    10,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "10",
        },
    }
    s2 := student{
        identity: identity{
            name:   "Chuck",
            age:    10,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "20",
        },
    }

    s3 := student{
        identity: identity{
            name:   "Chuck",
            age:    12,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "20",
        },
    }

    if s1.identity == s2.identity {
        fmt.Println("Achou", s1)
    }

    if s1.identity != s3.identity {
        fmt.Println("Não achou")
    }
}

L'alternative à ce code serait de créer des conditions comme celles-ci :

    if s1.name == s2.name && s1.age == s2.age && s1.course == s2.course {
        fmt.Println("Achou", s1)
    }

Vous pourriez l'extraire dans une fonction, pour le rendre moins déroutant, mais vous devrez quand même maintenir ces comparaisons.

Faites bon usage de la composition, cela peut grandement simplifier votre code !

Résumé

• Découvrez l'interface comparable
• Les types primitifs sont comparables
• Les types complexes peuvent ou non être comparables
• Utilisez la composition à votre avantage.

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!