← Back to blog

Go: Understanding Constructor Functions

Exploring the idiomatic approach to object initialization in Go and understanding why we use constructor functions to create new struct instances.

Written by Denys Dovzhenko
#golang#learning#structs#backend

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.

Let’s start with the struct itself, since the constructor only makes sense in context of what it’s building:

type User struct {
  Name  string
  Email string
  Age   int
}

Here is an example constructor I’ve been working with:

func newUser(name, email string, age int) *User {
  return &User{
    Name:  name,
    Email: email,
    Age:   age,
  }
}

Notice it returns a pointer (*User), not a value. We want a reference to the struct, not a copy — that way changes made through the pointer are reflected in the original.

(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:

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


    return &User{
        Name:  name,
        Email: email,
        Age:   age,
    }, nil
}

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 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.