Go语言入门4：常量

Go 语言入门基础学习笔记之 Go 语言的常量

常量

常量定义

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式：

Copy
const identifier [type] = value

同样，在这里可以省略类型说明符 type，因为编译器会根据常量值来自动推断类型。这样就分为了显式类型定义和隐式类型定义。

多个相同类型的声明可以简写为：

Copy
const c_name1, c_name2 = value1, value2

常量还可以用作定义枚举类型：

Copy
const (
Unknown = 0
Female = 1
Male = 2
)

由于如果枚举类型很多，一个个赋值十分麻烦，于是 Go 语言提供了一个关键字 iota

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

Copy
package main

import "unsafe"
const (
a = "abc"
b = len(a)
c = unsafe.Sizeof(a)
)

func main(){
println(a, b, c)
}

// 输出结果
abc 3 16

补充：

unsafe.Sizeof(a) 返回 a 类型在内存中占用的字节数。对于字符串类型，unsafe.Sizeof() 返回的是指向字符串的内部结构的大小，而不是字符串内容的大小。

在 Go 中，字符串是一个包含两个字段的结构体：

指针：指向字符串内容的内存地址。

长度：表示字符串内容的长度（以字节为单位）。

对于一个字符串类型，该结构体通常占用 16 字节（在 64 位系统上）。具体来说：

指针：8 字节（在 64 位系统上）

长度：8 字节（在 64 位系统上）

因此，字符串的总大小为 8 + 8 = 16 字节。

iota

iota 是一个特殊常量，可以认为是一个可以被编译器修改的常量，只能出现在 const 中。可以在常量声明中用于生成一系列相关的常量值。

iota 在 const 关键字出现时将被重置为 0 (const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次 (iota 可理解为 const 语句块中的行索引)，即 iota=行数-1。

iota 可以被用作枚举值：

Copy
const (
a = iota // 0
b = iota // 1
c = iota // 2
)

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

Copy
const (
a = iota
b
c
)

注意：iota 是按行递增的，因此只要是同一行的，iota 就相同。并且接下来的 iota 公式都应该与上方最近的公式一致。比如：

Copy
const (
a, b = iota + 1, iota + 2 // iota=0 a=1 b=2
c, d // iota=1 c=iota+1 d=iota+2
e, f = iota * 2, iota * 3 // iota=2 e=4 f=6
g, h // iota=3 g=iota*2 f=iota*3
)

iota 用法

Copy
package main

import "fmt"

func main() {
const (
a = iota //0
b //1
c //2
d = "ha" //独立值，iota += 1
e //"ha" iota += 1
f = 100 //iota +=1
g //100 iota +=1
h = iota //7,恢复计数
i //8
)
fmt.Println(a,b,c,d,e,f,g,h,i)
}

// 输出结果
0 1 2 ha ha 100 100 7 8

在 Go 中，常量声明中连续的未显式赋值常量会取前一个常量的值。e 没有显式赋值，因此它会继承前一个常量 d 的值（即 "ha"）。同理，g 没有显式赋值，因此它会继承前一个常量 f 的值（即 100）。

Copy
package main

import "fmt"
const (
i=1<<iota
j=3<<iota
k
l
)

func main() {
fmt.Println("i=",i)
fmt.Println("j=",j)
fmt.Println("k=",k)
fmt.Println("l=",l)
}

// 输出结果
i= 1
j= 6
k= 12
l= 24

在上面这个实例中，iota 表示从 0 开始自动加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思，即 <<n==*(2^n)），因此 i=1、j=6、k=12、l=24。

i=1：左移 0 位，不变仍为 1。

j=3：左移 1 位，变为二进制 110，即 6。

k=3：左移 2 位，变为二进制 1100，即 12。

l=3：左移 3 位，变为二进制 11000，即 24。

参考课程：

8 小时转职 Golang 工程师

Go 语言教程 | 菜鸟教程