Say Goodbye to Undefined Fields: A Practical Go Solution with omitzero

Frustrated with handling optional or nullable fields in Go? Struggling with omitempty and pointer workarounds? Discover a cleaner, more robust solution using Go 1.24's omitzero tag and a clever Undefined wrapper type. This approach simplifies marshaling, unmarshaling, and differentiating between zero, null, and absent values, leading to more maintainable and less error-prone code.

The Problem with omitempty: A Go Developer's Headache

Go's lack of a native "undefined" value has long plagued developers. The common workaround, using omitempty struct tags, often falls short. omitempty behavior is inconsistent across types. It treats zero-length slices/maps, nil pointers, and zero-valued primitives as "empty," but structs are never empty, leading to unexpected results.

Worse, when unmarshaling, omitempty offers no way to distinguish between a missing field and a field explicitly set to its zero value. This ambiguity makes handling optional and nullable data a complex, error-prone task.

Pointers to the Rescue? A Limited Workaround

Go developers often resort to using pointers with omitempty to represent optional fields. This allows you to omit nil pointer fields during marshaling and detect missing fields (as nil pointers) during unmarshaling.

However, this workaround fails when dealing with nullable values, where null is a valid, accepted value. Pointers with omitempty cannot differentiate between a truly absent field and a field explicitly set to null. Furthermore, excessive pointer usage introduces nil-checking overhead and code clutter, reducing readability and maintainability.

omitzero to the Rescue: Simpler, More Consistent Behavior

Go 1.24 introduced the omitzero tag, offering a more straightforward solution. omitzero omits fields with their zero value or, crucially, structs where all fields are zero-valued.

type MyStruct struct {
    SomeTime time.Time `json:",omitzero"`
}

No more default "0001-01-01T00:00:00Z" time.Time values cluttering your JSON! But what about handling nullable values or distinguishing between zero/null/absent values?

Introducing the Undefined Wrapper: The Complete Solution for Handling Optional and Nullable Fields in Go

Leveraging omitzero's consistent struct behavior, we can create a generic Undefined wrapper type to solve these remaining issues:

type Undefined[T any] struct {
    Val     T
    Present bool
}

The Undefined struct's Present field indicates whether a value was explicitly provided. Combine this with omitzero, and the magic happens!

UnmarshalJSON: Capturing Presence

During unmarshaling, the UnmarshalJSON method sets Present to true if the field exists in the JSON:

func (u *Undefined[T]) UnmarshalJSON(data []byte) error {
    if err := json.Unmarshal(data, &u.Val); err != nil {
        return fmt.Errorf("Undefined: couldn't unmarshal JSON: %w", err)
    }
    u.Present = true
    return nil
}

If the input lacks the field, UnmarshalJSON isn't called, and Present remains false.

MarshalJSON: Respecting Absence

The MarshalJSON method simply marshals the underlying value:

func (u Undefined[T]) MarshalJSON() ([]byte, error) {
    data, err := json.Marshal(u.Val)
    if err != nil {
        return nil, fmt.Errorf("Undefined: couldn't JSON marshal: %w", err)
    }
    return data, nil
}

The omitzero tag on the Undefined field ensures that the field is omitted if Present is false (meaning the struct is its zero value).

IsZero: Standard Library Harmony

The IsZero() method integrates with Go's standard JSON library, allowing omitzero to correctly identify zero values:

func (u Undefined[T]) IsZero() bool {
    return !u.Present
}

Practical Benefits: Simplified Marshaling and Unmarshaling of Nullable data in Go

This Undefined wrapper, combined with omitzero, provides a clean, unified mechanism for handling:

• Optional fields: Easily determine if a field was present in the input.
• Nullable values: Represent explicit null values distinctly from absent fields.
• Zero values: Differentiate between a field set to its zero value and a completely missing field.

Beyond JSON: Database Scanning

The same Undefined pattern can be extended to database scanning, enabling you to determine if a column was selected in a query!

Go Further with Goyave

This Undefined type is part of the Goyave framework, which offers a wealth of helpful tools and features for Go development. Explore Goyave to streamline your Go projects and write cleaner, more robust code. Start leveraging omitzero and the Undefined wrapper today for consistent handling of defined and undefined fields in Go!