A structure or struct in Golang is a user-defined type, which allows us to create a group of elements of different types into a single unit. Any real-world entity which has some set of properties or fields can be represented as a struct. Go language allows nested structure. A structure which is the field of another structure is known as Nested Structure. Or in other words, a structure within another structure is known as a Nested Structure. Syntax:
type struct_name_1 struct{ // Fields } type struct_name_2 struct{ variable_name struct_name_1 }
Let us discuss this concept with the help of the examples:
Example 1:
// Golang program to illustrate // the nested structure package main import "fmt" // Creating structure type Author struct {
name string
branch string
year int
} // Creating nested structure type HR struct {
// structure as a field
details Author
} func main() { // Initializing the fields
// of the structure
result := HR{
details: Author{"Sona", "ECE", 2013},
}
// Display the values
fmt.Println("\nDetails of Author")
fmt.Println(result)
} |
Output:
Details of Author {{Sona ECE 2013}}
Example 2:
// Golang program to illustrate // the nested structure package main import "fmt" // Creating structure type Student struct {
name string
branch string
year int
} // Creating nested structure type Teacher struct {
name string
subject string
exp int
details Student
} func main() { // Initializing the fields
// of the structure
result := Teacher{
name: "Suman",
subject: "Java",
exp : 5,
details: Student{"Bongo", "CSE", 2},
}
// Display the values
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)
} |
Output:
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
Example 3:
In Go, a structure can have fields that are themselves structures, which are called nested structures. Here is an example of a struct that has a nested struct:
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)
} |
Output:
John Doe
Age: 30
Address:
Street: 123 Main St
City: Anytown
State: CA
Postal Code: 12345
Here, we define two struct types: Person and Address. Person has a nested struct field Address. In the main function, we create a new Person instance with an Address field. Then, we print out the values of various fields of the Person and Address structs using dot notation to access the nested fields.