Struct Tags in Go How They Work and Their Role in Serialization

In Go, struct tags provide metadata about struct fields, helping with serialization, validation, and interoperability with external systems. They are commonly used in libraries like encoding/json, gorm, and protobuf to control how struct fields are processed.

This article explores how struct tags work, their syntax, and their role in serialization.

Struct tags are string literals associated with struct fields, enclosed in backticks (`). They follow a key-value format where each key corresponds to a package or library, and the value specifies metadata for that package.

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	ID    int    `json:"id"`
	Name  string `json:"name"`
	Email string `json:"email,omitempty"`
}

func main() {
	user := User{ID: 1, Name: "Alice"}
	jsonData, _ := json.Marshal(user)
	fmt.Println(string(jsonData)) // {"id":1,"name":"Alice"}
}

Explanation:

• json:"id" renames the ID field to "id" in JSON output.
• json:"email,omitempty" omits the Email field if it is empty.

Struct tags play a crucial role in controlling JSON serialization with the encoding/json package.

type Product struct {
	Name  string  `json:"product_name"`
	Price float64 `json:"price"`
}

type Response struct {
	Status  string `json:"status"`
	Message string `json:"message,omitempty"`
}

Key Options:

• omitempty: Excludes the field if it has a zero value.
• -: Skips a field from being serialized.

type User struct {
	Password string `json:"-"`
}

In Go's ORM library GORM, struct tags define table schema mappings.

type User struct {
	ID    uint   `gorm:"primaryKey"`
	Name  string `gorm:"size:100;not null"`
	Email string `gorm:"unique"`
}

Explanation:

• primaryKey sets ID as the primary key.
• size:100 limits Name to 100 characters.
• not null ensures Name is required.
• unique enforces unique values for Email.

The validator package uses struct tags to enforce validation rules on user input.

import (
	"github.com/go-playground/validator/v10"
)

type User struct {
	Name  string `validate:"required"`
	Email string `validate:"required,email"`
	Age   int    `validate:"gte=18"`
}

func main() {
	v := validator.New()
	user := User{Name: "", Email: "invalid-email", Age: 16}

	err := v.Struct(user)
	if err != nil {
		fmt.Println("Validation failed:", err)
	}
}

Explanation:

• required ensures a field is not empty.
• email checks for a valid email format.
• gte=18 ensures Age is at least 18.

Go struct tags also appear in protobuf (Google's serialization format).

type Person struct {
	Name string `protobuf:"bytes,1,opt,name=name"`
	Age  int    `protobuf:"varint,2,opt,name=age"`
}

Explanation:

• bytes,1,opt,name=name assigns a field number (1) for protobuf serialization.
• varint,2,opt,name=age sets a field number for integer serialization.

Go allows reading struct tags at runtime using reflection (reflect package).

import (
	"fmt"
	"reflect"
)

type User struct {
	Name  string `json:"name" validate:"required"`
	Email string `json:"email" validate:"required,email"`
}

func main() {
	t := reflect.TypeOf(User{})
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		fmt.Println("Field:", field.Name)
		fmt.Println("JSON Tag:", field.Tag.Get("json"))
		fmt.Println("Validation Tag:", field.Tag.Get("validate"))
	}
}

Use Case: Useful for building generic validation or serialization utilities.

• Use meaningful tags: Ensure tags clearly define their role (json, validate, gorm).
• Leverage omitempty for optional fields: Avoid unnecessary null or empty values.
• Be careful with reflection: Accessing tags dynamically can introduce performance overhead.
• Standardize tagging conventions: Maintain consistency across a project for readability.

Struct tags are a powerful feature in Go, enabling better serialization, validation, and database integration. By understanding how to use them effectively, developers can write cleaner, more maintainable Go code.

From JSON serialization to database ORM and input validation, struct tags enhance Go's type system and improve interoperability with external systems.