Ch.06：Go里的常量与iota

变量的值可以在运行时随时改变，但有些值从定义开始他就不应该变。例如圆周率、程序版本号、一周的天数。这类值用常量来表示，Go 用 const 声明

常量的基本声明#

PRTCL // GO

1
const Pi = 3.14159
2
const AppName = "MyApp"
3
const MaxRetry = 3

常量声明之后不能修改，强行赋值会报错：

PRTCL // GO

1
const Pi = 3.14159
2
Pi = 3.14  // 报错：cannot assign to Pi

常量也可以指定类型：

PRTCL // GO

1
const Pi float64 = 3.14159
2
const MaxRetry int = 3

不指定类型的常量叫无类型常量，灵活性更高，后面会讲

多个常量可以用括号一起声明：

PRTCL // GO

1
const (
2
    AppName = "MyApp"
3
    Version = "1.0.0"
4
    MaxRetry = 3
5
)

常量和变量的区别#

常量只能是编译阶段就能确定的值，不能是运行时才能得到的结果：

PRTCL // GO

1
const now = time.Now()  // 报错，time.Now() 是运行时才能得到的值

能用作常量的值：字符串字面量、数字字面量、布尔值、以及由这些构成的表达式：

PRTCL // GO

1
const (
2
    A = 1
3
    B = 2
4
    C = A + B  // ✅ 编译阶段就能算出来
5
)

常量没有声明了必须使用的限制，这点和变量不同：

PRTCL // GO

1
const unused = 42
2
// 不使用也不报错

无类型常量#

不指定类型的常量叫无类型常量，它在被使用时才确定类型：

PRTCL // GO

1
const x = 42
2

3
var a int = x      // x 当作 int 用
4
var b float64 = x  // x 当作 float64 用
5
var c int32 = x    // x 当作 int32 用

如果 x 是有类型的常量，这样赋值就要显式转换：

PRTCL // GO

1
const x int = 42
2
var b float64 = float64(x)  // 必须转换

无类型常量的好处是灵活，不需要反复转换类型，标准库里大量使用这个特性

无类型常量有自己的默认类型，在必须确定类型的场合使用默认类型：

PRTCL // GO

1
const x = 42      // 默认类型 int
2
const f = 3.14    // 默认类型 float64
3
const s = "hello" // 默认类型 string
4
const b = true    // 默认类型 bool

iota#

iota 是常量声明里的一个特殊计数器，只能在 const 块里用

每个 const 块开始时，iota 从 0 开始，每声明一个常量自动加 1：

PRTCL // GO

1
const (
2
    A = iota  // 0
3
    B = iota  // 1
4
    C = iota  // 2
5
)

通常简写，后面的常量重复使用同一个表达式：

PRTCL // GO

1
const (
2
    A = iota  // 0
3
    B         // 1，自动复用上一行的表达式
4
    C         // 2
5
)

每次新建一个 const 块，iota 重置为 0：

PRTCL // GO

1
const (
2
    A = iota  // 0
3
    B         // 1
4
)
5

6
const (
7
    C = iota  // 0，新的 const 块，iota 重置
8
    D         // 1
9
)

iota 的实际用法#

用来定义枚举

Go 没有专门的枚举类型，用 iota 模拟：

PRTCL // GO

1
type Weekday int
2

3
const (
4
    Sunday Weekday = iota  // 0
5
    Monday                  // 1
6
    Tuesday                 // 2
7
    Wednesday               // 3
8
    Thursday                // 4
9
    Friday                  // 5
10
    Saturday                // 6
11
)

type Weekday int 定义了一个新类型，底层是 int，但类型不同，不能混用，更安全

用 _ 跳过不需要的值：

PRTCL // GO

1
const (
2
    _  = iota  // 0，跳过
3
    KB = 1 << (10 * iota)  // 1 << 10 = 1024
4
    MB                      // 1 << 20 = 1048576
5
    GB                      // 1 << 30 = 1073741824
6
    TB                      // 1 << 40
7
)

这里用位移运算来定义文件大小单位，1 << 10 是 1024，1 << 20 是 1024²，以此类推

从非零值开始

PRTCL // GO

1
const (
2
    A = iota + 1  // 1
3
    B             // 2
4
    C             // 3
5
)

iota 用在表达式里

iota 可以参与任何表达式：

PRTCL // GO

1
const (
2
    A = iota * 2  // 0
3
    B             // 2
4
    C             // 4
5
    D             // 6
6
)

iota 的坑#

中间插入非 iota 常量，计数不停

PRTCL // GO

1
const (
2
    A = iota  // 0
3
    B = 100   // 100，但 iota 此时是 1
4
    C = iota  // 2，iota 继续计数
5
)

iota 不管你中间有没有用它，这必扬的都在自己计数

iota 只能在 const 块里用

PRTCL // GO

1
var x = iota  // 报错，iota 只能在 const 里用

同一行的多个常量共用同一个 iota 值

PRTCL // GO

1
const (
2
    A, B = iota, iota + 1  // A=0, B=1，同一行 iota 都是 0
3
    C, D                    // C=1, D=2
4
)

同一行声明多个常量，iota 值相同，不会在同一行内递增

常量在实际项目里用法示例#

HTTP 状态码：

PRTCL // GO

1
const (
2
    StatusOK       = 200
3
    StatusNotFound = 404
4
    StatusError    = 500
5
)

用户角色：

PRTCL // GO

1
type Role int
2

3
const (
4
    RoleGuest Role = iota
5
    RoleUser
6
    RoleAdmin
7
)

错误码：

PRTCL // GO

1
type ErrCode int
2

3
const (
4
    ErrOK      ErrCode = 0
5
    ErrUnknown ErrCode = iota + 1000  // 从 1001 开始
6
    ErrTimeout
7
    ErrNotFound
8
)

下一篇讲类型转换，Go 不做隐式转换，所有转换必须明确写出来，strconv 包怎么用，以及转换时的常见问题

常量的基本声明#

常量和变量的区别#

无类型常量#

iota#

iota 的实际用法#

iota 的坑#

常量在实际项目里用法示例#

从0带你学Golang

Ch.06：Go里的常量与iota

Ch.08：Go的运算符

Ch.07：Go的类型转换

Ch.04：Go的基本数据类型

Ch.07：Go的类型转换