Go language constant decryption: constant values (const and iota) (with code examples)

The Go language provides a variety of constant types. Common constant types include:

• Integer types: int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, etc.

• Floating point number types: float32, float64.

• Boolean type: bool, the value is true or false.

• String type: string.

• Character type: byte, used to represent ASCII characters.

In addition to basic data types, the Go language also provides constants of composite types, such as arrays, slices, maps, structures, etc., for storing multiple values or values of different types.

Next, let’s introduce another keyword iota related to constants.

iota

In the Go language, iota is a special constant that can be used as an incrementing counter (constant counter) for enumeration values and can only be used in constant expressions. iota is reset to 0 every time the const keyword appears, and every time iota appears, its value will increase by 1 (iota can be understood as the row index in the const statement block).

Code Example 1

Using iota can simplify definitions and is useful when defining enumerations. Here are some usage examples of iota:

?

In the above example, the value of Monday is iota + 1, which is 1. The value of Tuesday is iota + 1, which is 2. By analogy, the value of each constant will be calculated according to iota's auto-increment rules.

For more related technical points about Go, please pay attention to the public account: CTO Plus for subsequent posts. If you have any questions, please leave a message in the background for communication.

?

Code Example 2

iota can also be used to define a set of related constants, where the value of each constant is twice the value of the previous constant. Here's an example:

package main</code>
<code>import "fmt"</code>
<code>func iotaFunc2() {<!-- --></code><code> const (</code><code> KB = 1 << (10 * iota) // 1 is shifted left by 10 bits, that is 1024</code><code> MB // Shift 1 to the left by 20 bits, that is, 1024*1024</code><code> GB // Shift 1 to the left by 30 bits, that is, 1024*1024*1024</code><code> TB // 1 is shifted 40 bits to the left, that is, 1024*1024*1024*1024</code><code> )</code>
<code> fmt.Println(KB) // Output: 1</code><code> fmt.Println(MB) // Output: 1024</code><code> fmt.Println(GB) // Output: 1048576 </code><code> fmt.Println(TB) // Output: 1073741824</code><code>}

In the above example, the value of KB is 1 << (10 * iota), that is, 1 is shifted to the left by 10 bits, that is, it changes from 1 to 10000000000, which is 1024. The value of MB is 1 << (10 * iota), that is, 1 is shifted to the left by 20 bits, which is 1024*1024. By analogy, the value of each constant is twice the previous constant.

Code Example 3

iota can also be used for bit operations, such as defining a set of permission constants:

package main</code>
<code>import "fmt"</code>
<code>const (</code><code> ReadPermission = 1 << iota // Shift 1 to the left by 0 bits, which is 1</code><code> WritePermission // Shift 1 to the left by 1 bit, which is 2</code> <code> ExecutePermission // 1 is shifted left by 2 bits, which is 4</code><code>)</code>
<code>func main() {<!-- --></code><code> var permission int = ReadPermission | WritePermission</code>
<code> fmt.Println(permission & amp;ReadPermission == ReadPermission) // Output: true</code><code> fmt.Println(permission & amp;WritePermission == WritePermission) // Output: true</code> <code> fmt.Println(permission & amp;ExecutePermission == ExecutePermission) // Output: false</code><code>}

In the above example, the value of ReadPermission is 1 << iota, that is, 1 is shifted 0 bits to the left, which is 1. The value of WritePermission is 1 << iota, that is, 1 is shifted to the left by 1 bit, which is 2. By analogy, the value of each constant is twice the previous constant. Finally, we can use bit operations to determine whether a certain permission is set.

For more related technical points about Go, please pay attention to the public account: CTO Plus for subsequent posts. If you have any questions, please leave a message in the background for communication.

?

Code Example 4

Combined with_skipping certain values, iota's queue-jumping definition, example of using iota definition in multiple lines

func iotafFunc4() {<!-- --></code><code> //Use _ to skip certain values</code><code> const (</code><code> num1 = iota </code><code> _ // _ also occupies one line, so the value of _ is equivalent to 1</code><code> num3</code><code> _</code><code> num5</code><code> )</code><code> // Here again the assignment of const jump iota</code><code> const (</code><code> num6 = iota</code><code> num7 // num6=iota, so the value of num6 is 0; num7 does not have =, so the value is deduced to 1</code><code> num8 = 123 // Because num8=123, and num9 does not have =, so it is the same as the value of num9 To remain consistent, they are all 123</code><code> num9</code><code> num10 = iota</code><code> num11</code><code> )</code><code> fmt.Println( num1, num3, num5, num6, num7, num8, num9, num10, num11) // 0 2 4 0 1 123 123 4 5</code>
<code> //Multiple iota definitions in one line</code><code> const (</code><code> n1, n2 = iota + 1, iota + 2</code><code> n3, n4</code><code> n5, n6</code><code> n7, n8</code><code> // n9, n10, n11 incorrect usage, the number of variables in each row must be consistent with the first row</code><code> // n9, n10, n11, n12 //missing init expr for n11</code><code> )</code><code> fmt.Println(n1, n2, n3, n4, n5, n6, n7, n8) // 1 2 2 3 3 4 4 5</code>
<code> const (</code><code> n11, n12 = iota + 1, iota + 1</code><code> n13, n14 = iota + 1, iota + 1</code><code> )</code><code> fmt.Println(n11, n12, n13, n14) // 1 1 2 2</code><code>}

Usage scenarios of constants< /strong>