【Go】Go 语言中的常量

---

一、常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。

常量是一个简单值的标识符，常量是在程序运行时不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

---

二、定义常量

常量的声明和变量声明非常类似，只是把 var 换成了const，常量在定义的时候必须赋值。

常量的定义格式：

//type可省略
const name [type] = value

类型说明符 [type]可以省略，因为编译器可以根据变量的值来推断其类型。

所以常量的定义分为两类：

//显式类型定义： 
const b string = "abc"
//隐式类型定义： 
const b = "abc"

声明了常量 b 之后，在整个程序运行期间它的值都不能再发生变化了。

多个常量的声明可以简写为：

//name1, name2可以是不同的数据类型
const name1, name2 = value1, value2

const (
	pi = 3.1415
    e = 2.7182
)

const 同时声明多个常量时，如果省略了值则表示和上面一行的值相同。 例如：

const (
    n1 = 100
    n2
    n3
)

上面示例中，常量n1、n2、n3的值都是100。

---

三、特殊常量 iota

iota是 Go 语言的常量计数器，只能在常量的表达式中使用。

iota在 const关键字 出现时将被重置为0。const中 每新增一行常量声明 将使 iota计数一次 (iota可理解为const语句块中的行索引)。 使用 iota 能简化定义，在定义枚举时很有用。举个例子：

const (
    n1 = iota //0
    n2        //1
    n3        //2
    n4        //3
)

iota是一个特殊常量，它是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值：

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

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 ，可以简写为如下形式：

const (
    a = iota
    b         //默认用上一行的值来赋给它，用iota的值赋给它，但是iota到这一行之后加1，所以b的值是1
    c
)

一些有趣的 iota 实例

1. 使用 _ 跳过某些值：

const (
	n1 = iota //0
	n2        //1
	_
	n4        //3
)

2. iota声明中间插队：

const (
    n1 = iota //0
    n2 = 100  //100
    n3 = iota //2
    n4        //3
)
const n5 = iota //0

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //用上一行的"ha"来赋值   iota += 1
            f = 100    //iota +=1
            g          //用上一行的100来赋值  iota +=1
            h = iota   //恢复计数,7
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

输出结果：

0 1 2 ha ha 100 100 7 8

3. 妙用省略和 iota 值

移位操作：<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。可见左移一位相当于乘一个2。

package main

import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}

以上实例运行结果为：

i= 1
j= 6
k= 12
l= 24

iota 表示从 0 开始自动加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），即：i=1, j=6，这没问题，关键在 k 和 l，从输出结果看 k=3<<2，l=3<<3。

简单表述:

i=1：左移 0 位，不变仍为 1。
j=3：左移 1 位，变为二进制 110，即 6。
k=3：左移 2 位，变为二进制 1100，即 12。
l=3：左移 3 位，变为二进制 11000，即 24。
注：<

4. 多个 iota 定义在一行

const (
    a, b = iota + 1, iota + 2 //iota 为0，则0+1,0+2 = 1，2
    c, d                      //iota 为1，则1+1,1+2 = 2，3
    e, f                      //iota 为2，则2+1,2+2 = 3，4
)

---

四、go 常量中的无类型常量

Go语言的常量有个 不同寻常 之处。虽然一个常量可以有任意一个确定的基础类型，例如int或float64，或者是类似time.Duration这样命名的基础类型，但是 许多常量并没有一个明确的基础类型 。

math.Pi就是 无类型 的浮点数常量：

const (
   E   = 2.71828182845904523536028747135266249775724709369995957496696763
   Pi  = 3.14159265358979323846264338327950288419716939937510582097494459
)

编译器为这些没有明确基础类型的数字常量提供比基础类型更高精度的算术运算，当赋值给特定类型时精度会有影响。

只有常量可以是无类型的。当一个无类型的常量被赋值给一个变量的时候，或者出现在有明确类型的变量声明的右边，无类型的常量将会被隐式转换为对应的类型。

对于常量面值，不同的写法可能会对应不同的类型。例如0、0.0、0i和\u0000虽然有着相同的常量值，但是它们分别对应无类型的整数、无类型的浮点数、无类型的复数和无类型的字符等不同的常量类型。同样，true 和 false 也是无类型的布尔类型，字符串面值常量是无类型的字符串类型。

---

参考链接

1. Go 语言常量
2. [Go] go常量中的无类型常量