In Go language, struct tags are meta information attached to the structure field, which is used to control serialization, deserialization behavior or provide library configuration. 1. struct tags are written in the backticks in the format of key:"value", such as json:"name", which determines the serialization method of the field; 2. Multiple tags can coexist, and each library parses the required parts, such as json and gorm together; 3. mapstruct is used to configure mapping, and supports omitting tags and nested structures when the field names are consistent; 4. Pay attention to avoid spelling errors, fields need to be exported, and tags cannot be abused to affect readability. Mastering its usage can help improve development efficiency and code quality.

In Go, structs are one of the basic ways we organize data. struct tags are some meta information attached to the structure field, which is usually used to control serialization, deserialization behavior, or to provide additional configuration information for other libraries.

These tags seem simple, but if you don’t understand them clearly in actual development, it is easy to get into pitfalls. Let’s take a look at some key points and usage tips of struct tags.

What is struct tags?

struct tags is a string tag written after the structure field, wrapped in backticks (`). For example:

 type User struct {
    Name string `json:"name"`
    Age int `json:"age,omitempty"`
    Email string `json:"-"`
}

json:"name" , json:"age,omitempty" and json:"-" in the above example are all struct tags. Their function depends on the library you use, such as standard library encoding/json or third-party libraries such as yaml, gorm, mapstructure, etc.

The format of each tag is usually: key:"value" , where value can contain multiple options, separated by commas.

Common uses and recommendations

1. Control JSON serialization/deserialization behavior

This is the most common use scenario. Through json tags, you can specify the name of the field in JSON, whether to ignore null values, etc.

• Field name mapping: json:"username" means that the field is called username in JSON.
• Ignore null values: omitempty means that if the field is empty (such as empty string, 0, nil, etc.), it will not be output to JSON.
• Force ignorance: json:"-" means that this field should not be output at any time.

Small suggestions:

• If you are not sure whether a field is empty but do not want to be exposed to external interfaces, you can add omitempty .
• If you want to completely hide the fields, use - , but be careful that this won't really protect the data, it's just not serializing.

2. Use multiple tags at the same time

A field can have multiple tags, which is suitable for using multiple libraries at the same time. For example:

 type Product struct {
    ID int `json:"id" gorm:"primaryKey"`
    Name string `json:"name" validate:"required"`
}

Here we use three tags: json, gorm and validate. Different libraries will read the parts they need and will not affect each other.

Notice:

• Different libraries may have slightly different ways of parsing tags, and some support more syntax (such as mapstructure support ,squash ).
• If you are using certain frameworks (such as Gin, Echo), remember to check the document to confirm whether the tag is effective correctly.

3. Use mapstruct for configuration mapping

When loading configurations from YAML or TOML files, they are often used with viper and mapstructure. At this time, the key of the struct tag becomes mapstructure .

For example:

 type Config struct {
    Port int `maplanture:"port"`
    Hostname string `maplanture:"hostname"`
}

This allows automatic mapping from the configuration file to the structure field.

Practical Tips:

• If the field name and the configuration item name are the same, the tag can be omitted.
• Use mapstructure:",squash" to "flat" the nested structure, which is convenient for combining and configuration.

Frequently Asked Questions and Precautions

• A misspelling of tags will cause it to not work : for example, if you write it as jons:"name" , the JSON package will ignore it directly.
• Fields must be exported (capsular) before they can be processed : otherwise many libraries will skip this field.
• Don't abuse tags : Although you can write many tags on a field, if there are too many, it will affect readability.

Basically that's it. struct tags, although it seems to be a small detail, is very useful in actual projects. As long as you master the basic format and usage of each library, you can avoid a lot of trouble.

The above is the detailed content of Go struct tags. For more information, please follow other related articles on the PHP Chinese website!