Go: Understanding Constructor Functions

As I continue my journey into Go, I’ve been exploring how the language handles object-oriented concepts. Coming from languages with traditional classes, one of the first things I noticed is that Go doesn’t have a built-in constructor keyword or a new Class() syntax.

Instead, Go relies on a simple, idiomatic pattern: Constructor Functions.

What is a Constructor Function?

A constructor function is just a regular Go function that creates and returns a new instance of a struct. By convention, if your struct is named User, the constructor function is typically named NewUser.

Here is an example I’ve been working with, along with a comment summarizing my understanding:

1
// A constructor function is a function that creates and returns a new instance of a struct.
2
// It is a common pattern in Go to use constructor functions to create new instances of structs,
3
// especially when the struct has many fields or when we want to enforce certain invariants.
4
// We use pointers here because we want to return a reference to the struct, rather than a copy of it.
5
// This allows us to modify the struct through the pointer and have those changes reflected in the original struct.
6
func newUser(name, email string, age int) *User {
7
  return &User{
8
    Name:  name,
9
    Email: email,
10
    Age:   age,
11
  }
12
}

(Note: If this function needs to be exported and usable by other packages, it should be capitalized as NewUser!)

Why Do We Use Them?

While you can always initialize a struct directly (e.g., user := User{Name: "Bob"}), constructor functions provide several critical benefits:

1. Enforcing Invariants

If a User must have a valid email and must be over 18, a constructor function gives us a place to validate this before the object is ever created. We can return an error if the invariants aren’t met:

1
func NewUser(name, email string, age int) (*User, error) {
2
    if age < 18 {
3
        return nil, errors.New("user must be at least 18")
4
    }
5

6
    return &User{
7
        Name:  name,
8
        Email: email,
9
        Age:   age,
10
    }, nil
11
}

2. Complex Initialization

Sometimes a struct needs more than just simple field assignment. It might need a database connection, an initialized map (e.g., make(map[string]int)), or background goroutines started. The constructor encapsulates all of this setup so the caller doesn’t have to worry about it.

3. Returning Pointers for State Mutation

As noted in my comment above, returning a pointer (*User) instead of a value (User) has two main benefits:

Efficiency: We avoid copying the entire struct when returning it.
Mutability: Any methods called on the returned pointer will modify the original struct. If the struct represents stateful data (like a repository or a database connection), we almost always want to pass it around by reference.

Conclusion

Go’s approach to constructors felt very manual at first, but I’ve come to appreciate its transparency. There is no hidden “magic” happening under the hood when you initialize an object—it’s just a function returning a struct pointer. It keeps the code readable, explicit, and distinctly Go.