Go语言核心语法速成：变量、函数与结构体-代码聚汇网

Go语言核心语法速成：变量、函数与结构体

Nicholas Qin·2026-08-06·阅读 25 GEO检测（免费）

Go语言变量声明函数

|难度：普通|阅读约 16 分钟

1. Go语言核心语法速成：变量、函数、结构体快速上手

刚接触Go语言时，很多人会被它简洁的语法和高效的并发模型所吸引。但要在10分钟内掌握变量、函数和结构体这些核心语法，需要抓住关键点而非面面俱到。我在实际项目开发中发现，Go的语法设计处处体现着"少即是多"的哲学——没有复杂的继承体系，没有运算符重载，甚至没有异常处理，但这种克制反而让代码更易读、更易维护。

1.1 变量声明：Go的独特方式

Go语言的变量声明与其他主流语言有明显不同。最基础的方式是使用var关键字：

go复制var age int = 30

但Go编译器其实很智能，它可以自动推断类型：

go复制var age = 30 // 编译器知道这是int类型

更简洁的写法是用短变量声明（只能在函数内使用）：

go复制age := 30 // 等价于上面两种写法

注意：短变量声明中的:=是一个整体运算符，不是赋值和声明的简单组合。它意味着"声明并初始化"。

Go还支持批量声明变量，这在需要声明多个相关变量时特别有用：

go复制var (
    name string = "Alice"
    age  int    = 25
    isAdmin bool = true
)

或者使用短变量声明的批量形式：

go复制name, age, isAdmin := "Alice", 25, true

Go语言有一个独特的零值机制——所有变量在声明后都会自动初始化为其类型的零值：

数值类型：0
布尔类型：false
字符串类型：""（空字符串）
指针、接口、切片、通道、map和函数：nil

这个特性在实际开发中非常实用，可以避免很多未初始化变量导致的bug。

1.2 常量与iota：Go的枚举替代方案

Go没有枚举类型，但通过const和iota可以实现类似功能：

go复制const (
    Monday = iota + 1 // 1
    Tuesday           // 2
    Wednesday         // 3
    Thursday          // 4
    Friday            // 5
    Saturday          // 6
    Sunday            // 7
)

iota是一个特殊的常量计数器，在const块中从0开始自动递增。上面的代码定义了一周七天的枚举值。

更复杂的用法可以结合位运算：

go复制const (
    ReadPermission = 1 << iota // 1 (0001)
    WritePermission            // 2 (0010)
    ExecutePermission          // 4 (0100)
    AllPermissions = ReadPermission | WritePermission | ExecutePermission // 7 (0111)
)

这种模式在需要位标志的系统编程中非常常见。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 函数：Go的核心构建块

Go语言的函数设计有几个显著特点：多返回值、命名返回值、函数作为一等公民、延迟执行等。

2.1 基本函数定义

一个典型的Go函数定义如下：

go复制func add(a int, b int) int {
    return a + b
}

当参数类型相同时，可以简写：

go复制func add(a, b int) int {
    return a + b
}

2.2 多返回值：Go的特色功能

Go函数可以返回多个值，这是处理错误的标准方式：

go复制func divide(a, b float64) (float64, error) {
    if b == 0.0 {
        return 0.0, errors.New("division by zero")
    }
    return a / b, nil
}

调用时这样处理：

go复制result, err := divide(10.0, 2.0)
if err != nil {
    log.Fatal(err)
}
fmt.Println(result) // 输出: 5

2.3 命名返回值：提升代码可读性

Go允许为返回值命名，这些变量会被自动初始化为零值：

go复制func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return // 裸返回，自动返回x和y
}

命名返回值特别适合返回值较多或逻辑复杂的函数，可以提升代码可读性。

2.4 可变参数函数：灵活处理不定数量参数

Go支持可变参数函数，通过在参数类型前加...表示：

go复制func sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

fmt.Println(sum(1, 2, 3)) // 输出: 6

提示：可变参数实际上被转换为切片类型，所以也可以直接传入切片：

go复制nums := []int{1, 2, 3}
fmt.Println(sum(nums...)) // 输出: 6

2.5 匿名函数与闭包：函数式编程的支持

Go支持匿名函数，可以像普通变量一样传递：

go复制func main() {
    add := func(a, b int) int {
        return a + b
    }
    fmt.Println(add(1, 2)) // 输出: 3
}

更强大的功能是闭包——函数可以捕获其外部作用域的变量：

go复制func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

func main() {
    pos, neg := adder(), adder()
    for i := 0; i < 10; i++ {
        fmt.Println(pos(i), neg(-2*i))
    }
}

这个例子中，adder函数返回一个闭包，每个闭包都绑定到自己的sum变量上。

3. 结构体：Go的面向对象基础

Go不是传统的面向对象语言，没有类和继承的概念。结构体是Go中创建自定义复合类型的主要方式。

3.1 基本结构体定义与使用

定义一个简单的结构体：

go复制type Person struct {
    Name string
    Age  int
}

创建结构体实例：

go复制// 方式1：按字段顺序
p1 := Person{"Alice", 25}

// 方式2：使用字段名
p2 := Person{Name: "Bob", Age: 30}

// 方式3：先声明后赋值
var p3 Person
p3.Name = "Charlie"
p3.Age = 35

注意：方式1需要记住字段顺序，且必须提供所有字段的值。方式2更灵活，可以省略某些字段（会被初始化为零值）。

3.2 结构体方法：Go的"成员函数"

Go可以为结构体定义方法，这是一种特殊的函数，在函数名前指定接收者：

go复制func (p Person) SayHello() {
    fmt.Printf("Hello, my name is %s and I'm %d years old.\n", p.Name, p.Age)
}

调用方法：

go复制p := Person{"Alice", 25}
p.SayHello()

方法接收者可以是值类型（如上例）或指针类型：

go复制func (p *Person) Birthday() {
    p.Age++ // 这里需要修改结构体，所以必须用指针接收者
}

关键区别：

值接收者：方法内操作的是结构体的副本，不会影响原结构体

指针接收者：方法内操作的是结构体本身，可以修改原结构体

3.3 结构体嵌套与匿名字段：Go的"继承"替代方案

Go通过结构体嵌套实现代码复用：

go复制type Address struct {
    City    string
    Country string
}

type Employee struct {
    Person  // 匿名字段，自动获取Person的字段和方法
    Address // 同上
    Salary  float64
}

使用嵌套结构体：

go复制emp := Employee{
    Person: Person{
        Name: "Alice",
        Age:  30,
    },
    Address: Address{
        City:    "New York",
        Country: "USA",
    },
    Salary: 50000.0,
}

fmt.Println(emp.Name) // 可以直接访问嵌套字段
fmt.Println(emp.Person.Name) // 也可以完整路径访问

这种设计模式被称为"组合优于继承"，是Go语言的核心哲学之一。

3.4 结构体标签：元数据的力量

Go结构体支持字段标签（tag），这是附加在字段上的元数据：

go复制type User struct {
    ID       int    `json:"id" db:"user_id"`
    Username string `json:"username" db:"username"`
    Password string `json:"-" db:"password"` // json序列化时忽略此字段
}

标签本身不直接影响程序逻辑，但可以通过反射读取，常用于：

JSON/XML序列化（encoding/json, encoding/xml包）
数据库ORM映射
表单验证
配置解析

例如，使用encoding/json包序列化结构体：

go复制user := User{1, "alice", "secret"}
data, _ := json.Marshal(user)
fmt.Println(string(data)) // 输出: {"id":1,"username":"alice"}

4. 高级技巧与常见陷阱

4.1 零值陷阱：nil不是null

Go的nil与其他语言的null不同：

go复制var s []int // nil切片
if s == nil {
    fmt.Println("s is nil") // 会执行
}

s = []int{} // 空切片
if s == nil {
    fmt.Println("s is nil") // 不会执行
}

nil切片和空切片的区别：

nil切片：未初始化的切片，底层数组指针为nil
空切片：初始化但长度为0的切片，底层数组指针不为nil

两者在使用上几乎没区别（都可以调用append等操作），但在某些反射场景下表现不同。

4.2 方法集与接口满足规则

Go有一个容易混淆的规则：类型T的方法集包含所有值接收者方法，而类型*T的方法集包含所有值接收者和指针接收者方法。

这意味着：

go复制type MyInt int

func (m MyInt) ValueMethod() {}
func (m *MyInt) PointerMethod() {}

var m MyInt
var pm *MyInt

m.ValueMethod()    // OK
pm.ValueMethod()   // OK (*T可以调用值接收者方法)
m.PointerMethod()  // OK (T可以调用指针接收者方法)
pm.PointerMethod() // OK

这个规则会影响接口实现：

go复制type Interface interface {
    Method()
}

type T struct{}

func (t *T) Method() {} // 指针接收者

func main() {
    var t T
    var i Interface = t // 编译错误！T没有实现Interface
    var i2 Interface = &t // OK
}

4.3 结构体比较的注意事项

只有当结构体的所有字段都是可比较的类型时，结构体本身才是可比较的：

go复制type Point struct {
    X, Y int
}

p1 := Point{1, 2}
p2 := Point{1, 2}
fmt.Println(p1 == p2) // true

但如果结构体包含不可比较的字段（如切片、map、函数），则不能直接比较：

go复制type Data struct {
    Numbers []int
}

d1 := Data{Numbers: []int{1, 2}}
d2 := Data{Numbers: []int{1, 2}}
fmt.Println(d1 == d2) // 编译错误

4.4 内存对齐与结构体布局

Go编译器会自动对结构体字段进行内存对齐优化，但有时手动调整字段顺序可以节省内存：

go复制// 占用16字节
type A struct {
    a bool   // 1字节
    b int64  // 8字节
    c bool   // 1字节
}

// 占用24字节
type B struct {
    a bool   // 1字节
    c bool   // 1字节
    b int64  // 8字节
}

使用unsafe包可以查看结构体布局：

go复制import "unsafe"

fmt.Println(unsafe.Sizeof(A{})) // 16
fmt.Println(unsafe.Sizeof(B{})) // 24

调整字段顺序后，结构体A比B节省了8字节内存。这在处理大量数据时尤为重要。

4.5 结构体与JSON处理的常见问题

处理JSON时经常遇到的一些问题：

忽略空字段：

go复制type User struct {
    Name string `json:"name,omitempty"`
    Age  int    `json:"age,omitempty"`
}

u := User{Age: 0}
data, _ := json.Marshal(u)
fmt.Println(string(data)) // 输出: {"age":0}

注意：零值会被omitempty忽略，有时这不是我们想要的行为。

处理时间字段：

go复制type Event struct {
    Time time.Time `json:"time"`
}

e := Event{Time: time.Now()}
data, _ := json.Marshal(e)
fmt.Println(string(data)) // 输出: {"time":"2023-07-20T15:04:05Z"}

可以通过实现自定义的Marshaler/Unmarshaler接口来控制时间格式。

处理嵌入式结构体：

go复制type Base struct {
    ID int `json:"id"`
}

type User struct {
    Base
    Name string `json:"name"`
}

u := User{Base: Base{ID: 1}, Name: "Alice"}
data, _ := json.Marshal(u)
fmt.Println(string(data)) // 输出: {"id":1,"name":"Alice"}

嵌入式结构体的字段会被提升到外层，这在API设计中很有用。