Go匿名结构体使用场景

1. 定义

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

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

2. 代码使用示例

2.1 简单示例

package main

import (
	"fmt"
)

func main() {
	// 定义并初始化一个匿名结构体
	person := struct {
		Name string
		Age  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 main

import (
	"fmt"
)

func main() {
	// 定义并初始化一个嵌套的匿名结构体
	employee := struct {
		Name    string
		Age     int
		Address struct {
			City  string
			State string
		}
	}{
		Name: "Bob",
		Age:  25,
		Address: struct {
			City  string
			State 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 main

import "fmt"

func main() {

	// 测试数据
	var people = []struct {
		Name string
		Age  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 main

import (
	"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 main

import (
	"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 main

import (
	"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 main

import (
	"fmt"
	"sync"
)

func main() {
	// hits 匿名结构体变量
	// 这里同时用到了匿名结构体和匿名字段, sync.Mutex是匿名字段
	// 因为匿名结构体嵌套了sync.Mutex，所以就有了sync.Mutex的Lock和Unlock方法
	var hits struct {
		sync.Mutex
		n int
	}
	var wg sync.WaitGroup
	N := 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
}