Creating Read-Only Structs Using Unexported Fields in Go

Introduction to Structs in Go

In Go, structs are versatile data structures used to group variables together. Structs allow you to model real-world entities clearly and efficiently. By default, when their fields are exported, structs allow read and write access to their data.

Creating a Basic Struct

Let’s start with a basic example of a struct:


package main

import "fmt"

// Defining a struct with exported fields
type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Alice", Age: 30}
    fmt.Println(p.Name, p.Age)  // Outputs: Alice 30
}

The fields in the Person struct (Name and Age) are accessible directly due to their capitalized names, making them exported fields.

Implementing Read-Only Structs

To create a read-only struct in Go, you can define unexported fields and provide only getter methods. This way, outside code cannot modify the values directly.


package main

import "fmt"

// Defining a struct with unexported fields
type person struct {
    name string
    age  int
}

// Getter method for the name field
func (p person) Name() string {
    return p.name
}

// Getter method for the age field
func (p person) Age() int {
    return p.age
}

func main() {
    p := person{name: "Bob", age: 25}
    fmt.Println(p.Name(), p.Age())  // Outputs: Bob 25
    // Uncommenting the next lines will result in compilation errors
    // p.name = "Charlie"
    // p.age = 26
}

In this example, fields name and age are unexported by making them lowercase. Getter methods provide read-only access.

Advanced Example with Additional Functionalities

You might wish to include logic within your methods that utilize unexported fields to maintain additional state or derived properties.


package main

import (
    "fmt"
    "time"
)

type account struct {
    owner    string
    balance  float64
    startDate time.Time
}

// NewAccount initializes a new account
func NewAccount(owner string, initialBalance float64) account {
    return account{owner: owner, balance: initialBalance, startDate: time.Now()}
}

// GetOwner returns the owner of the account
func (a account) GetOwner() string {
    return a.owner
}

// BalanceDetails provides access to account balance
func (a account) BalanceDetails() string {
    duration := time.Since(a.startDate).Hours() / 24
    return fmt.Sprintf("Owner: %s, Balance: %.2f, Opened %v days ago", a.owner, a.balance, int(duration))
}

func main() {
    acc := NewAccount("Charlie", 1000.0)
    fmt.Println(acc.BalanceDetails())  // Outputs: Details about the account
}

Here, an account struct manages an owner and balance, along with the account's open date. It uses methods to expose data, keeping internal fields secure from modification.

Conclusion

Using unexported fields in Go structs, coupled with getter methods, allows you to create robust APIs by exposing only the necessary parts of your data structures. This facilitates data encapsulation while creating safe, read-only views of complex data types.