当前位置：首页 > news >正文

Go匿名结构体使用场景

news 2025/7/8 0:30:40

1. 定义

在 Go 语言中，匿名结构体（Anonymous Struct）是一种没有显式命名的结构体类型。你可以直接在代码中定义并使用匿名结构体，而不需要为其定义一个单独的类型名称。匿名结构体通常用于临时数据结构或一次性使用的场景。

匿名行为的设计带来了一些理解上的困难，但是熟悉了匿名设计的使用后，你会发现匿名设计在某些特定场景可以帮助大家写出更简洁、更优雅、更高效和更安全的代码。

2. 代码使用示例

2.1 简单示例

package mainimport ("fmt"
)func main() {// 定义并初始化一个匿名结构体person := struct {Name stringAge  int}{Name: "Alice",Age:  30,}// 打印匿名结构体的字段fmt.Println("Name:", person.Name)fmt.Println("Age:", person.Age)
}

结果：

Name: Alice
Age: 30

在这个示例中，struct { Name string; Age int } 定义了一个匿名结构体类型，并直接初始化了一个 person 变量。你可以像访问普通结构体一样访问匿名结构体的字段。

2.2 匿名结构体的嵌套

你也可以在匿名结构体中嵌套其他匿名结构体：

package mainimport ("fmt"
)func main() {// 定义并初始化一个嵌套的匿名结构体employee := struct {Name    stringAge     intAddress struct {City  stringState string}}{Name: "Bob",Age:  25,Address: struct {City  stringState string}{City:  "New York",State: "NY",},}// 打印嵌套的匿名结构体的字段fmt.Println("Name:", employee.Name)fmt.Println("Age:", employee.Age)fmt.Println("City:", employee.Address.City)fmt.Println("State:", employee.Address.State)
}

结果：

Name: Bob
Age: 25
City: New York
State: NY

在这个示例中，employee 是一个包含嵌套匿名结构体的匿名结构体。你可以通过 employee.Address.City 和 employee.Address.State 访问嵌套结构体的字段。

2.3 总结

struct { ... }：定义一个匿名结构体类型。
匿名结构体通常用于临时数据结构或一次性使用的场景。
你可以在匿名结构体中嵌套其他匿名结构体。
通过使用匿名结构体，你可以在 Go 程序中方便地定义和使用临时数据结构，而无需为其定义单独的类型名称。

3. 使用场景

3.1 造测试数据

匿名结构体可以和切片结合起来使用，通常用于创建一组测试数据。

package mainimport "fmt"func main() {// 测试数据var people = []struct {Name stringAge  int}{{"Li", 31},{"Yang", 28},{"Liu", 27},{"Tong", 30},}fmt.Println(people)
}

结果：

[{Li 31} {Yang 28} {Liu 27} {Tong 30}]

3.2 处理Json

将一个json串转化为map[string]interface{})结构

package mainimport ("encoding/json""fmt""reflect"
)const jsonStr = `{
"name":"Liuhui",
"id":712364567213544422
}`func main() {obj := make(map[string]interface{})_ = json.Unmarshal([]byte(jsonStr), &obj)fmt.Printf("%+v\n", obj)fmt.Println("-------------------")objBytes, _ := json.Marshal(obj)fmt.Println(string(objBytes))fmt.Printf("%+v\n", reflect.TypeOf(obj["id"]).Name())
}

结果(可以看到精度丢失)：

map[id:7.123645672135444e+17 name:Liuhui]
-------------------
{"id":712364567213544400,"name":"Liuhui"}
float64

在当前代码中，json.Unmarshal 将 JSON 数据解析到一个 map[string]interface{} 中。由于 interface{} 类型可以表示任何 Go 类型，因此在解析 JSON 时，Go 会根据 JSON 值的类型自动选择合适的 Go 类型。对于大整数（如 712364567213544422），Go 默认会将其解析为 float64 类型。
为什么会丢失精度？
float64 的精度限制：float64 类型在表示大整数时可能会丢失精度。float64 使用 64 位来表示数值，其中一部分用于表示指数，因此对于非常大的整数，float64 无法精确表示。
interface{} 的类型推断：当 JSON 中的整数非常大时，json.Unmarshal 会将其解析为 float64，因为 float64 可以表示比 int64 更大的数值范围。然而，float64 的精度不足以精确表示所有大整数，从而导致精度丢失。

如何避免精度丢失？
为了避免精度丢失，可以使用匿名结构体来解析 JSON 数据，并明确指定整数类型的字段。例如：

package mainimport ("encoding/json""fmt"
)const jsonStr = `{
"name":"Liuhui",
"id":712364567213544422
}`func main() {obj := struct {Name string `json:"name"`Id   int64  `json:"id"`}{}_ = json.Unmarshal([]byte(jsonStr), &obj)fmt.Printf("%+v\n", obj)fmt.Println("-------------------")objBytes, _ := json.Marshal(obj)fmt.Println(string(objBytes))
}

结果：

{Name:Liuhui Id:712364567213544422}
-------------------
{"name":"Liuhui","id":712364567213544422}

嵌套的 JSON

对于嵌套的 JSON,也可以使用内嵌的匿名结构体来解析:

package mainimport ("encoding/json""fmt"
)const jsonStr = `{
"name":"Liuhui",
"id":712364567213544422,
"job":{
"Company":"DouYin"}
}`func main() {obj := struct {Name string `json:"name"`Id   int64  `json:"id"`Job  struct {Company string `json:"company"`} `json:"job"`}{}_ = json.Unmarshal([]byte(jsonStr), &obj)fmt.Printf("%+v\n", obj)fmt.Println("-------------------")objBytes, _ := json.Marshal(obj)fmt.Println(string(objBytes))
}

结果：

{Name:Liuhui Id:712364567213544422 Job:{Company:DouYin}}
-------------------
{"name":"Liuhui","id":712364567213544422,"jobc":{"company":"DouYin"}}

3.3 嵌套锁

我们经常遇到多个goroutine要操作共享变量，为了并发安全，需要对共享变量的读写加锁。

这个时候通常需要定义一个和共享变量配套的锁来保护共享变量。

匿名结构体和匿名字段相结合，可以写出更优雅的代码来保护匿名结构体里的共享变量，实现并发安全。

package mainimport ("fmt""sync"
)func main() {// hits 匿名结构体变量// 这里同时用到了匿名结构体和匿名字段, sync.Mutex是匿名字段// 因为匿名结构体嵌套了sync.Mutex，所以就有了sync.Mutex的Lock和Unlock方法var hits struct {sync.Mutexn int}var wg sync.WaitGroupN := 1000// 启动100个goroutine对匿名结构体的成员n同时做读写操作wg.Add(N)for i := 0; i < 1000; i++ {go func() {defer wg.Done()hits.Lock()defer hits.Unlock()hits.n++}()}wg.Wait()fmt.Println(hits.n) // 1000
}