Using Composition and Interfaces in Go for Clean Code Practices | CodeSignal Learn

Using Composition and Interfaces in Go for Clean Code Practices | CodeSignal Learn

Introduction

Welcome to another lesson of the Clean Code in Go course! In this course, we have explored foundational concepts like the Single Responsibility Principle, Encapsulation, and Struct Initialization, all essential for writing clear, maintainable, and efficient code. In this lesson, we'll focus on using composition wisely. By understanding the role of composition, struct embedding, and interfaces, we'll learn how to apply these effectively to enhance code readability and organization while maintaining the principles of clean code.

The Role of Composition, Embedding, and Interfaces in Writing Clean Code

In Go, composition is a powerful tool that allows for code reuse and logical organization without relying on traditional inheritance. Instead of creating a subclass from an existing class, you can create more complex types by embedding structs and using interfaces to define behaviors. Code Reuse and Flexibility : By embedding one struct within another, you can reuse code without duplicating it, making it easier to maintain and extend. Improved Readability with Structs and Interfaces : Composition through struct embedding makes it evident what each type does. For example, embedding a Person struct in an Employee struct clarifies that an Employee has all properties of a Person . Adherence to Previous Concepts : Similar to inheritance, composition in Go should align with the Single Responsibility Principle and Encapsulation . Each struct should serve a clear purpose and maintain data integrity.

Best Practices for Using Composition and Interfaces

To leverage composition and interfaces effectively, it's important to follow these best practices: Favor Composition Over Inheritance : Always consider using composition and struct embedding before attempting to mimic classical inheritance patterns, as they promote loose coupling. Utilize Interfaces for Behavior Definition : Define interfaces for behaviors that different structs should implement, ensuring a clear separation of concerns. Avoid Unnecessary Embedding : Avoid overly complex struct embedding that could lead to confusion and harder code maintenance. Pitfalls include forcing struct embedding to mimic "is-a" relationships or misusing interfaces without proper logical structuring.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Bad Example

Let’s explore a bad example to understand the misuse of embedding and interfaces in Go: package main import "fmt" type Person struct {Name string Age int} func (p Person) Work() {fmt.Println("Person working")} type Employee struct {Person EmployeeID string} type Manager struct {Employee} func main() {manager := Manager{Employee{Person{"Alice", 30}, "E123"}} manager.Work() fmt.Println(manager.Person.Name, "should also be managing")} In this example: The struct hierarchy is unnecessarily deep, with a Manager embedding Employee, which embeds Person . Person having a Work() method might be inappropriate because not every person works, making the base struct less general. The embedding might be forced where a Manager "is-a" Person, but the intermediary Employee struct may not be necessary.

Refactored Example

Now let's refactor the previous example to follow best practices in Go: package main import "fmt" type Person struct {Name string Age int} type Employee struct {Person Person EmployeeID string} func (e Employee) FileTaxes() {fmt.Println(e.Person.Name, "filing taxes")} type Manager struct {Employee} func (m Manager) HoldMeeting() {fmt.Println(m.Employee.Person.Name, "holding a meeting")} func main() {person := Person{"Alice", 30} employee := Employee{Person: person, EmployeeID: "E123"} manager := Manager{Employee: employee} manager.HoldMeeting()} In the refactored example: Person no longer has a Work() method, making it more general. Employee uses composition by having a Person field instead of embedding it. This simplifies the structure. Manager maintains a logical structure with reduced complexity by defining its own behavior.

Go

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func (p Person) Work() {
    fmt.Println("Person working")
}

type Employee struct {
    Person
    EmployeeID string
}

type Manager struct {
    Employee
}

func main() {
    manager := Manager{Employee{Person{"Alice", 30}, "E123"}}
    manager.Work()
    fmt.Println(manager.Person.Name, "should also be managing")
}

Go

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

type Employee struct {
    Person     Person
    EmployeeID string
}

func (e Employee) FileTaxes() {
    fmt.Println(e.Person.Name, "filing taxes")
}

type Manager struct {
    Employee
}

func (m Manager) HoldMeeting() {
    fmt.Println(m.Employee.Person.Name, "holding a meeting")
}

func main() {
    person := Person{"Alice", 30}
    employee := Employee{Person: person, EmployeeID: "E123"}
    manager := Manager{Employee: employee}
    manager.HoldMeeting()
}