一.常量概述

  • 常量是一个固定值,在编译器就确定结果.声明时必须赋值且结果不可以改变.
  • 因为常量在编译器就确定,可以防止程序运行过程中意外修改
  • 常量关键字const
  • 常量定义完可以不使用
  • Go语言中常量定义没有明确语法要求,可以不全大写,驼峰即可.

  • 很多内容可以定义成常量

    • 人名
    • 圆周率
    • 电话号
    • 等

      二. 常量定义

  • 定义常量时如果不是必须指定特定类型,可以省略类型,使用默认类型.且数值类型常量(不定义类型)可以直接进行运算

  • 常量的值可以是表达式,但是不允许出现变量

    1. func main() {
    2.   const a string = "smallming"
    3.   const b = 123
    4.   const c = 3*2 + 5//不要指定类型
    5.   const d = 1.5//不要指定类型
    7.   fmt.Printf("%T %T",c,d)//int float
    9.   fmt.Println(c+d)//12.5
    11.   //下面这种方式是错误的
    12.   i := 3
    13.   const e = i*2 + 5 //const initializer i * 2 + 5 is not a constant
    14. }

  • 当定义多个常量时官方推荐的方式

    1.   const (
    2.       a = 1
    3.       b = 2
    4.       c = true
    5.   )

  • 定义多常量时后一个常量如果没有赋值,与前一个常量值相同.

    • 第一个常量必须赋值
      1. func main() {
      2. const (
      3.    a = 1
      4.    b
      5.    c
      6. )
      7. fmt.Println(a,b,c)//输出:1 1 1
      8. }

三.常量生成器

  • 当一组常量都是数值类型,可以使用常量生成器iota指定这组常量按照特定规则变化

  • iota起始值为0,每次增加1

    1. func main() {
    2.   const (
    3.       a = iota
    4.       b 
    5.       c 
    6.   )
    7.   fmt.Println(a, b, c) //输出: 0 1 2
    9.   const (
    10.       d = iota << 1
    11.       e 
    12.       f 
    13.   )
    14.   fmt.Println(d, e, f) //输出:0 2 4
    15. }

  • 无论是否使用iota,一组常量中每个的iota值是固定的,iota按照顺序自增1

  • 每组iota之间无影响

    1. func main() {
    2.   const (
    3.       a = 5    //iota=0
    4.       b = 3    //iota=1
    5.       c = iota //iota=2
    6.       d        //iota=3
    7.   )
    8.   fmt.Println(a, b, c, d) //输出5 3 2 3
    10.   const (
    11.       e = iota //iota=0
    12.       f        //iota=1
    13.       g = 10   //iota=2
    14.       h        //iota=3
    15.       i = iota //iota=4
    16.       j        //iota=5
    17.   )
    18.   fmt.Println(e, f, g, h, i, j) // 0 1 10 10 4 5
    19. }