Go语言的常量

常量：恒定不变的值

常量使用关键字const定义，用于存储不会改变的数据。常量不能被重新赋予任何值。

常量的定义格式：const identifier [type] =value。

省略类型说明符[type]，Go语言的编译器可以智能地判断值的类型。

显式定义：const h string="hello"

隐式定义：const w="world"

常量可以用作枚举：

const(
    Connected=0
    Disconnected=1
    Unknown=2
)

iota，在每一个const关键字出现 时被重置为0，然后下一个const出现之前，每出现 一次iota，其所代表的数字就会自动加1。

使用iota关键字实现枚举的代码如下：

package main

import(
  "fmt"
)
const(
  a=iota               //a==0
  b                    //b==1,隐式使用iota关键字
  c                     //c==2,实际等同于c=iota
  d,e,f=iota,iota,iota  //d=3,e=3,f=3,同一行值相同，些处不能只写一个iota
  g=iota                //g==4
  h="h"                 //h=="h",单独赋值，iota依旧递增为5
  i                     //i=="h",默认使用上面的赋值，iota依旧递增为6
  j=iota                //j==7
)
const z =iota   //每个单独定义const常量中，iota都会重置，此时z==0
func main(){
  fmt.Println(a,b,c,d,e,f,g,h,i,j,z)
}

代码结果如下：

0 1 2 3 3 3 4 h h 7 0

枚举——一组常量值

代码如下：

package main

import (
	"fmt"
)

func main() {
	type Weapon int
	const (
		Arrow Weapon = iota
		Shuriken
		SniperRifle
		Rifle
		Blower
	)
	fmt.Println(Arrow, Shuriken, SniperRifle, Rifle, Blower)
	var weapon Weapon = Blower
	fmt.Println(weapon)
}

运行结果如下：

0 1 2 3 4
4

代码如下：

package main

import (
	"fmt"
)

func main() {
	const (
		FlagNone = 1 << iota
		FlagRed
		FlagGreen
		FlagBlue
	)
	fmt.Printf("%d %d %d\n", FlagRed, FlagGreen, FlagBlue)
	fmt.Printf("%b %b %b\n", FlagRed, FlagGreen, FlagBlue)
}

运行结果如下：

2 4 8
10 100 1000

将枚举值转换为字符串

代码如下：

package main

import (
	"fmt"
)

type ChipType int

const (
	None ChipType = iota
	CPU
	GPU
)

func (c ChipType) String() string {
	switch c {
	case None:
		return "None"
	case CPU:
		return "CPU"
	case GPU:
		return "GPU"
	}
	return "N/A"
}

func main() {
	fmt.Printf("%s %d", CPU, CPU)
}

运行结果如下：

CPU 1