Go 常量定义

定义常量在各个语言中都是不可或缺的语法了. 而有些语言在常量的基础上, 增加了枚举类型, 比如C.

enum Weekday {
        SUNDAY,
        MONDAY,
        TUESDAY,
        WEDNESDAY,
        THURSDAY,
        FRIDAY,
        SATURDAY
};

上面的枚举, 对应的值依次为0到6.

而在Go中, 是没有提供枚举类型的. 如果实现上面相同的功能, 难道要写成这样么?

const (
	SUNDAY = 0
	MONDAY = 1
	TUESDAY = 2
	WEDNESDAY = 3
	THURSDAY = 4
	FRIDAY = 5
	SATURDAY = 6
)

不过仔细想象, Go的开发者之一就是开发C语言的前辈, 怎么能不继承这么漂亮的语法呢?

Go在常量定义上实现了两个特殊的特性:

1. 若一个常量没有赋值, 则默认为重复上一行
2. iota 神器

分别介绍一下这两个家伙.

常量的默认值

当一个常量没有明确给出值的时候, 则常量默认重复上一行赋值的行为. 比如:

const (
	a    = 1
	b    // 1
	c    = 2
	d    // 2
	e, f = 3, 4
	g, h // 3,4
	i    // 报错, 因为前一行赋值为 3,4. 无法重复
)

包括如果上一个指定了类型, 下面的也会跟着指定.

iota

为当前常量块的索引值(行号), 从0开始. 对常量块的定义, 表示包在 const() 中的常量定义. 比如:

const s = iota // 0
const o = iota // 0
const (
	a    = iota       // 0
	b                 // 1
	c                 // 2
	d, e = iota, iota // 3, 3
	f, g              // 4, 4
)

在常量定义中, iota 是可以参与运算的哦.

使用

一下举几个我想到的例子, 通过组合上面的特性, 通常还是能够有不错的效果的.

1. 定义二进制标识位

const (
	isA = 1 << iota // 0b1
	isB // 0b10
	isC // 0b100
	isD // 0b1000
)

2.丢弃及重复使用 iota

当需要索引从1开始时, 可以将第一行丢掉.

const (
	_ = iota // 丢弃0
	a // 1
	b // 2
	_ // 丢弃3
	c,d = iota,iota // 4,4 重复使用
)

3.数值型运算

上面都比较简单, 想了几个玩的比较花的. 来瞅瞅.

const (
	P   = 3.1415926      // 定义π
	P_2 = P / (2 * iota) // P/2
	P_4                  // P/4
	P_6                  // P/6
	P_8                  // P/8
)

const (
	P    = 3.1415926       // π
	P_2  = P / (1 << iota) // P/2
	P_4                    // P/4
	P_8                    // P/8
	P_16                   // P/16
)

const (
	P          = 3.1415926                       // 排
	P_2, P_M_2 = P / (1 << iota), P * (iota + 1) // P/2 P*2
	P_4, P_M_3                                   // P/4 P*3
	P_8, P_M_4                                   // P/8 P*4
)

4.计算容量单位大小

const (
	_  = 1 << (10 * iota) // 索引为0的数据不要了
	KB                    // 2^10
	MB                    // 2^20
	GB                    // 2^30
	TB                    // 2^40 下同
	PB
	EB
	ZB
	YB
)

---

OK, Go的常量定义基本也就这些了, 如果没有iota, 那么重复上一行行为也没有太大意义了, 毕竟定义几个相同值的常量有什么用呢? 将这两个特性想结合之后, 往往能够实现很不错的效果.