The magical power of Go language iota

Preface

When you delve into the official website library, open source library or any Go project, you will find that the magical identifier iota is everywhere. It plays an important role in making the code more concise, clear, and improves readability and maintainability. It has a wide range of applications, ranging from bitwise operations on enumerated types to complex constant expression calculations.
In this article, I will take you to explore the magical power of iota in depth, including the introduction and application scenarios of iota, as well as usage tips and precautions.
Are you ready? Grab a cup of your favorite drink or tea and follow this article to find out.

iota introduction

Within a constant declaration, the predeclared identifier iota represents successive untyped integer constants.
 Its value is the index of the respective ConstSpec in that constant declaration, starting at zero.[1]

The above quote comes from the official website document Iota. The original words translated into Chinese mean:
In the constant declaration, the pre-declared identifier iota represents a continuous untyped integer constant. Its value is the index of the corresponding ConstSpec in the constant declaration, counting from zero.
In short, by using iota, we can automatically create a series of consecutive integer values ​​in the constant declaration, starting from zero, without the need to manually specify the value of each constant.

Application scenarios of iota

Automatically generate increasing constant values

Increasing constant values ​​can be generated conveniently using iota. The first constant using iota in the constant declaration is initialized to 0, and the values ​​of subsequent constants will be automatically incremented. This eliminates the need to manually specify the value of each constant when defining a set of incrementing constants, and improves the readability of the code. performance and maintainability. For example:

const (
	Apple  = iota // 0
	Banana        // 1
	Cherry        // 2
)

Construct enumeration type constants

Using iota makes it easy to define a series of related enumeration values ​​without having to manually specify a specific number for each value. Such enumeration type definitions are more concise and easy to extend and modify. For example:

type WeekDay int

const (
	Sunday    WeekDay = iota // 0
	Tuesday                  // 1
	Wednesday                // 2
	Thursday                 // 3
	Friday                   // 4
	Saturday                 // 5
	Monday                   // 6
)

If you want to know more detailed usage of enumerations, you can go to Go There is no enumeration type in the language, but we can do this to read.

Expression evaluation

By using iota in constant declarations, you can create complex expressions and adjust the value of iota as needed in each constant declaration. This makes it easy to generate a set of constants with specific patterns. For example:

const (
	_  = iota
	KB = 1 << (10 * iota) // 1 << (10 * 1) = 1024B = 1KB
	MB = 1 << (10 * iota) // 1 << (10 * 2) = 1048576B = 1MB
	GB = 1 << (10 * iota) // 1 << (10 * 3) = 1073741824B = 1GB
	TB = 1 << (10 * iota) // 1 << (10 * 4) = 1099511627776B = 1TB
)

Bit operations

Use the left shift operator (<<) with iota to conveniently generate a set of bitwise constants. For example:

const (
	FlagNone  = 0         // 0
	FlagRead  = 1 << iota // 1
	FlagWrite             // 2
	FlagExec              // 4
)

Tips and precautions for using iota

Jump value use

We can use _ (underscore) to ignore certain values, for example:

const (
	Apple = iota // 0
	_
	Banana // 2
)

Different constant blocks, iota is independent

The scope of iota is the entire constant block. The iota of different constant blocks are independent. The value of the first iota in each constant block is 0.

const (
	A = iota // 0
	B        // 1
)

const (
	C = iota // 0
	D        // 1
)