What does golang enumeration mean?

Golang enumeration is an important data type, consisting of a set of key-value pairs. It is usually used as a constant identifier in programming languages. In major popular programming languages ​​such as c, java, etc., There is native support. In the field of programming, enumerations are used to represent types that contain only a limited number of fixed values. They are generally used in development to identify error codes or state machines.

The operating environment of this article: Windows 10 system, go1.20 version, dell g3 computer.

An enumeration is an important data type that consists of a set of key-value pairs and is usually used as an identifier for constants in programming languages. Major popular programming languages ​​such as c, java, etc. have native support. In go, you can't find enum or other keywords directly used to declare enumeration types. For developers who are familiar with other programming languages ​​and switch to Go programming, it will be more difficult to accept this situation at first. In fact, if you see how enumeration types are represented in Go, you may feel that the Go language designers have considered simplicity and problems in depth, which is unmatched by ordinary junior engineers. In the field of programming, enumerations are used to represent types that contain only a limited number of fixed values. They are generally used in development to identify error codes or state machines.

In fact, in the eyes of Go language designers, enum is essentially a constant. Why is there an extra keyword? There is just no enum keyword in go, and its form of expressing enumerations is not much different from other languages. Let's take a look at how to represent enumerations in go.

Learning and using a language is to learn and understand the design philosophy of the language itself, and at the same time, you will also feel the personality characteristics of the designer.

Basic work

For the convenience of the following explanation, here we use go modules to create a simple project first.

~/Projects/go/examples  
➜  mkdir enum  
~/Projects/go/examples  
➜  cd enum  
~/Projects/go/examples/enum  
➜  go mod init enum  
go: creating new go.mod: module enum  
~/Projects/go/examples/enum  
➜  touch enum.go

const iota

Take the three states of starting, running, and stopping as an example, and use the const key to declare a series of constant values. Write the following content in enum.go:

package main  
import "fmt"  
const (  
    Running int = iota  
    Pending  
    Stopped  
)  
func main() {  
    fmt.Println("State running: ", Running)  
    fmt.Println("State pending: ", Pending)  
    fmt.Println("State Stoped: ", Stopped)  
}

Save and run, you can get the following results,

~/Projects/go/examples/enum   
➜  go run enum.go  
State running:  0  
State pending:  1  
State Stoped:  2

explains what happened Before, let’s take a look at one thing, iota. Compared with C and Java, Go provides a constant counter, iota, which uses continuous assignment of values ​​​​to constants when declaring them.

For example, in this example,

const (  
    a int = iota // a = 0  
    b int = iota // b = 1  
    c int = iota // c = 2  
)  
const d int = iota // d = 0

In a const declaration block, the initial value of iota is 0, and each time a variable is declared, it increases by 1. The above code can be simplified to:

const (  
    a int = iota // a = 0  
    b // b = 1  
    c // c = 2  
)  
const d int = iota // d = 0

Imagine what would happen if there were 50 or 100 constant numbers at this time and were written in C and Java languages.

Regarding iota, there are more specific techniques (such as hop count). Please see the official definition of iota for details.

It is very convenient to use const to define a series of constants and use the iota constant counter to quickly and continuously assign values ​​to numeric type constants. Although there is no enum keyword, it is found to be redundant in this case. Enumerations are essentially a combination of constants.

Of course, you can use the following method to get closer to enums in other languages.

// enum.go  
...  
type State int  
const (  
    Running State = iota  
    Pending  
    Stopped  
)  
...

Wrap a set of constant values ​​​​with a type alias, right? Is it more like enum {} defined in other languages?

You can also change the above example to:

// enum.go  
...  
type State int 
const (  
    Running State = iota  
    Pending  
    Stopped  
)  
func (s State) String() string {  
    switch s {  
    case Running:  
        return "Running"  
    case Pending:  
        return "Pending"  
    case Stopped:  
        return "Stopped"  
    default:  
        return "Unknown" 
     }  
}  
...

Add the String function to the defined enumeration type, and the running result is as follows:

~/Projects/go/examples/enum   
➜  go run enum.go  
State running:  Running  
State pending:  Pending  
State Stoped:  Stopped

Isn’t it magical? My thoughts have broadened and I have gained a lot of experience. Separating the actual value from the printed characters is something that most language designers would not think of. Seeing this, do you have this feeling? The designer of the Go language is not lazy, but has thought a lot and done a lot in order to be lazy.

The above is the detailed content of What does golang enumeration mean?. For more information, please follow other related articles on the PHP Chinese website!