Go 结构体实例化

Begindev 编辑部 March 25, 2026

创建并初始化结构体 (Struct) 实例，是 Go 语言编程中最基础且最频繁的操作之一。这就像是按照设计图纸，真正在内存中把房子建起来，并给里面摆上家具（赋予具体的数值）。

Go 语言提供了多种初始化结构体的方法，每种方法在控制力、代码冗余度和可读性上都有所不同。深刻理解这些不同的初始化姿势，能让你根据不同的业务场景，写出最优雅、最易于维护的代码。

1. 结构体初始化的四种方式

让我们通过具体的代码，逐一解析这四种创建和初始化结构体实例的方法。

1.1 方式一：使用键值对字面量 (最推荐)

这是 Go 语言中最常见、最明确，也是官方最推荐的初始化方式。你需要写出结构体的类型名，然后在大括号 {} 里使用 字段名: 值 的格式进行赋值。

package main

import "fmt"

type Person struct {
	FirstName string
	LastName  string
	Age       int
}

func main() {
	// 使用键值对字面量初始化 Person 结构体
	person1 := Person{
		FirstName: "John",
		LastName:  "Doe",
		Age:       30,
	}
	fmt.Println(person1) // 输出: {John Doe 30}
}

这种方式的巨大优势：

极其清晰： 一眼就能看出哪个值赋给了哪个字段。
顺序自由： 你可以完全不按结构体定义的顺序来写字段。
向后兼容： 如果以后在结构体里新增了字段，使用这种方式的旧代码绝对不会报错（新字段会自动使用零值）。

省略部分字段：
如果你在初始化时跳过了某些字段，Go 会自动为它们赋上对应类型的零值。

// Age 字段被省略了
	person2 := Person{
		FirstName: "Jane",
		LastName:  "Smith",
	}
	fmt.Println(person2) // 输出: {Jane Smith 0} (Age 自动变成了 0)

1.2 方式二：按顺序简写赋值 (Short Assignment)

Go 允许你省略字段名，直接按结构体定义时的顺序，把值塞进大括号里。

package main

import "fmt"

type Person struct {
	FirstName string
	LastName  string
	Age       int
}

func main() {
	// 按照定义顺序：FirstName, LastName, Age 直接赋值
	person3 := Person{"Peter", "Jones", 40}
	fmt.Println(person3) // 输出: {Peter Jones 40}
}

严重警告 (Important Considerations)：
虽然这种写法少打了几个字，但强烈建议在生产代码中避免使用它（除非结构体只有一两个极度简单的字段，比如 Point{10, 20}）。

它极度依赖字段定义的顺序，一旦顺序被打乱，赋值就会完全错位。
如果未来别人在结构体里增加了一个新字段，这行代码会直接导致编译失败。
别人阅读代码时，很难立刻猜出 "Peter" 对应的是哪个字段。

1.3 方式三：使用 `new` 函数分配指针

正如我们在之前章节学过的，new(Type) 函数会在内存中划分一块空间，把里面的字段全部初始化为零值，并返回一个指向该结构体的指针。

package main

import "fmt"

type Person struct {
	FirstName string
	LastName  string
	Age       int
}

func main() {
	// 使用 new 分配内存，person4 是一个 *Person (指针)
	person4 := new(Person)
	
	fmt.Printf("初始状态: %+v\n", person4) // 输出: 初始状态: &{FirstName: LastName: Age:0}
	fmt.Printf("变量类型: %T\n", person4)  // 输出: 变量类型: *main.Person
	
	// Go 语法糖：直接通过指针操作字段，自动解引用
	person4.FirstName = "Alice"
	person4.LastName = "Brown"
	person4.Age = 25
	
	fmt.Println("赋值后:", person4) // 输出: 赋值后: &{Alice Brown 25}
}

何时使用 new：
当你确实需要一个结构体指针，并且打算在后续的业务逻辑中，分步骤、零散地给它的字段赋值时，使用 new 是一个合理的选择。

1.4 方式四：取址符 + 结构体字面量 (`&Type{}`)

这是方式一和方式三的完美结合体。它允许你在一行代码内完成：创建实例、赋上你想要的初始值，并且直接拿走它的指针。这也是 Go 源码中最常见的初始化指针的方式。

package main

import "fmt"

type Person struct {
	FirstName string
	LastName  string
	Age       int
}

func main() {
	// 在字面量前面加上 &，直接得到一个初始化好的指针
	person5 := &Person{
		FirstName: "Charlie",
		LastName:  "Davis",
		Age:       35,
	}
	
	fmt.Println(person5) // 输出: &{Charlie Davis 35}
}

巨大优势：
它既有字面量赋值的极高可读性，又省去了先 new 出来再一行行赋值的啰嗦，是获取结构体指针的最佳实践。

2. 复杂嵌套结构体初始化实战

当结构体内部嵌套了其他结构体时，初始化可能会变得稍微复杂一点。让我们用一个包含 Address 的 Employee 结构体，来把刚才学到的四种方法统统演练一遍。

package main

import "fmt"

// 定义地址结构体
type Address struct {
	Street  string
	City    string
	ZipCode string
}

// 定义员工结构体，内部嵌套了 Address
type Employee struct {
	ID        int
	FirstName string
	LastName  string
	Address   Address // 嵌套结构体
}

func main() {
	// 方式 1：使用带字段名的字面量 (最推荐，清晰明了)
	employee1 := Employee{
		ID:        101,
		FirstName: "David",
		LastName:  "Miller",
		Address: Address{ // 注意这里也要写上类型名 Address
			Street:  "123 Main St",
			City:    "Anytown",
			ZipCode: "12345",
		},
	}
	fmt.Println("员工 1:", employee1)

	// 方式 2：按顺序简写 (极其反人类，千万别这么写嵌套)
	employee2 := Employee{102, "Emily", "Wilson", Address{"456 Oak Ave", "Springfield", "67890"}}
	fmt.Println("员工 2:", employee2)

	// 方式 3：取址符 & 加上字面量 (推荐，直接拿到指针)
	employee3 := &Employee{
		ID:        103,
		FirstName: "Frank",
		LastName:  "Taylor",
		Address: Address{
			Street:  "789 Pine Ln",
			City:    "Hill Valley",
			ZipCode: "54321",
		},
	}
	fmt.Println("员工 3:", employee3)

	// 方式 4：使用 new 然后逐个赋值 (略显啰嗦)
	employee4 := new(Employee)
	employee4.ID = 104
	employee4.FirstName = "Grace"
	employee4.LastName = "Moore"
	employee4.Address.Street = "987 Cedar Rd" // 逐级点进去赋值
	employee4.Address.City = "Gotham"
	employee4.Address.ZipCode = "09876"
	fmt.Println("员工 4:", employee4)
}