What is Nested Structure in Golang?

In this article, we will learn Nested Structure in Golang,This free Go Language tutorial for complete beginners will help you learn Go Language from scratch.

Nested Structure in Golang - ❤️Go Language Tutorials In 2024

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:

C

// 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:

C

// 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:

Go

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.