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。让我们开始吧：

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

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

package main

导入我们需要的包：

import "fmt"

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

const GlobalLimit = 100

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

const MaxCacheSize int = 10 * GlobalLimit

创建我们的缓存前缀：

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

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

var cache map[string]string

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

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

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

func cacheSet(key, val string) {

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

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

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

func GetBook(isbn string) string {

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

  return cacheGet(CacheKeyBook + isbn)
}

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

func SetBook(isbn string, name string) {

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

  cacheSet(CacheKeyBook+isbn, name)
}

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

func GetCD(sku string) string {

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

  cacheSet(CacheKeyCD+sku, title)
}

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

func SetCD(sku string, title string) {

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

  cacheSet(CacheKeyCD+sku, title)
}

创建 main() 函数：

func main() {

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

  cache = make(map[string]string)
}

将一本书添加到缓存中：

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

将 CD 添加到缓存中：

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

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

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

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

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

关闭 main() 函数：

}

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

go run .

预期输出

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

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

枚举

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

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

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

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

…
const (
  Sunday = iota
  Monday
  Tuesday
  Wednesday
  Thursday
  Friday
  Saturday
)
…

通过 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 := 42
  if 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)
}

到此这篇关于Go语言的常量、枚举、作用域的文章就介绍到这了,更多相关Go语言的常量枚举作用域内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！