go常量

支持类型

数值类型

字符串类型

布尔类型

 

无类型常量（Untyped Constant）

即便两个类型拥有着相同的底层类型，但它们仍然是不同的数据类型，不可以被相互比较或混在一个表达式中进行运算。

type myInt int
const n myInt = 13
const m int = n + 5 // 编译器报错：cannot use n + 5 (type myInt) as type int in const initializer

func main() {
    var a int = 5
    fmt.Println(a + n) // 编译器报错：invalid operation: a + n (mismatched types int and myInt)
}

一：将常量n进行显示转化

type myInt int
const n myInt = 13
const m int = int(n) + 5  // OK

func main() {
    var a int = 5
    fmt.Println(a + int(n))  // 输出：18
}

二：无类型常量

实际在处理时，go进行了隐式转换

type myInt int
const n = 13

func main() {
    var a myInt = 5
    fmt.Println(a + n)  // 输出：18
}

Go 编译器在做隐式转型时，发现无法将常量转换为目标类型，Go 编译器也会报错，比如下面的代码就是这样：

const m = 1333333333

var k int8 = 1
j := k + m // 编译器报错：constant 1333333333 overflows int8

实现枚举

go 的 const 语法提供了“隐式重复前一个非空表达式”的机制

const (
    Apple, Banana = 11, 22
    Strawberry, Grape //11,22
    Pear, Watermelon //11,22
)

iota

iota 是 Go 语言的一个预定义标识符，它表示的是 const 声明块（包括单行声明）中，每个常量所处位置在块中的偏移值（从零开始）。同时，每一行中的 iota 自身也是一个无类型常量，可以像前面我们提到的无类型常量那样，自动参与到不同类型的求值过程中来，不需要我们再对它进行显式转型操作。 

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

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

隐式重复前一个非空表达式

每个 const 代码块都拥有属于自己的 iota , 每个 iota 的生命周期都始于一个 const 代码块的开始，在该 const 代码块结束时结束

const (
    a1 = 1         //1
    a2 = 2 << iota //2,左移1位 100 ，2*2=4
    a3             //2，左移2位，1000， 2*2*2 = 8
    a4             //2，左移3位, 10000, 2*2*2*2 = 16
)

const (
    aa = 1 << iota //1
    bb             //10 2
    cc             //100 4
    dd             //1000 8
)

const (
    aa, bb = iota, iota + 10 //0, 10
    cc, dd                   //1,11
    ee, ff                   //2,12
)

const (
    aa = 1
    bb = iota //1
    cc        //2
    dd        //3
    ee        //4
    ff        //5
)

const (
    aa = 1
    bb        //1
    cc        //1
    dd = iota //3
    ee        //4
    ff        //5
)

const (
    _  = iota //空白标识符占位
    aa        //1
    _
    bb //3
)