• [go学习笔记.第十五章.反射,常量] 2.常量

    1.常量的定格式 

     const identifier [type] = value

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

            显式类型定义： const b string = "abc"
            隐式类型定义： const b = "abc"
            多个相同类型的声明可以简写为：  const c_name1, c_name2 = value1, value2

    注意:

    • 数据类型可以省略, 但是const不能省略
    • 定义常量不能使用 := , := 是专门用于定义局部变量的
    • 定义局部变量没有使用, 编译会报错, 定义全局变量和常量没有使用, 不会报错
    • 在Go语言中可以连续定义多个变量, 所以也可以连续定义多个常量
      格式:
      const 变量名称1, 变量名称2 数据类型 = 值1, 值2
      const(
      变量名称1 数据类型 = 值1
      变量名称2 数据类型 = 值2
      )

    2.举例说明:

    定义单个常量 

    1.     const num int  =  666   //方式一
    2.     //const num  =  666     //方式二
    3.     //const num := 666   报错，:=只能用于定义局部变量
    4.     fmt.Printf("%d\n", num)

    定义多个常量 

    1.      const a, b, c int  = 10, 20, 30  //方式一
    2.     //const a, b, c  = 10, 20, 30    //方式二
    3.     //常量不是变量，只能定义的同时初始化，之后不能赋值，后面三行代码会报错
    4.     //a = 666
    5.     //b = 777
    6.     //c = 888

    常量组

    1.     //方式一
    2.     const(
    3.         a int = 10
    4.         b int = 20
    5.         c int = 30
    6.       )
    7.     //方式二
    8.     //const(
    9.         //  a  = 10
    10.         //  b  = 20
    11.         //  c  = 30
    12.      //)
    13.     //下三行会报错
    14.     //a = 666
    15.     //b = 777
    16.     //c = 888

     常量组的注意点

    • 和变量不同，定义的常量没有被使用,编译器不会报错, 可以编译运行
    • 在常量组中, 如果常量没有赋值, 那么默认值就是上一行的取值，注意，是一行
    1. const(
    2.         a  = 666   //666
    3.         b = 789    //789
    4.         c          //789
    5.     )
    6. fmt.Printf("%d, %d, %d", a, b, c)   
    7.  
    8. const(
    9.         a, b = 10, 20
    10.         c, d          //c,d对应a,b的值
    11. )
    12. fmt.Printf("%d, %d\n", a, b)  //10,20
    13. fmt.Printf("%d, %d\n", c, d)  //10,20

    3.枚举常量 

    • Go语句中没有明确枚举的固定写法, 但是在企业开发中一般都会常量组的形式来表示枚举
    • 格式：
      const(
            枚举元素 = 值
            枚举元素 = 值
      )
      1. const(
      2.         male = 0
      3.         female = 1
      4. )

    迭代器iota-特殊常量，可以认为是一个可以被编译器修改的常量

    1. //iota是迭代器, 默认会从0开始递增
    2. const(
    3.         male = iota //0
    4.         female = iota //1
    5.         yao = iota //2
    6. )

    只要常量组中出现了iota, 该常量组中后续的常量都会一次递增1 

    1. const(
    2.         male = iota    //0
    3.         female         //1
    4.         yao            //2
    5.     )

    如果常量组中的iota被打断了, 那么就不会继续递增了, 会按照常量组的默认方式处理(上一行的值) 

    1. const(
    2.         male = iota        //0
    3.         female = 666       //666
    4.         yao                //666
    5.     )

    如果常量组中的itoa被打断了, 但是后续又被恢复了(显式恢复), 那么前面有多少行就会递增多少 

    1. const(
    2.         male = iota   //0
    3.         female = 666  //666
    4.         yao = iota    //2
    5.     )
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6.     const (
    7.             a = iota   //0
    8.             b          //1
    9.             c          //2
    10.             d = "ha"   //独立值，iota += 1
    11.             e          //"ha"   iota += 1
    12.             f = 100    //iota +=1
    13.             g          //100  iota +=1
    14.             h = iota   //7,恢复计数
    15.             i          //8
    16.     )
    17.     fmt.Println(a,b,c,d,e,f,g,h,i)
    18. }
    19.  
    20. //结果如下:
    21. //0 1 2 ha ha 100 100 7 8
    1. package main
    2.  
    3. import "fmt"
    4. const (
    5.     i=1<<iota
    6.     j=3<<iota
    7.     k
    8.     l
    9. )
    10.  
    11. func main() {
    12.     fmt.Println("i=",i)
    13.     fmt.Println("j=",j)
    14.     fmt.Println("k=",k)
    15.     fmt.Println("l=",l)
    16. }
    17.  
    18. //结果如下:
    19. //i= 1
    20. //j= 6
    21. //k= 12
    22. //l= 24
    23.  
    24. //iota 表示从 0 开始自动加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），即：i=1, j=6，这没问题，关键在 k 和 l，从输出结果看 k=3<<2，l=3<<3。
    25.  
    26. //简单表述:
    27.  
    28. //i=1：左移 0 位,不变仍为 1; j=3：左移 1 位,变为二进制 110, 即 6; k=3：左移 2 位,变为二进制 1100, 即 12; l=3：左移 3 位,变为二进制 11000,即 24

    常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过 

    1. package main
    2.  
    3. import "unsafe"
    4.  
    5. const (
    6.     a = "abc"
    7.     b = len(a)
    8.     c = unsafe.Sizeof(a)
    9. )
    10.  
    11. func main(){
    12.     println(a, b, c)
    13. }
    14.  
    15. //结果如下:
    16. //abc 3 16
    17.  
    18. //unsafe.Sizeof(a): 字符串类型在 go 里是个结构, 包含指向底层数组的指针和长度,这两部分每部分都是8个字节，所以字符串类型大小为 16 个字节

    4.案例

    案例1

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6. func main()  {
    7. 	var num int
    8. 	//1.常量声明的时候,必须赋值
    9. 	const tax int = 0
    10. 	fmt.Println(num, tax)
    11. 	//2.常量不能修改
    12. 	// tax = 10
    13. 	//3.常量只能去修饰bool,数值类型(int,float系列),string类型
    14.  
    15. 	const (
    16. 		a = iota
    17. 		b 
    18. 		c
    19. 	)
    20. 	fmt.Println(a, b, c)
    21. }

    案例2

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. func main() {
    6.    const LENGTH int = 10
    7.    const WIDTH int = 5   
    8.    var area int
    9.    const a, b, c = 1, false, "str" //多重赋值
    10.  
    11.    area = LENGTH * WIDTH
    12.    fmt.Printf("面积为 : %d", area)
    13.    println()
    14.    println(a, b, c)   
    15. }
    16.  
    17. //结果如下:
    18. //面积为 : 50
    19. //1 false str

    [上一节][go学习笔记.第十五章.反射] 1.反射的基本介绍以及实践

    [下一节][go学习笔记.第十六章.TCP编程] 1.基本介绍以及入门案例 

  • 相关阅读:
    DBMS 中的 2 层架构与 3 层架构
    ChatGPT-4 VS 文心一言4.0
    服务器端文档组件
    【统计分析和过程改进】上海道宁带来Minitab软件合集，帮助企业和组织发挥数据的价值
    数据链路层——MAC帧、ARP协议详解
    使用Github Actions自动同步到Gitee仓库
    Java 21 正式 GA，虚拟线程真的来了
    对比学习系列论文COST（二）：
    TypeScript笔记：接口
    electron实现静默打印（各种踩坑解决）
  • 原文地址：https://blog.csdn.net/zhoupenghui168/article/details/127877899