Go 常量基础

GolangGolangBeginner
立即练习

💡 本教程由 AI 辅助翻译自英文原版。如需查看原文,您可以 切换至英文原版

介绍

在前面的课程中,我们学习了 Go 语言中的变量。在本节课中,我们将探讨常量的概念、如何使用它们以及它们的重要性。让我们深入常量的世界。

知识点:

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

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL go(("`Golang`")) -.-> go/BasicsGroup(["`Basics`"]) go/BasicsGroup -.-> go/values("`Values`") go/BasicsGroup -.-> go/constants("`Constants`") go/BasicsGroup -.-> go/variables("`Variables`") subgraph Lab Skills go/values -.-> lab-149070{{"`Go 常量基础`"}} go/constants -.-> lab-149070{{"`Go 常量基础`"}} go/variables -.-> lab-149070{{"`Go 常量基础`"}} end

什么是常量?

简单来说,常量是一个在程序执行期间被声明且不能被修改的值。常量允许编译器在程序执行之前(即编译阶段)知道它们的值。

常量声明时可以为其分配特定的值。它们的语法与变量类似,但一旦声明了常量的值,就无法更改。

当你需要声明一个不应更改的值时,常量非常有用,例如网站地址或像 π 这样具有特定意义的值。

声明常量

常量的声明与变量的声明类似,关键字 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" // 显式指定类型为 string
const labs = "LABS"    // 编译器自动推断为 string

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

func main() {
    fmt.Printf("labex 的类型是: %T, 其值为 %s\n", labex, labex)
    fmt.Printf("labs 的类型是: %T, 其值为 %s\n", labs, labs)

    fmt.Println()

    fmt.Println(hangzhou, chengdu)
    fmt.Println(monday, tuesday, wednesday)
}
go run ~/project/const.go

运行程序后,输出如下:

labex 的类型是: string, 其值为 LabEx
labs 的类型是: string, 其值为 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

在这里,thursdayfriday 没有显式赋值。根据 Go 的规则,当常量未显式初始化时,它会继承前一个常量的值。在这种情况下:

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

这种行为可以使代码更简洁,但如果你不了解这一点,可能会导致意外的结果。

如果你希望 thursdayfriday 具有不同的值,需要显式地为它们赋值:

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 和左移运算符 << 来表示 1 KB1 MB 的值。例如,1 KB 等于 1024B,而 1 MB 等于 1024 * 1024,即 1048576B

测验

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

要求:

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

提示: 你可以参考 "iota" 部分的代码。

所需的输出格式如下:

1GB is equal to 1073741824B
1TB is equal to 1099511627776B
✨ 查看解决方案并练习

总结

让我们回顾一下本节课学到的内容:

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

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

您可能感兴趣的其他 Golang 教程