Go 语言，作为一种现代编程语言，以其简洁性和高效性赢得了开发者的青睐。在 Go 语言中，常量与变量作为存储和操作数据的基本元素，扮演着至关重要的角色。通过正确理解和使用常量与变量，开发者可以编写出更加健壮和高效的代码。本篇文章将详细介绍 Go 语言中常量和变量的定义、使用规范，以及常见的应用场景，帮助开发者更好地掌握这些核心概念。

文章目录

• • • 1、Go 语言中的常量和枚举
    • • 1.1、常量的定义
      • 1.2、常量的计算规则
      • 1.3、数字型常量
      • 1.4、并行赋值与枚举
      • 1.5、iota 枚举器
      • 2、Go 语言中的变量
      • • 2.1、变量简介
        • 2.2、值类型和引用类型
        • 2.3、打印
        • 2.4、简短形式，使用 `:=` 赋值操作符
        • 2.5、例子
        • • 2.5.1 示例1：local_scope.go
          • 2.5.2 示例2：global_scope.go

            ---

            1、Go 语言中的常量和枚举

            在 Go 语言中，常量是一种使用 const 关键字定义的不可变值。常量可以是布尔型、数字型（整数型、浮点型、复数型）和字符串型。这些值一旦设定，在程序运行时不能被修改。

            1.1、常量的定义

            常量的定义格式是 const identifier [type] = value。类型声明可以省略，因为 Go 编译器能够根据赋值来自动推断常量的类型。

            示例：

            const Pi = 3.14159 // 类型被推断为 float64
            const b string = "abc" // 显式声明类型为 string
            const b = "abc" // 隐式类型，被推断为 string
            

            1.2、常量的计算规则

            常量的值必须在编译时确定，因此任何涉及运行时计算的操作都不能用于常量的定义。内置函数（如 len()）可以用在常量表达式中，但自定义函数则不行。

            示例：

            const c1 = 2/3 // 正确，编译时可确定
            const c2 = getNumber() // 错误，getNumber() 是运行时计算的值
            

            1.3、数字型常量

            数字型常量在 Go 中是非常灵活的，它们没有固定的大小或符号，可以根据需要采用任何大小。数字常量的精度非常高，不会发生溢出。

            示例：

            const Ln2 = 0.693147180559945309417232121458176568075500134360255254120680009
            const Log2E = 1/Ln2 // 精确计算
            const Billion = 1e9 // 浮点常量
            const hardEight = (1 << 100) >> 97 // 位操作生成常量
            

            1.4、并行赋值与枚举

            Go 支持使用并行赋值声明多个常量，这在定义枚举时尤其有用。

            示例：

            const (
                Monday, Tuesday, Wednesday, Thursday, Friday, Saturday = 1, 2, 3, 4, 5, 6
            )
            const (
                Unknown = 0
                Female = 1
                Male = 2
            )
            

            1.5、iota 枚举器

            iota 是 Go 的一个特殊常量生成器，主要用于创建递增的枚举值。在一个 const 声明块中，每新增一行常量声明，iota 的值就会自动增加 1。

            示例：

            const (
                a = iota // a = 0
                b        // b = 1
                c        // c = 2
            )
            const (
                _ = iota // 忽略第一个值
                KB = 1 << (10 * iota) // 1024
                MB                    // 1048576
            )
            

            iota 也可以用于更复杂的表达式，如结合位运算符来表示资源的状态。

            总的来说，在 Go 中，常量提供了一种安全有效的方法来处理不变的数据。通过使用常量，可以减少运行时错误并提高程序的性能。正确使用 const 和 iota 可以大大增强代码的可读性和维护性。

            ---

            2、Go 语言中的变量

            2.1、变量简介

            在 Go 语言中，变量的声明一般使用 var 关键字，遵循 var identifier type 的形式。与许多编程语言不同，Go 语言在声明变量时将变量类型放在变量名之后，这种设计意在避免类似于 C 语言中可能引起混淆的声明形式（例如：int* a, b; 在这里 a 是指针而 b 不是）。在 Go 中，声明两个指针变量会更加直观：

            var a, b *int
            

            这种语法结构帮助从左到右顺序阅读代码，使得代码更易理解和维护。

            示例:

            var a int
            var b bool
            var str string
            

            或使用因式分解关键字的形式来声明：

            var (
                a   int
                b   bool
                str string
            )
            

            这种格式常用于声明全局变量。声明后，Go 系统会自动将变量初始化为其类型的零值，例如：int 的零值为 0，float32/64 为 0.0，bool 为 false，string 为空字符串，而指针则为 nil。

            变量的命名遵循骆驼命名法，例如 numShips 和 startDate。全局变量如果需要被外部包使用，首字母需大写。

            变量的作用域取决于声明的位置。全局变量（在函数体外声明）可在整个包甚至外部包中使用。局部变量仅在声明它们的函数体内有效。

            2.2、值类型和引用类型

            值类型（如 int、float、bool 和 string）的变量直接存储值本身，内存中存储值的地方直接指向该值：

            var i int = 42
            j := i // 将 i 的值拷贝给 j
            

            修改 j 不会影响 i。而引用类型（如切片、映射、通道和指针）的变量存储的是一个指向内存地址的引用。赋值和传递引用类型的变量将复制其引用，而不是复制其数据本身。

            2.3、打印

            Go 提供了 fmt 包用于格式化输出，其中 Printf 函数可以将格式化的字符串输出到控制台：

            fmt.Printf("The operating system is: %s\n", runtime.GOOS)
            

            格式化字符串支持各种占位符，允许精确地控制输出格式。

            2.4、简短形式，使用 := 赋值操作符

            在函数内部，可以使用简短声明语句 := 来初始化变量：

            a := 1
            b := false
            

            这种形式简洁且允许编译器自动推断变量的类型。这种语法只能在函数内使用，不适用于全局变量的声明。

            2.5、例子

            2.5.1 示例1：local_scope.go

            这个示例展示了如何在 Go 程序中处理局部和全局变量。以下是程序的代码：

            go
            复制代码
            package main
            var a = "G"
            func main() {
                n()
                m()
                n()
            }
            func n() { print(a) }
            func m() {
                a := "O"
                print(a)
            }
            

            在这个示例中，你将看到全局变量 a 如何与局部变量 a 在不同函数中交互。n() 函数中的 a 直接引用全局变量，而 m() 中的 a 是一个局部变量，只在 m() 函数内部有效。

            2.5.2 示例2：global_scope.go

            这个示例用于展示全局变量在函数间是如何共享的。这里是完整的代码：

            go
            复制代码
            package main
            var a = "G"
            func main() {
                n()
                m()
                n()
            }
            func n() { print(a) }
            func m() {
                a = "O"
                print(a)
            }
            

            在这个程序中，a 是一个全局变量。在 m() 函数中对 a 进行的更改将影响后续对 a 的访问，包括在 n() 函数中对 a 的再次引用。

            这两个示例有效地揭示了变量在不同作用域中的行为，强调了在 Go 中局部变量与全局变量之间的区别以及它们如何相互影响。通过这种方式，开发者可以更好地理解和掌握在复杂程序中变量的作用域和生命周期。