常量的定义

  • 常量的值在编译时就已经确定
  • 常量的定义格式与变量基本相同
  • 等号右侧必须是常量或者常量表达式
  • 常量表达式中的函数必须是内置函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

import "fmt"

// 定义单个常量
const a int = 1
const b = 'B'
const (
	text = "123"
	length = len(text)
	num = b * 20
)

// 同时定义多个变量
const i, j, k = 1, "2", '3'
const (
	text2, length2, num2 = "468", len(text2), k * 10
)

func main()  {
	fmt.Println(a, b, text, length, num)
	fmt.Println(i, j, k, text2, length2, num2)
}

输出：
1 66 123 3 1320
1 2 51 468 3 510

常量的初始化规则与枚举

  • 在定义常量组时，如果不提供初始值，则表示将使用上行的表达式
  • 使用相同的表达式不代表具有相同的值
  • iota是常量的计数器，从0开始，组中每定义1个常量自动递增1
  • 通过初始化规则与iota可以达到枚举的效果
  • 每遇到一个const关键字，iota就会重置为0
1
2
3
4
5
6
7
8
9
10
// 常量定义也有大小写之分，大写包外可以访问
const (
	// a与b都为'A',常量b会引用上一个常量的值或者表达式
	a = 'A'
	b
	// c的值为2，d的值为3，e的值为4，iota是常量计数器，显示赋值之后的常量值才生效
	c = iota
	d = iota
	e
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 错误写法，会提示：missing init expr for Sunday
const (
	// 第一个常量不可省略表达式，必须给一个明确的值
	Sunday
	Monday = iota
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
)

// 正确写法
const (
	// 第一个常量不可省略表达式，必须给一个明确的值
	Sunday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
)

运算符

Go中的运算符均是从左至右结合
优先级（从高到低）

1
2
3
4
5
6
7
^     !                                          （一元运算符）
*     /    %    <<    >>    &      &^            （一元运算符）
+     -    |    ^                                （二元运算符）
==    !=   <    <=    >=    >                    （二元运算符）
<-                                               （专门用于channel）
&&
||
1
2
3
4
5
6
7
8
9
/*
 6: 0110
11: 1011
----------
&   0010 = 2（与）
|   1111 = 15（或）
^   1101 = 13（异或）
&^  0100 = 4
 */

思考问题

请尝试结合常量的iota与<<运算符实现计算机储存单位的枚举？

从小到大的存储单位主要利用移位操作，我们可以利用常量引用上一个常量的iota表达式来实现移位操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

const (
	_ = iota
	KB float64 = 1 << (iota * 10)
	MB
	GB
	TB
	PB
)

func main()  {
	fmt.Println(KB, MB, GB, TB, PB)
}

输出：
1024 1.048576e+06 1.073741824e+09 1.099511627776e+12 1.125899906842624e+15