Go 基本语法：变量声明与函数定义

Go 语言（又称 Golang）以简洁、高效和强类型著称。掌握变量声明与函数定义是编写 Go 代码的基石。以下指南将直接通过代码示例和步骤解析，带你快速掌握这两大核心语法。

第一部分：变量声明

Go 语言提供多种声明变量的方式，既支持显式指定类型，也支持自动类型推断。根据使用场景选择合适的方式至关重要。

1. 标准变量声明

这是最基础的声明方式，完全明确变量的类型和初始值。

1. 打开 你的代码编辑器，创建一个新的 .go 文件（例如 main.go）。
2. 输入 关键字 var，后跟变量名、类型以及赋值。
3. 编写 以下代码示例来理解基本格式：

package main

import "fmt"

func main() {
    // 声明一个名为 username 的字符串变量
    var username string = "Gopher"

    // 声明一个名为 age 的整数变量
    var age int = 5

    // 输出变量值
    fmt.Println(username)
    fmt.Println(age)
}

2. 类型推断

如果在声明时直接赋值，Go 编译器可以自动根据值的类型推断出变量的类型，此时可以省略类型定义。

1. 使用 var 关键字开始声明。
2. 省略 变量名后的类型。
3. 赋予 变量一个具体的初始值。

func main() {
    // 编译器自动推断 language 为 string 类型
    var language = "Go"

    // 编译器自动推断 version 为 float64 类型（Go 默认浮点类型）
    var version = 1.19

    fmt.Printf("%s %f", language, version)
}

3. 短变量声明（最常用）

在函数内部（注意：只能在函数内部），使用 := 运算符是更简洁的声明方式。这是 Go 代码中最常见的变量定义形式。

1. 定位 到函数体内部（即 func main() { ... } 的大括号内）。
2. 输入 变量名。
3. 按下 := 符号（短变量声明符）。
4. 赋予 初始值。

func main() {
    // 使用 := 声明并初始化，无需 var 和类型
    message := "Hello, World!"
    count := 100

    fmt.Println(message)
    fmt.Println(count)
}

4. 批量声明

当需要声明多个变量时，使用 var 配合括号可以大大减少代码冗余。

1. 输入 关键字 var。
2. 按下 左圆括号 (。
3. 换行 并逐行声明变量。
4. 闭合 右圆括号 )。

func main() {
    var (
        name   string = "Alice"
        salary int    = 5000
        isManager bool = true
    )

    fmt.Println(name, salary, isManager)
}

5. 零值机制

在 Go 中，如果声明了一个变量但没有显式赋值，它不会像某些语言那样是“未定义”或“null”，而是会被赋予一个默认的“零值”。理解这一点可以避免空指针异常等错误。

下表列出了 Go 中常见数据类型的零值：

第二部分：函数定义

函数是 Go 语言的“一等公民”，其定义语法清晰明了。Go 语言的独特之处在于支持多返回值。

1. 基本函数结构

定义一个函数需要指定函数名、参数列表、返回值类型和函数体。

1. 输入 关键字 func。
2. 编写 函数名（Go 语言中，首字母大写表示公开函数，小写表示私有函数）。
3. 在圆括号内 定义参数列表（格式为 参数名 参数类型）。
4. 在圆括号后 指定返回值类型。
5. 编写 花括号 {} 包裹的函数体逻辑。

// 定义一个名为 add 的函数，接收两个整数，返回一个整数
func add(a int, b int) int {
    return a + b
}

func main() {
    result := add(3, 5)
    fmt.Println(result) // 输出 8
}

2. 参数类型简写

当函数的多个参数属于同一类型时，只需要在最后一个参数后注明类型即可。

1. 列出 所有参数名。
2. 仅在最后一个参数后 写上类型。

// a 和 b 都是 int 类型，无需重复写 int
func multiply(a, b int) int {
    return a * b
}

3. 多返回值（Go 的杀手锏）

Go 语言允许一个函数返回多个结果。这在处理错误时非常有用（例如同时返回结果和错误信息）。

1. 在函数定义的返回值部分，使用圆括号包裹多个类型。
2. 在函数体中，使用 return 关键字返回对应数量的值，使用逗号分隔。

// 定义一个函数同时返回除法结果和余数
func divmod(a int, b int) (int, int) {
    quotient := a / b
    remainder := a % b
    return quotient, remainder
}

func main() {
    q, r := divmod(10, 3)
    fmt.Printf("商: %d, 余数: %d\n", q, r) // 输出: 商: 3, 余数: 1
}

4. 命名返回值

你可以在函数签名中预先给返回值命名。这样在函数体内部可以直接给这些变量赋值，最后直接使用 return 即可返回所有命名的返回值。这在长函数中能增加代码可读性。

1. 在返回值列表中，不仅写类型，还要写变量名。
2. 在函数体中，直接对这些返回值变量进行赋值。
3. 在结尾处，仅输入 return 关键字而不带任何参数。

// 返回值被命名为 result 和 err
func calculate(price int, count int) (result int, err error) {
    if count < 0 {
        // 直接给命名的 err 变量赋值
        err = fmt.Errorf("数量不能为负数")
        return // 直接返回，此时 result 为 0，err 为非空
    }
    result = price * count
    return // 返回 result 和 err
}

func main() {
    total, error := calculate(100, 2)
    if error != nil {
        fmt.Println("出错:", error)
    } else {
        fmt.Println("总价:", total)
    }
}

5. 可变参数函数

如果你希望函数能接收任意数量的参数，可以使用可变参数语法。这类似于 Python 的 *args 或 JavaScript 的 ...args。

1. 在参数类型前 添加 三个点 ...。
2. 在函数内部，该参数会被视为一个切片。

// nums 可以接收任意数量的 int 参数
func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

func main() {
    fmt.Println(sum(1, 2))    // 输出 3
    fmt.Println(sum(1, 2, 3)) // 输出 6
}

第三部分：综合实战

结合上述变量与函数的知识，我们编写一个简单的程序：计算圆的面积和周长。

1. 创建 文件 circle.go。
2. 定义 常量 Pi（虽然本节主要讲变量，但常量在几何计算中必不可少，使用 const 定义）。
3. 定义 函数 calculateCircle，接收半径，返回面积和周长。
4. 在 main 函数中，使用短变量声明调用函数并输出结果。

package main

import (
    "fmt"
    "math"
)

// calculateCircle 接收半径，返回面积和周长
func calculateCircle(radius float64) (area, circumference float64) {
    // 使用 math 包中的 Pi 常量
    area = math.Pi * radius * radius
    circumference = 2 * math.Pi * radius
    return // 使用命名返回值特性
}

func main() {
    // 1. 使用短变量声明半径
    r := 5.0

    // 2. 调用函数接收多返回值
    // _ 用于忽略某个返回值（如果我们不需要周长）
    a, c := calculateCircle(r)

    // 3. 格式化输出
    fmt.Printf("半径: %.2f\n", r)
    fmt.Printf("面积: %.2f\n", a)
    fmt.Printf("周长: %.2f\n", c)
}

执行上述代码步骤如下：

1. 打开终端或命令行。
2. 导航到保存 circle.go 的目录。
3. 输入命令 go run circle.go。
4. 查看输出结果，验证面积与周长的计算是否正确。