Struktura w języku Go to zdefiniowany przez użytkownika typ, który umożliwia utworzenie grupy elementów różnych typów w pojedynczej jednostce. Każdy byt świata rzeczywistego, który ma pewien zestaw właściwości lub pól, może być reprezentowany jako struktura.

Jak używać zagnieżdżonych struktur w Golang
Język Go pozwala na zagnieżdżanie struktur. Struktura będąca polem innej struktury nazywana jest strukturą zagnieżdżoną. Innymi słowy, strukturę wewnątrz innej struktury nazywamy strukturą zagnieżdżoną. Składnia:
type struct_name_1 struct{
// Các trường
}
type struct_name_2 struct{
variable_name struct_name_1
}
Aby zrozumieć zagnieżdżoną strukturę w języku Go, rozważ poniższy przykład:
Przykład 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)
}
Wynik:
Details of Author
{{Sona ECE 2013}}
Przykład 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)
}
Wynik:
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
Przykład 3:
W języku Go struktura może mieć pola, które same w sobie są strukturami, nazywanymi strukturami zagnieżdżonymi. Oto przykład struktury, która ma strukturę zagnieżdżoną:
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)
}
Wynik:
John Doe
Age: 30
Address:
Street: 123 Main St
City: Anytown
State: CA
Postal Code: 12345
Tutaj definiujemy dwa typy struktury: Osoba i Adres. Osoba ma zagnieżdżone pole struktury o nazwie Adres. W funkcji głównej tworzymy nową instancję Osoby z polem Adres. Następnie drukujemy różne wartości pól struktur Osoba i Adres, używając notacji kropkowej, aby uzyskać dostęp do zagnieżdżonych pól.