Explication détaillée de la structure du langage Go et du graphique et du texte d'initialisation

Go prend en charge les types définis par l'utilisateur via des alias de type (types d'alias) et des structures.

Les structures sont des types composites. Lorsque vous devez définir un type composé d'une série d'attributs, chaque attribut a son propre type et sa propre valeur, vous devez utiliser une structure qui rassemble les données.

Les structures sont également des types de valeur, vous pouvez donc utiliser la nouvelle fonction pour créer

Les données qui composent le type de structure deviennent des champs. Chaque champ a un type et un nom ; au sein d'une structure, les noms de champs doivent être uniques.

1. Définition de la structure

La manière générale de définir une structure est la suivante :

type identifier struct {   
   field type1
    field type2}

type T struct { a, b int} est également une syntaxe légale. Elle est plus adaptée aux structures simples

Les champs de la structure ont des noms, tels que field1, field2, etc. Si les champs ne sont jamais utilisés dans le code, Ensuite, vous pouvez le nommer _.

La dénomination des types de structure et des champs suit des règles de visibilité, il est donc possible que certains champs d'un type de structure soient exportés et d'autres non.

Les champs d'une structure peuvent être de n'importe quel type, même la structure elle-même, ou il peut s'agir d'une fonction ou d'une interface. Vous pouvez déclarer une variable de type struct et attribuer des valeurs à ses champs comme ceci :

var s T
s.a = 5
s.b = 8

Un tableau peut également être considéré comme un type struct, mais il utilise des indices au lieu de champs nommés

Deuxièmement, l'initialisation

Méthode 1 : Déclarer la structure via var

En langage Go Lorsqu'une variable est déclarée , le système initialisera automatiquement sa valeur par défaut. Par exemple, int est initialisé à 0 et le pointeur est nul.
La déclaration var allouera également de la mémoire pour les données de type structure, nous pouvons donc directement attribuer des valeurs à ses champs après avoir déclaré var s T comme dans le code précédent

Méthode 2 : Utiliser new

Utilisez la nouvelle fonction pour allouer de la mémoire à une nouvelle variable de structure. Elle renvoie un pointeur vers la mémoire allouée : var t *T = new(T).

type struct1 struct {
    i1 int
    f1 float32
    str string}func main() {
    ms := new(struct1)
    ms.i1 = 10
    ms.f1 = 15.5
    ms.str= "Chris"

    fmt.Printf("The int is: %d\n", ms.i1)
    fmt.Printf("The float is: %f\n", ms.f1)
    fmt.Printf("The string is: %s\n", ms.str)
    fmt.Println(ms)
}

Semblable aux langages orientés objet, vous pouvez utiliser l'opérateur point pour attribuer une valeur à un champ : structname.fieldname = value.

De même, vous pouvez utiliser l'opérateur point pour obtenir la valeur du champ de structure : structname.fieldname.

Méthode 3 : Utiliser le littéral

type Person struct {
    name string
    age int
    address string
}

func main() {
    var p1 Person
    p1 = Person{"lisi", 30, "shanghai"}   //方式A
    p2 := Person{address:"beijing", age:25, name:"wangwu"} //方式B
    p3 := Person{address:"NewYork"} //方式C
}

Dans (Méthode A), les valeurs doivent être données dans l'ordre dans lequel les champs sont définis dans la structure. (Méthode B) ajoute le nom du champ et les deux points devant la valeur. Dans cette méthode, l'ordre des valeurs n'a pas besoin d'être cohérent et certains champs peuvent être ignorés, tout comme (Méthode C).

En plus des trois méthodes ci-dessus, il existe une manière plus courte et plus courante d'initialiser des entités de structure, comme suit :

ms := &Person{"name", 20, "bj"}
ms2 := &Person{name:"zhangsan"}

&Person{a, b, c} est une abréviation, The la couche inférieure appellera toujours new(), où l'ordre des valeurs doit être écrit dans l'ordre des champs. Il peut également être écrit en ajoutant le nom du champ et les deux points devant la valeur (voir méthodes B et C. au-dessus de).

Les expressions new(Type) et &Type{} sont équivalentes.

3. La différence entre plusieurs méthodes d'initialisation

Jusqu'à présent, nous avons appris trois façons d'initialiser une structure :

//第一种，在Go语言中，可以直接以 var 的方式声明结构体即可完成实例化
var t T
t.a = 1
t.b = 2

//第二种，使用 new() 实例化
t := new(T)

//第三种，使用字面量初始化
t := T{a, b}
t := &T{} //等效于 new(T)

L'utilisation de var t T allouera de la mémoire pour t et mettra la mémoire à zéro, mais le type de t à ce moment est T

Lors de l'utilisation du nouveau mot-clé t := new(T) , la variable t est un pointeur vers T

D'après la disposition de la mémoire, nous pouvons voir la différence entre ces trois méthodes d'initialisation :

Utiliser la déclaration var :

Utilisez new pour initialiser :

Utilisez la structure littérale pour initialiser :

Regardons un exemple spécifique :

package main
import "fmt"

type Person struct {
 name string
 age int
}

func main() {
 var p1 Person
 p1.name = "zhangsan"
 p1.age = 18
 fmt.Printf("This is %s, %d years old\n", p1.name, p1.age)

 p2 := new(Person)
 p2.name = "lisi"
 p2.age = 20
 (*p2).age = 23 //这种写法也是合法的
 fmt.Printf("This is %s, %d years old\n", p2.name, p2.age)

 p3 := Person{"wangwu", 25}
 fmt.Printf("This is %s, %d years old\n", p3.name, p3.age)
}

Sortie :

This is zhangsan, 18 years old
This is lisi, 23 years old
This is wangwu, 25 years old

Dans le deuxième cas de l'exemple ci-dessus, bien que p2 soit un type pointeur, on peut toujours aimer p2.age = 23 Pour l'affectation, il n'est pas nécessaire de utilisez l'opérateur -> comme en C++, Go le convertira automatiquement.

Notez que vous pouvez également utiliser l'opérateur * pour que le contenu pointe d'abord par le pointeur, puis l'attribuer : (*p2).age = 23.

Disposition de la mémoire de la structure

Go 语言中，结构体和它所包含的数据在内存中是以连续块的形式存在的，即使结构体中嵌套有其他的结构体，这在性能上带来了很大的优势。不像 Java 中的引用类型，一个对象和它里面包含的对象可能会在不同的内存空间中，这点和 Go 语言中的指针很像。

下面的例子清晰地说明了这些情况：

type Rect1 struct {Min, Max Point }
type Rect2 struct {Min, Max *Point }

更多go语言知识请关注PHP中文网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!