What is the difference between Go's struct embedding and composition for structs in Go?

Question

Jayant Kumar · Accepted Answer

Table of Contents
Introduction
In Go programming, both struct embedding and composition are used to create complex data structures by combining existing ones. While these terms are often used interchangeably, they refer to slightly different approaches. Struct embedding is a language feature that allows a struct to include another struct's fields and methods directly. Composition, on the other hand, is a broader design principle where multiple components are combined to build more complex functionality.
Differences Between Struct Embedding and Composition in Go
 Struct Embedding in Go
Struct embedding in Go allows a struct to include another struct directly as an anonymous field. This gives the outer struct direct access to the embedded struct's fields and methods, effectively promoting them to the outer struct's scope.

Example of Struct Embedding:
package main

import "fmt"

// Define a base struct
type Address struct {
    City, State string
}

// Define another struct that embeds Address
type Person struct {
    Name    string
    Age     int
    Address // Embedded struct
}

func main() {
    // Create an instance of Person
    p := Person{
        Name: "Alice",
        Age:  30,
        Address: Address{
            City:  "New York",
            State: "NY",
        },
    }

// Access fields of the embedded struct directly
    fmt.Printf("%s lives in %s, %s.
", p.Name, p.City, p.State)
}

In this example, the Person struct embeds the Address struct, allowing direct access to City and State fields as if they were part of Person.

Key Characteristics of Struct Embedding

Field Promotion: Fields and methods of the embedded struct are promoted to the outer struct, enabling direct access.
Code Reusability: Embedding allows the reuse of existing structs, promoting code reusability.
Simplifies Access: Direct access to embedded fields and methods simplifies code and reduces verbosity.

Composition in Go
Composition in Go refers to the design principle of building complex types by combining simpler ones. Unlike embedding, composition is not a specific language feature but rather a general practice. Composition involves creating a struct with one or more fields of other types, allowing the outer struct to use their functionalities by delegation.

Example of Composition:
package main

import "fmt"

// Define a base struct
type Engine struct {
    Horsepower int
}

// Define another struct that uses composition
type Car struct {
    Brand  string
    Engine Engine // Composed struct
}

func main() {
    // Create an instance of Car
    c := Car{
        Brand:  "Toyota",
        Engine: Engine{Horsepower: 150},
    }

// Access composed struct fields via the field name
    fmt.Printf("%s car has %d horsepower.
", c.Brand, c.Engine.Horsepower)
}

In this example, Car has an Engine field, but accessing it requires referencing the field name (Engine), unlike struct embedding.

Key Characteristics of Composition

Encapsulation: Fields and methods are encapsulated and are not promoted to the outer struct's scope.
Explicit Access: Access to the composed fields and methods requires explicit reference, maintaining clear boundaries between the components.
Flexible Design: Composition allows greater flexibility in structuring complex types by combining different components without tightly coupling them.

Key Differences: Struct Embedding vs. Composition
| Feature | Struct Embedding | Composition |
| --- | --- | --- |
| Definition | Embedding one struct inside another as an anonymous field | Combining multiple types to form a complex type |
| Field Promotion | Fields and methods of the embedded struct are promoted | Fields and methods are accessed explicitly |
| Access | Direct access without specifying embedded struct name | Requires explicit access using field names |
| Encapsulation | Reduces encapsulation; promotes fields/methods to the outer struct | Preserves encapsulation; keeps boundaries clear |
| Use Case | Suitable when you want direct access and tight coupling | Suitable when you want clear separation and flexibility |
| Example Usage | Embedding Address struct in Person struct | Composing Engine struct in Car struct |
Practical Examples of Struct Embedding and Composition
Example : Using Struct Embedding for Easy Access
package main

import "fmt"

// Define a base struct
type User struct {
    Username string
}

// Define another struct that embeds User
type Admin struct {
    User   // Embedding User struct
    Level  int
}

func main() {
    a := Admin{
        User:  User{Username: "john_doe"},
        Level: 1,
    }

fmt.Println("Admin Username:", a.Username) // Direct access
}

In this example, Admin embeds User, allowing direct access to the Username field.
Example : Using Composition for Better Encapsulation
package main

import "fmt"

// Define a struct representing a book
type Book struct {
    Title  string
    Author string
}

// Define a struct that uses composition to include a Book
type Library struct {
    Name string
    Book Book // Composition
}

func main() {
    l := Library{
        Name: "Central Library",
        Book: Book{Title: "Go Programming", Author: "Alice"},
    }

fmt.Printf("Library: %s, Book: %s by %s
", l.Name, l.Book.Title, l.Book.Author)
}

Here, Library uses composition to include a Book, maintaining clear boundaries and explicit access to the fields.
Conclusion
While both struct embedding and composition can be used to build complex types in Go, they serve different purposes. Struct embedding provides a way to promote fields and methods, simplifying access but reducing encapsulation. Composition, on the other hand, maintains clearer boundaries and encapsulation, allowing for more flexible and modular designs. Understanding the difference between these two approaches helps Go developers choose the most suitable method based on their specific requirements.

Feature	Struct Embedding	Composition
Definition	Embedding one struct inside another as an anonymous field	Combining multiple types to form a complex type
Field Promotion	Fields and methods of the embedded struct are promoted	Fields and methods are accessed explicitly
Access	Direct access without specifying embedded struct name	Requires explicit access using field names
Encapsulation	Reduces encapsulation; promotes fields/methods to the outer struct	Preserves encapsulation; keeps boundaries clear
Use Case	Suitable when you want direct access and tight coupling	Suitable when you want clear separation and flexibility
Example Usage	Embedding `Address` struct in `Person` struct	Composing `Engine` struct in `Car` struct

What is the difference between Go's struct embedding and composition for structs in Go?

Similar Questions