Golang Structs And Embedding Complete Guide

Step 1: Basic Structs

A struct in Go is a collection of fields. Each field has a name and a type.

Example: Define a basic struct:

package main

import "fmt"

// Define a struct named "Person"
type Person struct {
    FirstName string
    LastName  string
    Age       int
}

func main() {
    // Create and initialize a struct
    person := Person{
        FirstName: "John",
        LastName:  "Doe",
        Age:       30,
    }

    // Access struct fields
    fmt.Printf("Name: %s %s, Age: %d\n", person.FirstName, person.LastName, person.Age)
}

Output:

Name: John Doe, Age: 30

Explanation:

• We define a Person struct with three fields: FirstName, LastName, and Age.
• We create an instance of Person and initialize it.
• We access and print the fields of the Person struct.

Step 2: Nested Structs

A struct can also contain another struct as its field.

Example: Define a nested struct:

package main

import "fmt"

// Define a nested struct named "Address"
type Address struct {
    Street  string
    City    string
    ZipCode string
}

// Define a struct named "Employee" that includes an Address struct
type Employee struct {
    Person
    Address
    EmployeeID int
}

func main() {
    // Create and initialize a nested struct
    employee := Employee{
        Person: Person{
            FirstName: "Jane",
            LastName:  "Smith",
            Age:       28,
        },
        Address: Address{
            Street:  "123 Elm St",
            City:    "Metropolis",
            ZipCode: "12345",
        },
        EmployeeID: 101,
    }

    // Access struct fields
    fmt.Printf("Name: %s %s\n", employee.FirstName, employee.LastName)
    fmt.Printf("Address: %s, %s, %s\n", employee.Street, employee.City, employee.ZipCode)
    fmt.Printf("Employee ID: %d\n", employee.EmployeeID)
}

Output:

Name: Jane Smith
Address: 123 Elm St, Metropolis, 12345
Employee ID: 101

Explanation:

• We define an Address struct with fields Street, City, and ZipCode.
• We define an Employee struct that includes a Person struct and an Address struct.
• We create an instance of Employee and initialize it.
• We access and print the fields of the Employee struct, including nested ones.

Step 3: Struct Embedding

Struct embedding in Go allows a struct to directly include another struct's fields without explicitly naming them. This makes composition clean and efficient.

Example: Use struct embedding:

package main

import "fmt"

// Define a struct named "Address"
type Address struct {
    Street  string
    City    string
    ZipCode string
}

// Define a struct named "Employee" using struct embedding
type Employee struct {
    Person
    Address
    EmployeeID int
}

// Define a Person struct
type Person struct {
    FirstName string
    LastName  string
    Age       int
}

func main() {
    // Create and initialize an embedded struct
    employee := Employee{
        Person: Person{
            FirstName: "Alice",
            LastName:  "Johnson",
            Age:       27,
        },
        Address: Address{
            Street:  "456 Oak St",
            City:    "Springfield",
            ZipCode: "67890",
        },
        EmployeeID: 102,
    }

    // Access struct fields using field promotion (direct access to embedded fields)
    fmt.Printf("Name: %s %s\n", employee.FirstName, employee.LastName)
    fmt.Printf("Address: %s, %s, %s\n", employee.Street, employee.City, employee.ZipCode)
    fmt.Printf("Employee ID: %d\n", employee.EmployeeID)
}

Output:

Name: Alice Johnson
Address: 456 Oak St, Springfield, 67890
Employee ID: 102

Explanation:

• We define an Employee struct that embeds Person and Address.
• We create an instance of Employee and initialize it.
• We access the fields of the embedded structs directly, without using the struct name as a prefix (field promotion).

Step 4: Struct Embedding with Methods

When structs are embedded, methods associated with the embedded struct are available to the outer struct.

Example: Define methods for embedded structs:

package main

import (
    "fmt"
    "strings"
)

// Define a struct named "Address"
type Address struct {
    Street  string
    City    string
    ZipCode string
}

// Define a struct named "Employee" using struct embedding
type Employee struct {
    Person
    Address
    EmployeeID int
}

// Define a Person struct
type Person struct {
    FirstName string
    LastName  string
    Age       int
}

// Define a method for the Address struct
func (a Address) FullAddress() string {
    return fmt.Sprintf("%s, %s %s", a.Street, a.City, a.ZipCode)
}

// Define a method for the Person struct
func (p Person) FullName() string {
    return strings.Join([]string{p.FirstName, p.LastName}, " ")
}

func main() {
    // Create and initialize an embedded struct
    employee := Employee{
        Person: Person{
            FirstName: "Bob",
            LastName:  "Brown",
            Age:       25,
        },
        Address: Address{
            Street:  "789 Maple St",
            City:    "Riverside",
            ZipCode: "54321",
        },
        EmployeeID: 103,
    }

    // Access struct fields using field promotion and struct methods
    fmt.Printf("Name: %s\n", employee.FullName())
    fmt.Printf("Address: %s\n", employee.FullAddress())
    fmt.Printf("Employee ID: %d\n", employee.EmployeeID)
}

Output:

Name: Bob Brown
Address: 789 Maple St, Riverside 54321
Employee ID: 103

Explanation:

• We define methods FullName for Person and FullAddress for Address.
• We create an instance of Employee.
• We call the methods on the Employee instance, which has access to the methods of its embedded structs.

Conclusion