1：常量定义使用

在讲解常量之前，我们要先简单说一下我们前面讲解的变量。我们都知道，变量是用来存储数据，并且变量里面存储的值是可以在程序运行时随时发生变化的，例如如下案例，结果输出是多少？

  1. func main() {
  2.     var num int
  3.     num = 10
  4.     num = 20
  5.     fmt.Println("num = ", num)
  6. }


这个程序我们前面已经做过，最终的输出结果是20，因为重新给number变量赋值。
但是，常量里面的值确定好后，后面是不允许修改的。下面看一下关于常量的定义使用：

  1. func main() {
  2.     //变量：程序运行期间可以变化的量
  3.     //常量：程序运行过程中不可以变化的量
  4.     const a int = 10
  5.     fmt.Println("a = ", a)
  7.     //自动推导类型
  8.     const b = 11.2
  9.     fmt.Println("b = ", b)
  10. }


常量的命名规范与变量命名规范一致。

问题：什么场景下会用到常量呢？

在程序开发中，我们用常量存储一直不会发生变化的数据，例如：π，身份证号码等。像这类的数据，在整个程序中运行中都是不允许发生改变的。

2：字面常量

所谓字面常量（literal），是指程序中硬编码的常量，如：

  1. 123
  2. 3.1415
  3. 3.2+11i

3：iota枚举

常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。

注意：在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。

具体使用方式如下：

  1. package main
  3. import "fmt"
  5. func main() {
  6.     //1.iota常量自动生成器，每隔一行就会自动加一
  7.     //2.iota给常量赋值使用
  8.     const (
  9.         a = iota //0
  10.         b = iota //1
  11.         c = iota //2
  12.     )
  13.     fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
  15.     //3.iota遇到const，重置为0
  16.     const d = iota
  17.     fmt.Printf("d = %d\n", d)
  19.     //4.可以只写一个iota
  20.     const (
  21.         a1 = iota
  22.         b1
  23.         c1
  24.     )
  25.     fmt.Printf("a1 = %d, b1 = %d, c1 = %d\n", a1, b1, c1)
  27.     //5.如果是同一行，值都是一样的
  28.     const (
  29.         i = iota
  30.         j1, j2, j3 = iota, iota, iota
  31.         k = iota
  32.     )
  33.     fmt.Printf("i = %d, j1 = %d, j2 = %d, j3 = %d, k = %d\n", i, j1, j2, j3, k)
  34. }