Notes d'apprentissage de golang - structure

Structure

GoLe langage n'a pas de concept purement orienté objet,C'est l'utilisation de structures、Fonctions, etc. pour implémenter.Quelques caractéristiques de la programmation d'objets faciaux,Par exemple：Succession、Caractéristiques combinées

Définition

SurtoutstructMots clés,La structure est la suivante:：

type struct_name struct{
	member defintion
}

type：Mot - clé de définition de la structure

struct_name：Nom du type de structure

struct：Mot - clé de définition de la structure

member definition：Définition des membres

Initialisation de la structure

Sans initialisation,Les membres sont tous nuls,int—>0,float—>0,bool—>false,string—>nil

type test struct {
    
   name bool
   id   float32
   sex  string
   age  int
}
var Sentiment test
fmt.Println(Sentiment)

Résultats：

{false 0  0}

Déclaration et affectation des membres de la structure

Affectation de l'opérateur de point

Demo01

package main

import "fmt"

func main() {
    
   type test struct {
    
      name string
      id   int
      sex  string
      age  int
   }
   var Sentiment test				//Déclaration
   Sentiment.id = 1					// Tout ce qui suit fait partie de l'affectation de l'opérateur de point 
   Sentiment.name = "Sentiment"
   Sentiment.sex = "man"
   Sentiment.age = 18
   fmt.Println(Sentiment)
}

Résultats:

{
    Sentiment 1 man 18}

Assigner des paires de clés

En plus de cela, vous pouvez assigner une valeur à une paire de clés

package main

import "fmt"

func main() {
    
   type test struct {
    
      name string
      id   int
      sex  string
      age  int
   }
   Sentiment := test{
    
      name: "Sentiment",
      id:   1,
      sex:  "man",
      age:  18,        //Note:： Il faut aussi ajouter une virgule à la fin 
   }

   fmt.Println(Sentiment)
}

Structure anonyme

Si la structure est utilisée temporairement , Peut - être sans nom ,Utilisation directe

demo02

package main

import "fmt"

func main() {
    
   var dog struct {
    
      id   int
      name string
   }
   dog.id = 1
   dog.name = "Tana"
   fmt.Println(dog)
}

Résultats：

{
    1 Tana}

Pointeur de structure

demo03

Le pointeur de structure est similaire au pointeur de variable normal

package main

import "fmt"

func main() {
    
   type Person struct {
    
      id   int
      name string
   }
   var Sentiment = Person{
    1, "Sentiment"}
   var p_person = &Sentiment
   fmt.Printf("Sentiment:%v\n", Sentiment)		//Structure de sortie
   fmt.Printf("p_person:%p\n", p_person)		//Adresse de la structure
   fmt.Printf("p_person:%v", p_person)			// Valeur correspondant à l'adresse de la structure 

}

Résultats：

Sentiment:{
    1 Sentiment}
p_person:0xc000004078
p_person:&{
    1 Sentiment}

newMot - clé créer un pointeur de structure

En plus de ce qui précède& En dehors de la création d'affectation ,Peut passernewMot - clé pour l'Instanciation de la structure,On obtient l'adresse de la structure.

package main

import "fmt"

func main() {
   type Person struct {
      id   int
      name string
   }
   var p_person = new(Person)

   fmt.Printf("p_person:%T\n", p_person)

}

Résultats：

p_person:*main.Person

Assignation des membres du pointeur de structure

Membre du pointeur de structure, Vous pouvez également utiliser l'opérateur point pour assigner des valeurs

package main

import "fmt"

func main() {
    
   type Person struct {
    
      id   int
      name string
   }
   var p_person = new(Person)
   p_person.id = 1
   p_person.name = "Sentiment"
   fmt.Printf("p_person:%v", p_person)

}

Résultats：

p_person:&{
    1 Sentiment}

Structure comme paramètre de fonction

Les structures peuvent aussi être comme des variables , Passer comme argument à une fonction ,Il y a deux façons：

• Structure de transfert direct ： Le contenu de la structure externe ne change pas à l'intérieur de la fonction ( La valeur de l'équivalent d'un appel à la structure elle - même ne change pas )
• Passer le pointeur de structure：À l'intérieur de la fonction, Capable de modifier le contenu des structures externes ( Parce que le pointeur est utilisé , Donc C'est l'opération sur l'adresse mémoire , Changement de structure )

Structure de transfert direct

Demo04

package main

import "fmt"

type Person struct {
    
   name string
   id   int
}

func show(person Person) {
    
   person.id = 1
   person.name = "Sentiment"
   fmt.Println(person)
}
func main() {
    
   person := Person{
    "Tana", 2}
   fmt.Printf("person: %v\n", person)			
   fmt.Println("-------------")
   show(person)								//Appelezshow Changement de valeur après la méthode 
   fmt.Println("-------------")
   fmt.Printf("person: %v", person)			// Mais il n'y a eu qu'un seul appel ,Produit à nouveaupersonValeur de,Toujours pareil.
}

Résultats：

person: {
    Tana 2}
-------------
{
    Sentiment 1}
-------------
person: {
    Tana 2}

Passer le pointeur de structure

package main

import "fmt"

type Person struct {
    
	name string
	id   int
}

//func show(person Person) {
    
// person.id = 1
// person.name = "Sentiment"
// fmt.Println(person)
//}
func show2(person *Person) {
    
	person.id = 3
	person.name = "Mumu"
	fmt.Println(person)
}
func main() {
    
	person := Person{
    "Tana", 2}
	fmt.Printf("person: %v\n", person)
	fmt.Println("-------------")
	show2(&person) 								//Appelezshow2Méthodes, Le paramètre obtenu est le type de pointeur 
	fmt.Println("-------------")
	fmt.Printf("person:%v", person) 		// Parce que c'est le type de pointeur , Adresse mémoire récupérée , Par conséquent, la valeur de la structure externe change également après l'appel 
}

Résultats：

person: {
    Tana 2}
-------------
&{
    Mumu 3}
-------------
person:{
    Mumu 3}

Nidification des structures

Supposons qu'une personne PersonStructure, Cet homme a toujours eu un animal de compagnie DogStructure

DogStructure

type Dog struct {
    
   name string
   age  int
}

Person1Structure

type Person1 struct {
    
	dog  Dog
	name string
	id   int
}

Demo05

package main

import "fmt"

type Dog struct {
    
   name string
   age  int
}
type Person1 struct {
    
   dog  Dog
   name string
   id   int
}

func main() {
    
   Sentiment := new(Person1)
   Sentiment.id = 1
   Sentiment.name = "Sentiment"
   Sentiment.dog.name = "Tana"
   Sentiment.dog.age = 3
   fmt.Println(Sentiment)
}

Résultats：

&{
    {
    Tana 3} Sentiment 1}