Verschachtelte Struktur in Golang

Eine Struktur oder ein Struct in Golang ist ein benutzerdefinierter Typ, der es uns ermöglicht, eine Gruppe von Elementen unterschiedlichen Typs zu einer einzigen Einheit zusammenzufassen. Jede reale Entität mit bestimmten Eigenschaften oder Feldern kann als Struct dargestellt werden.

So verwenden Sie verschachtelte Strukturen in Golang

Die Sprache Go erlaubt verschachtelte Strukturen. Eine Struktur, die ein Feld einer anderen Struktur ist, wird als verschachtelte Struktur bezeichnet. Anders ausgedrückt: Eine Struktur innerhalb einer anderen Struktur wird als verschachtelte Struktur bezeichnet. Syntax:

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

}

Betrachten Sie das folgende Beispiel, um die verschachtelte Struktur in Golang zu verstehen:

Beispiel 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)
}

Ergebnis:

Details of Author
{{Sona ECE 2013}}

Beispiel 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)
}

Ergebnis:

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

Beispiel 3:

In Go kann eine Struktur Felder enthalten, die selbst Strukturen sind, sogenannte verschachtelte Strukturen. Hier ist ein Beispiel für eine Struktur mit einer verschachtelten Struktur:

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)
}

Ergebnis:

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

Hier definieren wir zwei Strukturtypen: Person und Adresse. Person hat ein verschachteltes Strukturfeld namens Adresse. In der Hauptfunktion erstellen wir eine neue Instanz von Person mit einem Adressfeld. Anschließend drucken wir die Werte verschiedener Felder der Strukturen Person und Adresse mithilfe der Punktnotation, um auf die verschachtelten Felder zuzugreifen.