Go 常量基础

介绍

在之前的课程中，我们学习了 Go 语言中的变量。在本实验中，我们将探索常量的概念、使用方法以及它们的重要性。让我们一起深入了解常量的世界。

知识点：

• 什么是常量
• 声明常量
• iota 常量生成器
• 常量的使用

什么是常量？

简单来说，常量是在程序执行期间声明后且无法修改的值。常量允许编译器在程序执行前的编译阶段就确定它们的值。

常量声明可以被赋予特定的值。它们的语法与变量类似，但一旦声明了常量值，就不能再更改。

当你想要声明一个不应该改变的值时，常量非常有用，例如网站地址或具有特定含义的数值（如 π）。

声明常量

常量的声明与变量类似。只需将关键字 var 替换为关键字 const 即可。

注意：常量在声明时必须赋值。

在 Go 中，所有变量在定义后必须被使用，但常量是个例外。即使定义了常量却不使用，也不会产生编译错误。

声明常量的语法如下：

const name [type] = value

name 是要声明的常量名称。type 是常量的数据类型，但可以省略，因为 Go 可以自动进行类型推断。末尾的 value 是分配给常量的值。

请注意，只有以下类型可以用于常量声明：

• 整数类型
• 浮点类型
• 复数类型
• 布尔类型
• 字符串类型

让我们看一个例子。在 ~/project 目录下创建一个名为 const.go 的新文件：

touch ~/project/const.go

在 const.go 中输入以下代码：

package main

import "fmt"

// 声明单个常量
const labex string = "LabEx" // 显式指定类型为字符串
const labs = "LABS"    // 由编译器自动推断为字符串

// 声明多个常量
const (
    hangzhou, chengdu = "HANGZHOU", "CHENGDU"
    monday, tuesday, wednesday = "MONDAY", "TUESDAY", "WEDNESDAY"
)

func main() {
    fmt.Printf("The type of labex is: %T, and its value is %s\n", labex, labex)
    fmt.Printf("The type of labs is: %T, and its value is %s\n", labs, labs)

    fmt.Println()

    fmt.Println(hangzhou, chengdu)
    fmt.Println(monday, tuesday, wednesday)
}

go run ~/project/const.go

运行程序后，输出如下：

The type of labex is: string, and its value is LabEx
The type of labs is: string, and its value is LABS

HANGZHOU CHENGDU
MONDAY TUESDAY WEDNESDAY

在这里，我们演示了单个和多个常量的声明。在声明多个常量时，建议使用括号。

在程序中，我们仅演示了字符串常量的声明。然而，常量也可以是其他类型，如整数和布尔值。

当使用括号声明多个常量时，如果某个常量没有初始化，它将继承前一个常量的值。

在 const.go 中输入以下代码：

package main

import "fmt"

const (
    monday    = "MONDAY"
    tuesday   = "TUESDAY"
    wednesday = "WEDNESDAY"
    thursday
    friday
)

func main() {
    fmt.Println(monday, tuesday, wednesday, thursday, friday)
}

go run ~/project/const.go

输出如下：

MONDAY TUESDAY WEDNESDAY WEDNESDAY WEDNESDAY

在这里，thursday 和 friday 没有显式赋值。根据 Go 的规则，当常量没有显式初始化时，它会继承前一个常量的值。在这种情况下：

• thursday 继承了 wednesday 的值。
• friday 也继承了 wednesday 的值。

这种特性可以使代码更简洁，但如果你不了解它，可能会导致意外的结果。

如果你希望 thursday 和 friday 拥有不同的值，你需要显式地为它们赋值：

const (
    monday    = "MONDAY"
    tuesday   = "TUESDAY"
    wednesday = "WEDNESDAY"
    thursday  = "THURSDAY"
    friday    = "FRIDAY"
)

这将产生预期的输出：

MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY

iota 常量生成器

除了逐个声明常量外，我们还可以使用 iota 进行批量声明。让我们看一个例子。在 const.go 文件中编写以下代码：

package main

import "fmt"

const (
    monday    = iota // 初始值为 0
    tuesday   = iota // 每次递增 1
    wednesday = iota
    thursday  = iota
    friday    = iota
)

func main() {
    fmt.Println(monday, tuesday, wednesday, thursday, friday)
}

go run ~/project/const.go

输出如下：

0 1 2 3 4

使用 iota 时，初始值为 0，后续每个项目都会递增 1。

在声明第一个项目后，后续常量不需要再显式使用 iota 赋值。以下代码也能正常运行：

package main

import "fmt"

const (
    monday    = iota // 0
    tuesday          // 1
    wednesday        // 2
    thursday         // 3
    friday           // 4
)

func main() {
    fmt.Println(monday, tuesday, wednesday, thursday, friday)
}

如果我们想跳过某个特定的值怎么办？在这种情况下，我们可以使用下划线。以下代码跳过了周三对应的常量：

package main

import "fmt"

const (
    monday  = iota // 0
    tuesday        // 1
    _
    thursday // 3
    friday   // 4
)

func main() {
    fmt.Println(monday, tuesday, thursday, friday)
}

go run ~/project/const.go

如你所见，输出如下：

0 1 3 4

iota 运算符还可以用于算术运算。在 const.go 中输入以下代码：

package main

import "fmt"

const (
    a = iota     // 0
    b = iota * 3 // 1 * 3
    c = iota + 4 // 2 + 4
)

const (
    B  = 1 << (iota * 10) // 等于 1 << (0 * 10)
    KB                    // 1024
    MB                    // 1048576
)

func main() {
    fmt.Println(a, b, c)
    fmt.Println(B, KB, MB)
}

go run ~/project/const.go

输出如下：

0 3 6
1 1024 1048576

在第一组常量声明中，我们使用 iota 执行了简单的算术运算。

在第二组中，我们将 iota 与左移运算符 << 结合使用，以 B 为单位表示 1 KB 和 1 MB 的值。例如，1 KB 等于 1024B，而 1 MB 等于 1024 * 1024，即 1048576B。

挑战

现在让我们巩固所学知识。创建一个名为 iota.go 的新文件，并使用 iota 和常量以 B 为单位输出 1GB 和 1TB 的值。

要求：

1. 不要直接输出转换后的数字。请使用 iota 进行换算。
2. iota.go 文件应位于 ~/project 目录下。

提示： 你可以参考「iota」章节中的代码。

要求的输出格式如下：

1GB is equal to 1073741824B
1TB is equal to 1099511627776B

总结

让我们回顾一下本实验学到的内容：

• 常量在声明后不能被修改。
• 可以使用 const 关键字声明常量。
• 声明多个常量时，优先使用括号。
• iota 常量生成器可用于枚举声明。
• iota 也可以用于算术运算。

在本实验中，我们学习了常量，并介绍了 iota 常量生成器。字符串、整数、浮点数和常量是 Go 语言中最基本的数据类型。