Go语言常量解密：恒定不变的值（const与iota）（附代码示例）

目录

常量的声明和定义

批量声明常量

完整代码示例

常量命名规则

常见的常量类型

iota

代码示例1

代码示例2

代码示例3

代码示例4

常量的使用场景

总结

---

​原文：Go语言常量解密：恒定不变的值（const与iota）（附代码示例）

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

变量和常量是编程中必不可少的部分，在公众号CTO Plus前面的文章中，我介绍到了变量（标识符）和常量的使用方法，并分别使用代码示例演示了他们的特性，具体可以参考公众号CTO Plus前面的文章《Go语言变量与标识符探秘：灵活存储数据》，下一篇将介绍下变量的作用域《Go语言变量的生命周期与作用域》。

相对于变量，Go语言中的常量是一种固定不变的值，其值在程序运行时不能被修改，多用于定义程序运行期间不会改变的那些值。常量在程序中用于存储不变的数据，例如数学常量（如PI）、固定的配置参数等。

本文我将详细介绍Go语言中常量的声明和多种定义方式、命名规则、常见的常量类型，还介绍到了iota这个常量计数器并使用4个代码示例做了详细的功能演示，最后介绍了下常量的使用场景。

​

常量的声明和定义

在Go语言中，常量的声明和变量声明非常类似，只是把var换成了const，常量在定义的时候必须赋值，其语法如下：

常量的声明使用关键字const

const 常量名 类型 = 值

例如，声明一个整数类型的常量maxAge和一个没显示指定类型的PI，这两个变量在整个程序运行期间它们的值都不能再发生变化：

const maxAge int = 100

const PI = 3.1415926

如果使用:=定义常量，则会报语法错误

const NUM := 0 // syntax error: unexpected :=, expected =

批量声明常量

多个常量也可以一起声明：

const (  BLOG   = "https://mp.weixin.qq.com/s/0yqGBPbOI6QxHqK17WxU8Q"  WECHAT = "CTO Plus") 

批量声明常量时，如果某一行没有写=，那么就和上一行一致

// const同时声明多个常量时，如果省略了值则表示和上面一行的值相同const (  maxAge = 100  age2  age3)

上面示例中，常量maxAge 、age2、age3的值都是100。

但是第一个变量必须赋值，否则编译报错

const (  num1  // missing init expr for num1  num2  num3)

使用常量的几个注意事项：

1. 定义的时候，必须指定值。

2. 指定的值类型主要有三类：布尔，数字，字符串， 其中数字类型包含（rune, integer, floating-point, complex), 它们都属于基本数据类型。

3. 不能使用 :=。

4. 常量的声明和赋值是同时进行的，因此不需要使用等号=进行赋值操作，如果使用=再次赋值则编译出错。

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

​

完整代码示例

package main
import "fmt"
/*1. 定义的时候，必须指定值2. 指定的值类型主要有三类： 布尔，数字，字符串， 其中数字类型包含（rune, integer, floating-point, complex), 它们都属于基本数据类型。3. 不能使用 :=*/func constVar() {  const maxAge int = 100  const PI = 3.1415926
  fmt.Println(maxAge)  //maxAge = 0  // cannot assign to maxAge (constant 100 of type int)
  const num = 1234  // num = 123 //erro   cannot assign to num (untyped int constant 1234)
  const (    num1 = 1000    num2 = 2.222  )  // num1 = 123 // error   cannot assign to num1  fmt.Println(num, num1+num2)}
// 全局常量 多个常量一起声明const (  BLOG   = "https://mp.weixin.qq.com/s/0yqGBPbOI6QxHqK17WxU8Q"  WECHAT = "CTO Plus")
// const同时声明多个常量时，如果省略了值则表示和上面一行的值相同const (  maxAge = 100  age2  age3)
func main() {  constVar()  fmt.Println(BLOG)               // https://mp.weixin.qq.com/s/0yqGBPbOI6QxHqK17WxU8Q  fmt.Println(WECHAT)             // CTO Plus  fmt.Println(maxAge, age2, age3) // CTO Plus}

常量命名规则

在Go语言中，常量的命名需要遵循一些规则：

• 常量名由字母、数字、下划线组成，且必须以字母或下划线开头。

• 常量名区分大小写，maxAge和MaxAge是不同的常量。

• 避免使用Go语言的关键字作为常量名，如if、for等。

• 常量名应该具有描述性，能够清晰地表达常量的含义。

一般而言，Go语言的命名风格采用驼峰命名法，即首字母小写，后续单词首字母大写，例如maxAge、piValue。

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

​

常见的常量类型

Go语言提供了多种常量类型，常见的常量类型包括：

• 整数类型：int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64等。

• 浮点数类型：float32、float64。

• 布尔类型：bool，取值为true或false。

• 字符串类型：string。

• 字符类型：byte，用于表示ASCII字符。

除了基本的数据类型，Go语言还提供了复合类型的常量，如数组、切片、映射、结构体等，用于存储多个值或不同类型的值。

接下来我们来介绍下跟常量有关的另一个关键字iota

iota

在Go语言中，iota是一个特殊的常量，它可以被用作枚举值的自增计数器（常量计数器），只能在常量的表达式中使用。iota在每个const关键字出现时被重置为0，并且每出现一次iota，它的值就会自增1（iota可理解为const语句块中的行索引）。

代码示例1

使用iota能简化定义，在定义枚举时很有用，下面是一些iota的用法示例：

​

在上面的示例中，Monday的值为iota + 1，即1。Tuesday的值为iota + 1，即2。以此类推，每个常量的值都会根据iota的自增规则进行计算。

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

​

代码示例2

iota还可以用于定义一组相关的常量，每个常量的值都是前一个常量的2倍。下面是一个示例：

package main
import "fmt"
func iotaFunc2() {  const (    KB = 1 << (10 * iota) // 1左移10位，即1024    MB                    // 1左移20位，即1024*1024    GB                    // 1左移30位，即1024*1024*1024    TB                    // 1左移40位，即1024*1024*1024*1024  )
  fmt.Println(KB) // 输出：1  fmt.Println(MB) // 输出：1024  fmt.Println(GB) // 输出：1048576  fmt.Println(TB) // 输出：1073741824}

在上面的示例中，KB的值为1 << (10 * iota)，即1左移10位，也就是由1变成了10000000000，即1024。MB的值为1 << (10 * iota)，即1左移20位，即1024*1024。以此类推，每个常量的值都是前一个常量的2倍。

代码示例3

iota还可以用于位运算，例如定义一组权限常量：

package main
import "fmt"
const (    ReadPermission = 1 << iota // 1左移0位，即1    WritePermission            // 1左移1位，即2    ExecutePermission          // 1左移2位，即4)
func main() {    var permission int = ReadPermission | WritePermission
    fmt.Println(permission&ReadPermission == ReadPermission)     // 输出：true    fmt.Println(permission&WritePermission == WritePermission)   // 输出：true    fmt.Println(permission&ExecutePermission == ExecutePermission) // 输出：false}

在上面的示例中，ReadPermission的值为1 << iota，即1左移0位，即1。WritePermission的值为1 << iota，即1左移1位，即2。以此类推，每个常量的值都是前一个常量的2倍。最后，我们可以使用位运算来判断某个权限是否被设置。

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

​

代码示例4

结合_跳过某些值，iota的插队定义，iota定义在多行的使用示例

func iotafFunc4() {  //使用_跳过某些值  const (    num1 = iota    _    // _也占了一行，所以_的值相当于是1    num3    _    num5  )  // 此处又重新了const  跳跃iota的赋值  const (    num6 = iota    num7       // num6=iota，所以num6的值为0；num7没有= 所以值递推为1    num8 = 123 //  因为num8=123，而num9没有=，所以和num9的值保持一致都是123    num9    num10 = iota    num11  )  fmt.Println(num1, num3, num5, num6, num7, num8, num9, num10, num11) // 0 2 4 0 1 123 123 4 5
  //多个iota定义在一行  const (    n1, n2 = iota + 1, iota + 2    n3, n4    n5, n6    n7, n8    // n9, n10, n11  错误用法，每行变量的个数必须跟第一排保持一致    // n9, n10, n11, n12 //missing init expr for n11  )  fmt.Println(n1, n2, n3, n4, n5, n6, n7, n8) // 1 2 2 3 3 4 4 5
  const (    n11, n12 = iota + 1, iota + 1    n13, n14 = iota + 1, iota + 1  )  fmt.Println(n11, n12, n13, n14) // 1 1 2 2}

常量的使用场景

常量在程序中用于存储不变的数据，常见的使用场景包括：

• 数学常量：例如圆周率π、自然对数的底数e等。

• 固定的配置参数：例如数据库连接字符串、API密钥等。

• 枚举类型：将一组相关的常量定义为枚举类型，用于表示一组固定的取值。

常量的使用可以提高程序的可读性和可维护性，避免在程序中使用魔法数值，使程序更加清晰和易于理解。

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

​

总结

总的来说，Go语言中的常量是一种固定不变的值，用于存储不变的数据。定义常量使用const关键字，定义之后不能修改，不能再次赋值，在程序运行期间不会改变，常量的命名需要遵循一定的规则。

• 常量类型包括整数类型、浮点数类型、布尔类型、字符串类型等。常量的使用场景包括数学常量、固定的配置参数、枚举类型等。

• iota是一个特殊的常量，用作枚举值的自增计数器。

• iota在每个const关键字出现时被重置为0，并且每出现一次iota，它的值就会自增1。

• iota可以用于定义一组相关的常量，每个常量的值都是前一个常量的2倍。

• iota还可以用于位运算，例如定义一组权限常量。

通过合理使用常量，可以提高程序的可读性和可维护性。

更多精彩，关注我公号，一起学习、成长

​

​

推荐阅读：

• 开源项目 | 17款云原生安全相关的扫描和平台类开源工具

• Go语言常量解密：恒定不变的值（const与iota）（附代码示例）
  深入了解Go语言的数据类型

• 使用strconv进行Go的 int、float、string类型相互转换：灵活转换数据类型

• Go语言变量的生命周期与作用域

• Go中字符串的遍历技巧：轻松操作文本

• Go语言字符串操作大揭秘：高效处理文本

• Go的流程控制（if、for、switch、goto）全面解析与刨坑

• Go的多端开发环境与编译器的搭建详解（图文）

• Go语言的高级特性，发展趋势，以及推荐最热门的开源项目