Explication détaillée de la structure du langage Go

Définition : Il s'agit d'un type de données agrégé, qui est une entité agrégée à partir de zéro ou plusieurs valeurs de tout type.

Membres : Chaque valeur est appelée membre de la structure.

Exemple :

Utilisez un cas classique de structure pour traiter les informations sur les employés de l'entreprise. Chaque information sur les employés contient un numéro d'employé unique, le nom de l'employé, son adresse personnelle, sa date de naissance, son poste et son salaire. , un leadership supérieur, etc. Toutes ces informations doivent être liées à une entité, qui peut être copiée dans son ensemble, utilisée comme paramètre ou valeur de retour d'une fonction, ou stockée dans un tableau, etc.

Définir la structure :

type Employee struct {
    ID        int
    Name      string
    Address   string
    DoB       time.Time
    Position  string
    Salary    int
    ManagerID int
}

Définir les variables :

var dilbert Employee

Accéder aux membres :

dilbert.Salary -= 5000

Obtenir l'adresse du membre :

position := &dilbert.Position
*position = "Senior " + *position

Opérateur point et pointeur vers la structure :

var employeeOfTheMonth *Employee = &dilbert
employeeOfTheMonth.Position += " (proactive team player)"

Ordre de définition des membres :

Habituellement, une ligne correspond à un membre de la structure, et le nom du membre vient en premier et le type vient en dernier. Cependant, si les types de membres adjacents sont les mêmes, ils peuvent être fusionnés en une seule ligne, tout comme le Nom et. Adressez-vous aux membres ci-dessous

type Employee struct {
    ID            int
    Name, Address string
    DoB           time.Time
    Position      string
    Salary        int
    ManagerID     int
}

Règles de dénomination des membres :

Si le nom du membre de la structure commence par une lettre majuscule, alors le membre est exporté, cela est déterminé par le langage Go ; règles d'exportation. Une structure peut contenir des membres exportés et non exportés.

Signification de l'exportation : peut être lu et écrit dans d'autres packages.

Un type de structure nommé S ne contiendra plus de membres de type S : car la valeur d'un agrégat ne peut pas se contenir elle-même. (Cette restriction s'applique également aux tableaux.) Mais les structures de type S peuvent contenir des membres de type *S, ce qui nous permet de créer des structures de données récursives, telles que des listes chaînées et des arborescences.

type tree struct {
    value       int
    left, right *tree
}

Valeur de la structure :

peut spécifier la valeur de chaque membre.

type Point struct{ X, Y int }
p := Point{1, 2}

Ce qui précède est la première façon d'écrire, qui nécessite de spécifier une valeur nominale pour chaque membre de la structure dans l'ordre dans lequel les membres de la structure sont définis. Vous pouvez également :

anim := gif.GIF{LoopCount: nframes}

est initialisé avec les noms de membres et les valeurs correspondantes, qui peuvent inclure tout ou partie des membres dans cette forme d'écriture de la valeur nominale de la structure, si un membre est omis, il aura par défaut une valeur nulle. Puisque les noms des membres sont fournis, l’ordre dans lequel tous les membres apparaissent n’a pas d’importance.

Remarque : Deux formes d'écriture différentes ne peuvent pas être mélangées.

Intégration de la structure et membres anonymes :

type Point struct {
    X, Y int
}

type Circle struct {
    Center Point
    Radius int
}

type Wheel struct {
    Circle Circle
    Spokes int
}

Accédez à chaque membre :

var w Wheel
w.Circle.Center.X = 8
w.Circle.Center.Y = 8
w.Circle.Radius = 5
w.Spokes = 20

Simplifiez à nouveau la définition de la structure :

type Circle struct {
    Point
    Radius int
}

type Wheel struct {
    Circle
    Spokes int
}

Fier de la fonctionnalité d'intégration anonyme, nous peut accéder directement aux attributs de la feuille sans donner le chemin complet :

var w Wheel
w.X = 8            // equivalent to w.Circle.Point.X = 8
w.Y = 8            // equivalent to w.Circle.Point.Y = 8
w.Radius = 5       // equivalent to w.Circle.Radius = 5
w.Spokes = 20

Le littéral de structure doit suivre la structure lorsque le type de forme est déclaré, donc seules les deux syntaxes suivantes peuvent être utilisées, elles s'excluent mutuellement sont équivalentes :

w = Wheel{Circle{Point{8, 8}, 5}, 20}

w = Wheel{
    Circle: Circle{
        Point:  Point{X: 8, Y: 8},
        Radius: 5,
    },
    Spokes: 20, // NOTE: trailing comma necessary here (and at Radius)
}

Balise de structure :

Dans la déclaration de structure, la valeur nominale de la chaîne après les membres Year et Color est la balise membre de la structure

type Movie struct {
    Title  string
    Year   int  `json:"released"`
    Color  bool `json:"color,omitempty"`
    Actors []string
}

var movies = []Movie{
    {Title: "Casablanca", Year: 1942, Color: false,
        Actors: []string{"Humphrey Bogart", "Ingrid Bergman"}},
    {Title: "Cool Hand Luke", Year: 1967, Color: true,
        Actors: []string{"Paul Newman"}},
    {Title: "Bullitt", Year: 1968, Color: true,
        Actors: []string{"Steve McQueen", "Jacqueline Bisset"}},
    // ...
}

comme ceci La structure de données de JSON est particulièrement adapté au format JSON, et il est facile de convertir entre les deux. Le processus de conversion d'une tranche, une structure similaire aux films dans le langage Go, en JSON est appelé marshaling. Le marshaling se fait en appelant la fonction json.Marshal :

data, err := json.Marshal(movies)
if err != nil {
    log.Fatalf("JSON marshaling failed: %s", err)
}
fmt.Printf("%s\n", data)

La fonction Marshal renvoie une tranche d'octets codée contenant une longue chaîne sans indentation d'espaces ; nous l'enveloppons pour l'affichage :

[{"Title":"Casablanca","released":1942,"Actors":["Humphrey Bogart","Ingr
id Bergman"]},{"Title":"Cool Hand Luke","released":1967,"color":true,"Ac
tors":["Paul Newman"]},{"Title":"Bullitt","released":1968,"color":true,"
Actors":["Steve McQueen","Jacqueline Bisset"]}]

Parmi eux, le membre Year a été codé et a été libéré, et le membre Color a été codé et est devenu une couleur commençant par une lettre minuscule. Ceci est dû au membre de conformation Tag. Un Tag membre de structure est une chaîne de méta-informations associée au membre lors de la phase de compilation :

Year  int  `json:"released"`
Color bool `json:"color,omitempty"`

Le Tag membre d'une structure peut être n'importe quelle chaîne littérale, mais il s'agit généralement d'une série de clés séparées par des espaces. :"valeur" séquence de paires clé-valeur ; étant donné que la valeur contient des guillemets doubles, les balises membres sont généralement écrites sous la forme de chaînes littérales natives.

Pour plus de connaissances sur le langage go, veuillez faire attention à la colonne tutoriel sur le langage go.

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!