What Does Omitempty Do In Golang

Go Programming

In Go programming language, the omitempty tag is a very handy feature that allows us to control the behavior of struct fields when they are being encoded or decoded into JSON. It gives us the ability to omit empty or zero values from the resulting JSON output. This can be quite useful in reducing the size of the JSON payload and making it more concise.

Personally, I find the omitempty tag to be a powerful tool in my Go programming arsenal. It not only helps in optimizing the size of JSON data but also improves the readability and clarity of the code. Let’s dive deep into the details and explore how the omitempty tag works in Go.

Understanding the Basics

Before we delve into the specifics of omitempty, let’s understand how Go encodes and decodes structs into JSON. When we use the json.Marshal function to convert a struct into JSON, Go examines each field in the struct and generates the corresponding JSON key-value pairs.

By default, all fields in the struct will be included in the JSON output, even if they have zero or empty values. However, when we specify the omitempty tag on a struct field, Go will skip that field if it has a zero or empty value during the encoding process.

For example, consider the following struct:

type Person struct {
Name string `json:"name"`
Age int `json:"age,omitempty"`
Address string `json:"address,omitempty"`

In this case, if the Age field and Address field have zero or empty values, they will be omitted from the resulting JSON. However, if they have non-zero or non-empty values, they will be included in the JSON output.

Use Cases and Benefits

The omitempty tag can be particularly useful in scenarios where we want to exclude optional fields from the JSON output when they are not set. For example, if we have an API that allows users to create a profile and includes optional fields like phone number or website, we can use omitempty to omit those fields from the JSON payload if the user does not provide a value for them.

This can help reduce the size of the JSON payload and make the data more concise. It also simplifies the processing of JSON data on the receiving end, as the consumer of the API does not need to handle unnecessary fields that are not relevant to their use case.

Considerations and Gotchas

While the omitempty tag is a powerful feature, it’s essential to keep a few things in mind when using it:

1. Zero Values

By default, Go considers the zero values of different types when determining whether a field should be omitted or not. For example, an empty string, zero integer, or zero value of any other type will be treated as a zero value. So, if you want to include zero values for a field, you should avoid using the omitempty tag.

2. Pointers

When working with pointer types, Go considers a nil pointer as an empty value and will omit the field if the omitempty tag is specified. However, if the pointer is not nil and points to a zero value, the field will be included in the JSON output. So, pay attention to how you handle pointers when using omitempty.


The omitempty tag in Go provides us with a powerful mechanism to control the encoding and decoding of struct fields in JSON. It allows us to omit empty or zero values from the resulting JSON output, optimizing payload size, and enhancing readability. However, it’s crucial to understand the behavior of omitempty and consider its implications when using it in our code.

In my own experience, I have found the omitempty tag to be an invaluable tool in working with JSON data in Go. It has helped me write cleaner and more efficient code, making my applications perform better and improving the overall user experience.