6 Go语言的常量、枚举、作用域

本专栏将从基础开始，循序渐进，由浅入深讲解Go语言，希望大家都能够从中有所收获，也请大家多多支持。
查看相关资料与知识库
专栏地址:Go专栏
如果文章知识点有错误的地方，请指正！大家一起学习，一起进步。

常量

常量类似于变量，但其初始值不能更改。在需要代码运行时保持不变的值的情况下，使用常量非常有用。虽然可以将这些值硬编码到代码中以实现类似效果，但经验表明，虽然这些值在运行时不需要更改，但将来可能需要更改。如果发生这种情况，追踪和修复所有硬编码的值可能是一项繁琐且容易出错的任务。使用常量可以节省大量的后续维护工作。

常量声明类似于 var 语句。定义常量时，必须指定初始值。类型是可选的，如果省略，类型将会被推断。初始值可以是文字值或简单的表达式，并且可以使用其他常量的值。与 var 一样，可以在一个语句中声明多个常量。以下是常量声明的语法：

const <name> <type> = <value>
const (<name1> <type1> = <value1><name2> <type2> = <value2>…<nameN> <typeN> = <valueN>
)

练习 1.16 – 常量

在这个练习中，我们遇到了一个性能问题：我们的数据库服务器太慢了。我们将创建一个自定义内存缓存。我们会使用 Go 的 map 集合类型作为缓存。缓存中可以存储的项目数量有一个全局限制。我们将使用一个 map 来帮助跟踪缓存中的项目数量。我们需要缓存两种类型的数据：书籍和 CD。两者都使用 ID，因此我们需要一种方法来区分共享缓存中的两种类型的项目。我们需要一种方法来设置和获取缓存中的项目。

我们将设置缓存中的最大项目数量。我们还将使用常量添加前缀，以区分书籍和 CD。让我们开始吧：

1. 创建一个新的文件夹，并在其中添加一个 main.go 文件。

2. 在 main.go 文件的顶部添加 main 包名：

   package main
   

3. 导入我们需要的包：

   import "fmt"
   

4. 创建一个表示全局限制大小的常量：

   const GlobalLimit = 100
   

5. 创建一个 MaxCacheSize 常量，它是全局限制大小的 10 倍：

   const MaxCacheSize int = 10 * GlobalLimit
   

6. 创建我们的缓存前缀：

   const (CacheKeyBook = "book_"CacheKeyCD = "cd_"
   )
   

7. 声明一个 map 类型的变量，用于存储缓存，其中键和值都是字符串类型：

   var cache map[string]string
   

8. 创建一个从缓存中获取项目的函数：

   func cacheGet(key string) string {return cache[key]
   }
   

9. 创建一个在缓存中设置项目的函数：

   func cacheSet(key, val string) {
   

10. 在这个函数中，检查 MaxCacheSize 常量，防止缓存超过这个大小：

      if len(cache)+1 >= MaxCacheSize {return}cache[key] = val
    }
    

11. 创建一个从缓存中获取书籍的函数：

    func GetBook(isbn string) string {
    

12. 使用书籍缓存前缀创建一个唯一的键：

      return cacheGet(CacheKeyBook + isbn)
    }
    

13. 创建一个将书籍添加到缓存中的函数：

    func SetBook(isbn string, name string) {
    

14. 使用书籍缓存前缀创建一个唯一的键：

      cacheSet(CacheKeyBook+isbn, name)
    }
    

15. 创建一个从缓存中获取 CD 数据的函数：

    func GetCD(sku string) string {
    

16. 使用 CD 缓存前缀创建一个唯一的键：

      return cacheGet(CacheKeyCD + sku)
    }
    

17. 创建一个将 CD 添加到共享缓存中的函数：

    func SetCD(sku string, title string) {
    

18. 使用 CD 缓存前缀常量为共享缓存构建一个唯一的键：

      cacheSet(CacheKeyCD+sku, title)
    }
    

19. 创建 main() 函数：

    func main() {
    

20. 通过创建一个 map 值来初始化缓存：

      cache = make(map[string]string)
    }
    

21. 将一本书添加到缓存中：

      SetBook("1234-5678", "Get Ready To Go")
    

22. 将 CD 添加到缓存中：

      SetCD("1234-5678", "Get Ready To Go Audio Book")
    

23. 从缓存中获取并打印那本书：

      fmt.Println("Book :", GetBook("1234-5678"))
    

24. 从缓存中获取并打印那张 CD：

      fmt.Println("CD :", GetCD("1234-5678"))
    

25. 关闭 main() 函数：

    }
    

26. 保存文件。然后，在新文件夹中运行：

    go run .
    

预期输出

在这个练习中，我们使用常量来定义在代码运行时不需要更改的值。我们用不同的语法选项声明了常量，有的指定了类型，有的则没有。我们既声明了单个常量，也在一个语句中声明了多个常量。

接下来，我们将查看与常量相关的变体，用于更紧密关联的值。

枚举

枚举是一种定义固定值列表的方式，这些值都是相关的。虽然 Go 语言没有内置的枚举类型，但它提供了 iota 工具，让我们可以使用常量定义自己的枚举。接下来，我们将探讨如何使用 iota 来实现枚举。

例如，在以下代码中，我们将一周的天数定义为常量。这个代码很适合使用 Go 的 iota 特性：

…
const (Sunday  = 0Monday  = 1Tuesday = 2Wednesday = 3Thursday = 4Friday  = 5Saturday = 6
)
…

使用 iota，Go 会帮助我们管理这样的列表。使用 iota，以下代码等同于上面的代码：

…
const (Sunday = iotaMondayTuesdayWednesdayThursdayFridaySaturday
)
…

通过 iota，我们可以自动为枚举分配值。使用 iota 使得创建和维护枚举更加方便，特别是在你需要在代码中间添加新值时。iota 是一个标识符，指示 Go 编译器从 0 开始为第一个值分配，后续值每次递增 1。在使用 iota 时，顺序是重要的。iota 还允许跳过值（使用 _），从不同的偏移量开始，甚至使用更复杂的计算。

接下来，我们将详细了解 Go 的变量作用域规则以及这些规则如何影响代码编写。

作用域

在 Go 中，所有变量都存在于一个作用域中。顶级作用域是包作用域。作用域可以包含子作用域。定义子作用域的方式有几种；最简单的理解方式是，当你看到 { 时，表示你开始了一个新的子作用域，而这个子作用域在遇到匹配的 } 时结束。父子关系是在代码编译时定义的，而不是在代码运行时。当访问变量时，Go 会查看变量定义的作用域。如果在当前作用域找不到该变量，Go 会查看父作用域，然后是祖父作用域，一直到包作用域。当找到匹配的变量时，Go 会停止查找。如果没有找到匹配的变量，则会报错。

换句话说，当你的代码使用一个变量时，Go 需要确定该变量的定义位置。它从当前代码的作用域开始查找。如果在该作用域内找到一个变量定义，则停止查找并使用该变量定义。如果找不到变量定义，则开始向上遍历作用域栈，直到找到具有该名称的变量。这个查找过程基于变量名称。如果找到的变量名称匹配但类型不正确，Go 会抛出错误。

在以下示例中，我们定义了一个 level 变量。无论在哪里使用 level，都会使用同一个变量：

package main
import "fmt"
var level = "pkg"
func main() {fmt.Println("Main start :", level)if true {fmt.Println("Block start :", level)funcA()}
}
func funcA() {fmt.Println("funcA start :", level)
}

输出结果如下：

Main start : pkg
Block start : pkg
funcA start : pkg

在这个示例中，我们创建了一个 level 的影子变量。这个新的 level 变量与包作用域中的 level 变量没有关系。当我们在块内打印 level 时，Go 运行时会在 main 的作用域中找到 level 变量，并停止查找。这导致新变量覆盖了包变量。你也可以看到它是一个不同的变量，因为它的类型不同，变量在 Go 中不能改变类型：

package main
import "fmt"
var level = "pkg"
func main() {fmt.Println("Main start :", level)// 创建一个影子变量level := 42if true {fmt.Println("Block start :", level)funcA()}fmt.Println("Main end :", level)
}
func funcA() {fmt.Println("funcA start :", level)
}

输出结果如下：

Main start : pkg
Block start : 42
funcA start : pkg
Main end : 42

Go 的静态作用域解析在调用 funcA 时发挥作用。因此，当 funcA 运行时，它仍然看到包作用域中的 level 变量。作用域解析不考虑 funcA 的调用位置。

你不能访问子作用域中定义的变量：

package main
import "fmt"
func main() {{level := "Nest 1"fmt.Println("Block end :", level)}// 错误：未定义: level//fmt.Println("Main end  :", level)
}