golang has no annotations

As Golang gradually becomes a mainstream programming language, some people may ask: Golang does not have annotations, what impact will this have on coding?

For programmers who have just started using Golang, they may think that the lack of annotations in Golang is a serious shortcoming, but in fact, in this case, the role of annotations has been replaced by some grammatical features.

The difference between annotations and annotations

First, let us clarify the difference between annotations and annotations.

Comments are lines used to explain or comment in program code. These lines will not be parsed and executed by the compiler. In other words, comments are for programmers to understand the code, not for the computer to understand the code.

Annotations are a special language feature that are common in some other languages ​​such as Java and C#. Annotations allow developers to add additional metainformation to source code and be used by frameworks or tools at runtime or compile time.

In Golang, there are no real annotations, but there are some syntax features that can achieve similar goals.

Syntax features that replace annotations in Golang

1. Structure tags

The structure in Golang has a very useful feature: you can append a " mark". Tags are simple strings that describe the structure without interfering with the definition of the structure itself. This is useful for structs in frameworks and libraries.

For example, let's look at the code in the third-party library:

<code>type Model struct {
    ID        uint
    CreatedAt time.Time
    UpdatedAt time.Time
    DeletedAt *time.Time `sql:"index"`
}</code>

We append a sql:"index" tag to the deletion date, which will notify The SQL library represents this field as an index in the database. This tag is intended for use by frameworks and libraries, and simply adds a very useful piece of metadata.

2. Special constants

Constants are values ​​similar to variables, but cannot be changed. Special constants in Golang are constants that can be specially processed at compile time. These constants can be added to a program for special purposes such as event and error markers. Here is an example implementation using Iota and an enumeration:

<code>package main

import "fmt"

const (
    Unknown = iota
    Female = iota
    Male = iota
)

func main() {
    fmt.Printf("Unknown: %d, Female: %d, Male: %d", Unknown, Female, Male)
}</code>

This code block uses Iota as an auto-incrementing constant value, which we call the "enumeration type". The constant values ​​here are mainly used for elements of limited sets, such as gender, "unknown, male, female", etc.

3. Built-in annotations

Golang provides some built-in annotations, which are used as tools for collaborative work. These comments usually exist in a special format and can be used by the IDE. The following are some commonly used comments in Golang:

• // TODO: implies unfinished work in the code.
• // BUG: Indicates bugs that exist in the program. There is a format that can be searched and aggregated.
• // FIXME: Indicates that there is a known bug, but there is no time to solve it yet.
• // CODEGEN: A tag used to generate code instead of handwritten code.

These comments are different from annotations in that they are not converted into executable code at runtime.

Annotations are good, but they should not be overused

Although annotations are a very important feature, it is not a good idea to add arbitrary annotations when coding. Because if overused, these annotations can make the code cluttered and difficult to maintain. Additionally, the code generated at compile time may appear more confusing and may have unintended side effects.

Therefore, Golang adopts a more intuitive and concise method to add metadata. Although there are no real annotations, this method is enough to meet the needs of most programmers.

The above is the detailed content of golang has no annotations. For more information, please follow other related articles on the PHP Chinese website!