English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutoriel de base en Golang

Instructions de contrôle en Golang

Fonction et méthode en Golang

Structure en Golang

Slice et tableau en Golang

Chaîne (String) en Golang

Pointeur en Golang

Interface en Golang

Concurrence en Golang

Erreurs Go (Golang 异常(Error))

Autres détails Go

Comparaison de structure Go

Dans Go, une structure ou struct est un type utilisateur défini, qui nous permet de créer un ensemble d'éléments de différents types dans un même bloc. Toute entité réelle possédant un ensemble d'attributs ou de champs peut être représentée par une structure. Ce concept est souvent comparé à la classe en programmation orientée objet. Elle peut être appelée une classe légère, qui ne supporte pas l'héritage, mais la composition.

En langage Go, on peut utiliserl'opérateur ==oula méthode DeeplyEqual()comparer deux structures du même type et contenant les mêmes valeurs de champs. Si les structures sont égales les unes aux autres (par rapport à leurs valeurs de champs), les opérateurs et les méthodes renvoient tous deux true ; sinon, ils renvoient false. De plus, si les variables comparées appartiennent à des structures différentes, le compilateur génère une erreur. Laissez-nous discuter de ce concept à l'aide d'exemples :

Remarque : la méthode DeeplyEqual() est définie dans le paquet "reflect".

comparer les structures avec l'opérateur ==

//conception de l'égalité des structures
//vérifier l'égalité des structures avec l'opérateur ==
package main
import "fmt"
//créer une structure
type Author struct {
    name      string
    branch    string
    language  string
    Particles int
}
func main() {
    //créer des variables
    //structure de l'auteur
    a1 := Auteur{
        name:      "Moana",
        branch:    "CSE",
        language:  "Python",
        Particles : 38,
    }
    a2 := Auteur{
        name:      "Moana",
        branch:    "CSE",
        language:  "Python",
        Particles : 38,
    }
    a3 := Auteur{
        name:      "Dona",
        branch:    "CSE",
        language:  "Python",
        Particles : 38,
    }
    //vérifier a avec l'opérateur ==1et a2est égal
    if a1 == a2 {
        fmt.Println("variable a1égal à la variable a2)
    } else {
        fmt.Println("variable a1inégal à la variable a2)
    }
    if a2 == a3 {
        fmt.Println("variable a2égal à la variable a3)
    } else {
        fmt.Println("variable a2inégal à la variable a3)
    }
}

Sortie :

variable a1égal à la variable a2
variable a2inégal à la variable a3

comparer les structures avec la méthode DeepEqual()

//utiliser la méthode DeepEqual()
package main
import (
    "fmt"
    "reflect"
)
//créer une structure
type Author struct {
    name      string
    branch    string
    language  string
    Particles int
}
func main() {
    //définir des variables
    //structure de l'auteur
    a1 := Auteur{
        name:      "Soana",
        branch:    "CSE",
        language:  "Perl",
        Particles : 48,
    }
    a2 := Auteur{
        name:      "Soana",
        branch:    "CSE",
        language:  "Perl",
        Particles : 48,
    }
    a3 := Auteur{
        name:      "Dia",
        branch:    "CSE",
        language:  "Perl",
        Particles : 48,
    }
    //comparer a1et a2, utiliser la méthode DeepEqual()
    fmt.Println("a1Égal à a2Oui: ", reflect.DeepEqual(a1, a2))
    //comparer a2et a3, utiliser la méthode DeepEqual()
    fmt.Println("a2Égal à a3Oui: ", reflect.DeepEqual(a2, a3))
}

Sortie :

a1Égal à a2Oui:  true
a2Égal à a3Est-ce que:  false