Structs and Methods

Understanding Structs in Go

Memory Layout and Alignment

Structs in Go are composite types that group related data together. Understanding their memory layout is crucial for writing efficient code. Fields are laid out in memory in the order they're declared, with padding added for alignment based on the platform's word size.

// Memory layout demonstration
type Inefficient struct {
    a bool    // 1 byte + 7 bytes padding
    b int64   // 8 bytes
    c bool    // 1 byte + 7 bytes padding
    d int64   // 8 bytes
}  // Total: 32 bytes

type Efficient struct {
    b int64   // 8 bytes
    d int64   // 8 bytes
    a bool    // 1 byte
    c bool    // 1 byte + 6 bytes padding
}  // Total: 24 bytes

// Check struct size
fmt.Println(unsafe.Sizeof(Inefficient{}))  // 32
fmt.Println(unsafe.Sizeof(Efficient{}))    // 24

Struct Fundamentals

Declaration and Initialization

Go provides multiple ways to create and initialize structs. Understanding the differences between zero values, literals, and the new function helps you choose the right approach.

// Struct definition
type Person struct {
    Name    string
    Age     int
    Email   string
    Active  bool
}

// Various initialization methods
var p1 Person                            // Zero value
p2 := Person{}                            // Empty literal
p3 := Person{Name: "Alice", Age: 30}    // Named fields
p4 := Person{"Bob", 25, "bob@ex.com", true} // Positional (avoid)

// Using new (returns pointer)
p5 := new(Person)                        // *Person, zero-valued
p6 := &Person{Name: "Carol"}             // *Person, literal

// Anonymous structs
point := struct {
    X, Y float64
}{10.5, 20.3}

// Struct tags
type User struct {
    ID       int    `json:"id" db:"user_id"`
    Username string `json:"username" validate:"required,min=3"`
    Password string `json:"-" db:"password_hash"`
}

Struct Comparison and Assignment

Structs are comparable if all their fields are comparable. Assignment copies all fields, creating an independent copy (value semantics).

// Comparison
type Point struct { X, Y int }

p1 := Point{1, 2}
p2 := Point{1, 2}
p3 := Point{2, 1}

fmt.Println(p1 == p2)  // true
fmt.Println(p1 == p3)  // false

// Assignment creates a copy
p4 := p1
p4.X = 100
fmt.Println(p1.X)      // Still 1

// Non-comparable structs (contains slice)
type Data struct {
    Values []int
}
// d1 == d2  // Compile error!

Methods in Go

Defining Methods

Methods are functions with a special receiver argument. The receiver appears between the func keyword and the method name, binding the function to the type.

// Method with value receiver
type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// Method with pointer receiver
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

// Method on non-struct types
type Counter int

func (c *Counter) Increment() {
    *c++
}

func (c Counter) String() string {
    return fmt.Sprintf("Counter: %d", c)
}

Value vs Pointer Receivers

Choosing between value and pointer receivers is a critical design decision. Each has specific use cases and performance implications.

Struct Embedding and Composition

Embedding for Composition

Go doesn't have inheritance, but struct embedding provides a powerful composition mechanism. Embedded fields promote their methods to the outer struct, enabling code reuse.

// Base types
type Address struct {
    Street  string
    City    string
    Country string
}

func (a Address) FullAddress() string {
    return fmt.Sprintf("%s, %s, %s", a.Street, a.City, a.Country)
}

// Embedding
type Employee struct {
    Name    string
    ID      int
    Address // Embedded field
}

// Usage
emp := Employee{
    Name: "Alice",
    ID:   123,
    Address: Address{
        Street:  "123 Main St",
        City:    "Boston",
        Country: "USA",
    },
}

// Promoted fields and methods
fmt.Println(emp.City)          // Direct access to embedded field
fmt.Println(emp.FullAddress()) // Promoted method

// Method overriding
func (e Employee) String() string {
    return fmt.Sprintf("%s (#%d) at %s", e.Name, e.ID, e.FullAddress())
}

Multiple Embedding

Structs can embed multiple types, but field/method name conflicts must be resolved explicitly.

// Multiple embedding
type Reader struct {
    Name string
}

func (r Reader) Read() string {
    return "Reading..."
}

type Writer struct {
    Name string
}

func (w Writer) Write() string {
    return "Writing..."
}

type ReadWriter struct {
    Reader
    Writer
}

// Resolving conflicts
rw := ReadWriter{
    Reader: Reader{Name: "ReaderName"},
    Writer: Writer{Name: "WriterName"},
}

// Ambiguous: rw.Name (compile error)
fmt.Println(rw.Reader.Name)  // Explicit access
fmt.Println(rw.Writer.Name)
fmt.Println(rw.Read())      // Promoted method
fmt.Println(rw.Write())     // Promoted method

Advanced Patterns

Builder Pattern

The builder pattern is useful for constructing complex structs with many optional fields. It provides a fluent interface for step-by-step construction.

// Builder pattern implementation
type Server struct {
    Host     string
    Port     int
    Timeout  time.Duration
    MaxConns int
    TLS      bool
}

type ServerBuilder struct {
    server Server
}

func NewServerBuilder() *ServerBuilder {
    return &ServerBuilder{
        server: Server{
            Port:     8080,      // Default values
            Timeout:  30 * time.Second,
            MaxConns: 100,
        },
    }
}

func (b *ServerBuilder) WithHost(host string) *ServerBuilder {
    b.server.Host = host
    return b
}

func (b *ServerBuilder) WithPort(port int) *ServerBuilder {
    b.server.Port = port
    return b
}

func (b *ServerBuilder) WithTimeout(timeout time.Duration) *ServerBuilder {
    b.server.Timeout = timeout
    return b
}

func (b *ServerBuilder) WithTLS() *ServerBuilder {
    b.server.TLS = true
    return b
}

func (b *ServerBuilder) Build() (*Server, error) {
    if b.server.Host == "" {
        return nil, fmt.Errorf("host is required")
    }
    return &b.server, nil
}

// Usage
server, err := NewServerBuilder().
    WithHost("localhost").
    WithPort(9000).
    WithTimeout(60 * time.Second).
    WithTLS().
    Build()

Functional Options Pattern

Functional options provide a clean way to handle optional parameters and configuration. This pattern is widely used in Go libraries for API design.

// Functional options pattern
type Client struct {
    baseURL    string
    timeout    time.Duration
    maxRetries int
    apiKey     string
}

type ClientOption func(*Client)

func WithTimeout(d time.Duration) ClientOption {
    return func(c *Client) {
        c.timeout = d
    }
}

func WithMaxRetries(n int) ClientOption {
    return func(c *Client) {
        c.maxRetries = n
    }
}

func WithAPIKey(key string) ClientOption {
    return func(c *Client) {
        c.apiKey = key
    }
}

func NewClient(baseURL string, opts ...ClientOption) *Client {
    c := &Client{
        baseURL:    baseURL,
        timeout:    30 * time.Second,  // Defaults
        maxRetries: 3,
    }
    
    for _, opt := range opts {
        opt(c)
    }
    
    return c
}

// Usage
client := NewClient("https://api.example.com",
    WithTimeout(60*time.Second),
    WithMaxRetries(5),
    WithAPIKey("secret-key"),
)

Method Sets and Interfaces

Understanding Method Sets

The method set determines which methods are accessible and which interfaces a type implements. The rules differ for value and pointer types.

// Method sets demonstration
type Shape interface {
    Area() float64
    Scale(float64)
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func (c *Circle) Scale(factor float64) {
    c.Radius *= factor
}

// Interface satisfaction
var s Shape
c := Circle{Radius: 5}
// s = c     // Compile error! Circle doesn't implement Shape
s = &c       // OK: *Circle implements Shape

// But addressable values work
circles := []Circle{{1}, {2}, {3}}
circles[0].Scale(2)  // OK: circles[0] is addressable

Performance Considerations

Stack vs Heap Allocation

Understanding when structs are allocated on the stack versus the heap is crucial for performance. Escape analysis determines the allocation location.

// Stack allocation (no escape)
func stackAlloc() {
    p := Person{Name: "Alice", Age: 30}
    fmt.Println(p.Name)
    // p doesn't escape, allocated on stack
}

// Heap allocation (escapes)
func heapAlloc() *Person {
    p := &Person{Name: "Bob", Age: 25}
    return p  // p escapes, allocated on heap
}

// Check escape analysis
// go build -gcflags="-m" main.go

// Benchmark comparison
func BenchmarkStackStruct(b *testing.B) {
    for i := 0; i < b.N; i++ {
        p := Person{Name: "Test", Age: 20}
        _ = p
    }
}

func BenchmarkHeapStruct(b *testing.B) {
    for i := 0; i < b.N; i++ {
        p := new(Person)
        p.Name = "Test"
        p.Age = 20
        _ = p
    }
}

Best Practices

Common Pitfalls