Structure imbriquée dans Golang

Une structure ou struct dans Golang est un type défini par l'utilisateur qui nous permet de créer un groupe d'éléments de différents types en une seule unité. Toute entité du monde réel possédant un ensemble de propriétés ou de champs peut être représentée sous la forme d'une structure.

Comment utiliser les structures imbriquées dans Golang

Le langage Go permet des structures imbriquées. Une structure qui est un champ d’une autre structure est appelée une structure imbriquée. En d’autres termes, une structure à l’intérieur d’une autre structure est appelée structure imbriquée. Syntaxe:

type struct_name_1 struct{
  // Các trường
} 
type struct_name_2 struct{
  variable_name  struct_name_1

}

Considérez l’exemple suivant pour comprendre la structure imbriquée dans Golang :

Exemple 1 :

// Chương trình Go minh hoạc
// cấu trúc lồng nhau
package main

import "fmt"

// Tạo cấu trúc
type Author struct {
	name string
	branch string
	year int
}

// Tạo cấu trúc lòng nhau
type HR struct {

	// cấu trúc là một trường
	details Author
}

func main() {

	// Khởi tạo các trường
	// của cấu trúc
	result := HR{
	
		details: Author{"Sona", "ECE", 2013},
	}

	// Hiện giá trị
	fmt.Println("\nDetails of Author")
	fmt.Println(result)
}

Résultat:

Details of Author
{{Sona ECE 2013}}

Exemple 2 :

// Chương trình Golang minh họa
// cấu trúc lồng nhau
package main

import "fmt"

// Tạo cấu trúc
type Student struct {
	name string
	branch string
	year int
}

// Tạo cấu trúc lồng nhau
type Teacher struct {
	name string
	subject string
	exp	 int
	details Student
}

func main() {

	// Khởi tạo các trường
	// của cấu trúc
	result := Teacher{
		name: "Suman",
		subject: "Java",
		exp:	 5,
		details: Student{"Bongo", "CSE", 2},
	}

	// Hiện giá trị
	fmt.Println("Details of the Teacher")
	fmt.Println("Teacher's name: ", result.name)
	fmt.Println("Subject: ", result.subject)
	fmt.Println("Experience: ", result.exp)

	fmt.Println("\nDetails of Student")
	fmt.Println("Student's name: ", result.details.name)
	fmt.Println("Student's branch name: ", result.details.branch)
	fmt.Println("Year: ", result.details.year)
}

Résultat:

Details of the Teacher
Teacher's name:  Suman
Subject:  Java
Experience:  5

Details of Student
Student's name:  Bongo
Student's branch name:  CSE
Year:  2

Exemple 3 :

En Go, une structure peut avoir des champs qui sont eux-mêmes des structures, appelées structures imbriquées. Voici un exemple de structure qui possède une structure imbriquée :

package main

import (
	"fmt"
)

type Address struct {
	Street	 string
	City	 string
	State	 string
	PostalCode string
}

type Person struct {
	FirstName string
	LastName string
	Age	 int
	Address Address
}

func main() {
	p := Person{
		FirstName: "John",
		LastName: "Doe",
		Age:	 30,
		Address: Address{
			Street:	 "123 Main St",
			City:	 "Anytown",
			State:	 "CA",
			PostalCode: "12345",
		},
	}

	fmt.Println(p.FirstName, p.LastName)
	fmt.Println("Age:", p.Age)
	fmt.Println("Address:")
	fmt.Println("Street:", p.Address.Street)
	fmt.Println("City:", p.Address.City)
	fmt.Println("State:", p.Address.State)
	fmt.Println("Postal Code:", p.Address.PostalCode)
}

Résultat:

John Doe
Age: 30
Address:
Street: 123 Main St
City: Anytown
State: CA
Postal Code: 12345

Ici, nous définissons deux types de structures : Person et Address. La personne possède un champ de structure imbriqué appelé Adresse. Dans la fonction principale, nous créons une nouvelle instance Person avec un champ Address. Nous imprimons ensuite les différentes valeurs de champ des structures Person et Address en utilisant la notation par points pour accéder aux champs imbriqués.