第一章：Go语言基础入门之变量、常量与基本数据类型

Go 语言基础：变量、常量与基本数据类型深度解析

Go 语言以其简洁、高效和并发特性在现代软件开发中占据一席之地。对于任何一门编程语言，理解其如何处理数据是迈向精通的第一步。本文将深入探讨 Go 语言中数据存储的基石：变量、常量以及内置的基本数据类型。

我们将详细介绍变量的两种声明方式 (var 和 :=)，常量的定义与特殊用法 (const 和 iota)，并逐一剖析 int, float64, bool, string 等基本数据类型，以及 Go 语言中一个重要概念——零值。

一、变量 (Variables)：数据的容器

变量是程序中用于存储数据的命名存储区域。在 Go 语言中，变量的声明方式有两种：使用 var 关键字和使用短变量声明 :=。

1. 使用 var 关键字声明变量

var 关键字是 Go 语言中最常见的变量声明方式，可以用于包级别（全局）或函数内部。

a. 声明变量并指定类型 (不初始化)

当只声明变量而不进行初始化时，Go 语言会自动为变量赋其对应类型的零值 (zero value)。这是 Go 语言的一个重要特性，可以避免未初始化变量的运行时错误。

package main

import "fmt"

func main() {
    var age int      // 声明一个名为 age 的 int 类型变量
    var name string  // 声明一个名为 name 的 string 类型变量
    var isStudent bool // 声明一个名为 isStudent 的 bool 类型变量
    var price float64 // 声明一个名为 price 的 float64 类型变量

    fmt.Printf("age 的零值: %d\n", age)         // 输出: age 的零值: 0
    fmt.Printf("name 的零值: '%s'\n", name)     // 输出: name 的零值: '' (空字符串)
    fmt.Printf("isStudent 的零值: %t\n", isStudent) // 输出: isStudent 的零值: false
    fmt.Printf("price 的零值: %.2f\n", price)   // 输出: price 的零值: 0.00
}

零值规则：

• 数值类型 (int, float 等): 0
• 布尔类型 (bool): false
• 字符串类型 (string): "" (空字符串)
• 派生类型 (如切片、映射、通道、指针等): nil

b. 声明变量并初始化

你可以在声明的同时为变量赋初始值。

package main

import "fmt"

func main() {
    var count int = 100         // 声明并初始化一个 int 变量
    var message string = "Hello, Go!" // 声明并初始化一个 string 变量

    fmt.Println("count:", count)
    fmt.Println("message:", message)
}

c. 类型推断 (Type Inference)

Go 语言具有强大的类型推断能力。当你声明变量并初始化时，如果省略类型，Go 编译器会根据初始值自动推断变量的类型。

package main

import "fmt"

func main() {
    var quantity = 50        // quantity 被推断为 int 类型
    var greeting = "你好，世界" // greeting 被推断为 string 类型
    var isActive = true      // isActive 被推断为 bool 类型
    var ratio = 3.14         // ratio 被推断为 float64 类型

    fmt.Printf("quantity 的类型是 %T, 值为 %v\n", quantity, quantity)
    fmt.Printf("greeting 的类型是 %T, 值为 %v\n", greeting, greeting)
    fmt.Printf("isActive 的类型是 %T, 值为 %v\n", isActive, isActive)
    fmt.Printf("ratio 的类型是 %T, 值为 %v\n", ratio, ratio)
}

d. 批量声明

当需要声明多个变量时，可以使用圆括号 () 进行批量声明，使代码更加整洁。

package main

import "fmt"

func main() {
    var (
        firstName string = "John"
        lastName  string = "Doe"
        age       int    = 25
        salary    float64 // 未初始化，零值为 0.0
    )

    fmt.Println("姓名:", firstName, lastName)
    fmt.Println("年龄:", age)
    fmt.Println("薪水:", salary)
}

2. 短变量声明 :=

短变量声明 := 是 Go 语言中最常用的变量声明方式，它结合了变量声明和初始化的过程，并且强制进行类型推断。

a. 声明与初始化

package main

import "fmt"

func main() {
    name := "Alice" // 声明并初始化 string 类型的 name 变量
    score := 95     // 声明并初始化 int 类型的 score 变量
    isValid := true // 声明并初始化 bool 类型的 isValid 变量

    fmt.Println("Name:", name)
    fmt.Println("Score:", score)
    fmt.Println("IsValid:", isValid)
}

b. 适用范围

:= 只能在函数内部使用。在函数外部（包级别）声明变量，必须使用 var 关键字。

// package-level (global) variable
var GlobalCount = 100 // 必须使用 var

func main() {
    localCount := 50 // 可以使用 :=
}

c. 多变量声明与赋值

:= 也支持同时声明和初始化多个变量。

package main

import "fmt"

func main() {
    x, y := 10, 20      // x 为 int, y 为 int
    message, err := "Success", nil // message 为 string, err 为 error 类型 (此处为 nil)

    fmt.Println("x:", x, "y:", y)
    fmt.Println("message:", message, "error:", err)
}

d. 重新声明规则

:= 要求等号左边至少有一个新声明的变量。如果所有变量都已经声明过，那么 := 会导致编译错误。但有一个特例：如果多变量赋值中，至少有一个变量是新声明的，而其他变量是已声明的，那么也是合法的。

package main

import "fmt"

func main() {
    count := 10 // count 是新声明的

    // count := 20 // 错误: no new variables on left side of := (count 已经声明过了)

    name, age := "Bob", 30 // name 和 age 都是新声明的

    // 允许的特例：y 是新变量，x 是旧变量，但 := 仍然可以使用
    x := 1
    x, y := 2, 3 // x 被重新赋值为 2，y 是新声明的变量 3
    fmt.Println("x:", x, "y:", y) // 输出: x: 2 y: 3
}

3. var vs. := 总结

最佳实践：

• 在函数内部，如果变量需要声明并立即初始化，优先使用 :=，因为它更简洁。
• 在包级别（函数外部）或你需要明确指定变量类型而不立即初始化时，使用 var。

二、常量 (Constants)：不可变的值

常量是程序中固定不变的值。它们在编译时就已经确定，并且在程序的整个生命周期中都不能被修改。在 Go 语言中，使用 const 关键字来定义常量。

1. 定义常量

常量可以像变量一样单独定义，也可以批量定义。

package main

import "fmt"

func main() {
    const Pi = 3.14159 // 声明一个浮点型常量
    const Greeting string = "Hello" // 声明一个字符串常量并显式指定类型

    fmt.Println("圆周率:", Pi)
    fmt.Println("问候语:", Greeting)

    // Pi = 3.14 // 错误：不能修改常量
}

常量特性：

• 常量可以是字符、字符串、布尔或数值类型。
• 常量在定义时必须初始化。
• 常量不能使用 := 语法声明。
• 常量不能是函数调用的结果，它们必须是编译时可确定的值。

2. 常量的类型推断与无类型常量 (Untyped Constants)

与变量类似，常量在声明时如果省略类型，Go 也会进行类型推断。但 Go 语言的常量有一个非常特殊的概念叫做“无类型常量”（或称“未指定类型的常量”）。

无类型常量并没有一个固定的类型，它只是一系列数字，Go 会在需要时将其转换为适当的类型。这使得常量在表达式中非常灵活。

package main

import "fmt"

const A = 100 // A 是一个无类型整数常量
const B = 3.14 // B 是一个无类型浮点数常量

func main() {
    var intVar int = A        // A 被隐式转换为 int
    var floatVar float64 = A  // A 被隐式转换为 float64
    var complexVar complex128 = A // A 被隐式转换为 complex128
    fmt.Printf("intVar: %T %v\n", intVar, intVar)
    fmt.Printf("floatVar: %T %v\n", floatVar, floatVar)
    fmt.Printf("complexVar: %T %v\n", complexVar, complexVar)

    var f32 float32 = B // B 被隐式转换为 float32
    fmt.Printf("f32: %T %v\n", f32, f32)
}

当一个无类型常量被赋值给一个变量或者在需要特定类型的表达式中使用时，它会自动转换为所需的类型。

3. iota 常量生成器

iota 是 Go 语言中一个预声明的标识符，它用在 const 声明语句中，表示递增的无类型整数序列。iota 的值从 0 开始，每当 const 关键字出现时，iota 的值就会重置为 0，并在同一 const 块中每声明一个常量，iota 的值就会递增 1。

a. 基本用法

package main

import "fmt"

func main() {
    const (
        _ = iota // _ 用于跳过第一个 0 值，或作为占位符
        KB       // KB = 1
        MB       // MB = 2
        GB       // GB = 3
    )
    fmt.Println("KB:", KB) // 输出: KB: 1
    fmt.Println("MB:", MB) // 输出: MB: 2
    fmt.Println("GB:", GB) // 输出: GB: 3

    const (
        Monday = iota + 1 // Monday = 1 (iota = 0 + 1)
        Tuesday           // Tuesday = 2 (iota = 1 + 1)
        Wednesday         // Wednesday = 3 (iota = 2 + 1)
    )
    fmt.Println("Monday:", Monday)
    fmt.Println("Tuesday:", Tuesday)
    fmt.Println("Wednesday:", Wednesday)
}

b. 结合位移运算

iota 结合位移运算 (<<) 常常用于定义与存储单位相关的常量。

package main

import "fmt"

const (
    // iota 在每个 const 块开始时重置为 0
    _        = iota             // iota = 0, 忽略此值
    KB float664 = 1 << (10 * iota) // iota = 1, KB = 1 << 10 (1024)
    MB                          // iota = 2, MB = 1 << 20 (1024 * 1024)
    GB                          // iota = 3, GB = 1 << 30
    TB                          // iota = 4, TB = 1 << 40
)

func main() {
    fmt.Printf("KB: %d Bytes\n", KB)
    fmt.Printf("MB: %d Bytes\n", MB)
    fmt.Printf("GB: %d Bytes\n", GB)
    fmt.Printf("TB: %d Bytes\n", TB)
}

三、基本数据类型 (Basic Data Types)

Go 语言提供了丰富且严谨的内置基本数据类型，确保类型安全和内存效率。

1. 整数类型 (Integer Types)

Go 语言支持有符号整数和无符号整数，并且提供多种位宽选择。

• 有符号整数: int8, int16, int32 (rune), int64
  • 范围从 -(2^(n-1)) 到 2^(n-1) - 1。
• 无符号整数: uint8 (byte), uint16, uint32, uint64
  • 范围从 0 到 2^n - 1。
• int 和 uint:
  • 它们是平台相关的整数类型，其大小通常与 CPU 的字长一致（32 位或 64 位）。在大多数现代系统中，int 和 uint 都是 64 位的。
  • 推荐使用 int，除非你确定需要特定位宽或无符号整数。
• byte 和 rune:
  • byte 是 uint8 的别名，通常用于表示原始字节数据。
  • rune 是 int32 的别名，用于表示一个 Unicode 码点（UTF-8 编码的字符）。

package main

import "fmt"

func main() {
    var i int = 42          // int 类型，通常是 64 位
    var u uint = 100        // uint 类型，通常是 64 位
    var i8 int8 = -120      // int8 类型
    var u8 uint8 = 255      // uint8 类型 (byte)
    var r rune = 'A'        // rune 类型 (int32), 表示 Unicode 字符 'A'
    var b byte = 255        // byte 类型 (uint8)

    fmt.Printf("i: %v (类型: %T)\n", i, i)
    fmt.Printf("u: %v (类型: %T)\n", u, u)
    fmt.Printf("i8: %v (类型: %T)\n", i8, i8)
    fmt.Printf("u8: %v (类型: %T)\n", u8, u8)
    fmt.Printf("r: %v (类型: %T, 字符: %c)\n", r, r, r)
    fmt.Printf("b: %v (类型: %T)\n", b, b)
}

2. 浮点类型 (Floating-Point Types)

Go 语言支持两种浮点数类型。

• float32: 单精度浮点数。
• float64: 双精度浮点数。这是 Go 语言浮点数的默认类型，推荐使用，因为它提供更高的精度。

package main

import "fmt"

func main() {
    var f1 float32 = 3.1415926 // 单精度
    var f2 float64 = 3.1415926535 // 双精度 (默认)

    fmt.Printf("f1: %v (类型: %T)\n", f1, f1)
    fmt.Printf("f2: %v (类型: %T)\n", f2, f2)

    var inferredFloat = 2.718 // 默认推断为 float64
    fmt.Printf("inferredFloat: %v (类型: %T)\n", inferredFloat, inferredFloat)
}

3. 布尔类型 (Boolean Type)

布尔类型只有两个预定义的值：true 和 false。

• bool: 用于表示逻辑真或假。

package main

import "fmt"

func main() {
    var isGoFun bool = true
    var hasError bool = false

    fmt.Println("Go 语言有趣吗?", isGoFun)
    fmt.Println("是否有错误发生?", hasError)
}

4. 字符串类型 (String Type)

字符串是 Go 语言中的一个重要类型，它表示一个不可变的字节序列。Go 字符串是 UTF-8 编码的。

• string: 字符串可以通过双引号 "" 或反引号 声明。

a. 双引号字符串

用于普通字符串，支持转义字符（如 \n 换行，\t 制表符，\" 双引号等）。

package main

import "fmt"

func main() {
    var s1 string = "Hello, Go!"
    var s2 string = "第一行\n第二行" // 包含换行符

    fmt.Println(s1)
    fmt.Println(s2)
}

b. 反引号字符串 (Raw String Literals)

用于原始字符串，不会解释转义字符，可以包含多行。这对于定义正则表达式、JSON 字符串或 HTML 模板非常有用。

package main

import "fmt"

func main() {
    var rawString = `这是一个
多行的
原始字符串。
它不会解释 \n 或 \t`

    fmt.Println(rawString)

    jsonString := `{
        "name": "Go",
        "type": "Language"
    }`
    fmt.Println(jsonString)
}

Go 字符串是不可变的，这意味着一旦创建，就不能更改其内容。如果需要修改字符串，通常会创建一个新的字符串。

5. 零值 (Zero Values) 再次强调

Go 语言在声明变量但未显式初始化时，会自动将其初始化为对应类型的零值。这一设计哲学避免了其他语言中“未初始化变量”的常见错误，并简化了代码。

package main

import "fmt"

func main() {
    var a int
    var b float64
    var c bool
    var d string
    var e *int // 指针类型

    fmt.Printf("int 零值: %v\n", a)
    fmt.Printf("float64 零值: %v\n", b)
    fmt.Printf("bool 零值: %v\n", c)
    fmt.Printf("string 零值: '%v'\n", d)
    fmt.Printf("pointer 零值: %v\n", e)
}

结语

掌握变量的声明与初始化（var 和 := 的选择），常量的不可变性与 iota 的巧妙运用，以及 Go 语言的基本数据类型及其零值，是深入学习 Go 语言的基石。这些概念虽然基础，但在 Go 程序的编写中无处不在。理解它们的细节将帮助你编写出更健壮、更地道的 Go 代码。