Nested Structure in Golang

Namachila October 8, 2025

0 2 2 minutes read

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.