使用 Go 语言解析 JSON 数组：结构体定义与 Unmarshal 方法详解-Golang-PHP中文网

使用 Go 语言解析 JSON 数组：结构体定义与 Unmarshal 方法详解

花韻仙語

发布： 2025-10-17 10:51:27

原创

688人浏览过

使用 go 语言解析 json 数组：结构体定义与 unmarshal 方法详解

本文档旨在指导开发者如何使用 Go 语言的 `encoding/json` 包解析包含 JSON 数组的复杂数据结构。通过定义合适的 Go 结构体，并结合 `json.Unmarshal` 方法，可以轻松地将 JSON 数据转换为 Go 中的数据结构。本文将提供结构体定义示例和代码示例，帮助开发者理解和应用该技术。

在 Go 语言中，处理 JSON 数据是一项常见的任务。encoding/json 包提供了强大的功能，可以方便地将 JSON 数据转换为 Go 语言中的数据结构，反之亦然。当 JSON 数据包含数组时，我们需要定义合适的 Go 结构体来映射这些数组。

结构体定义

要正确解析 JSON 数组，关键在于定义与 JSON 结构相匹配的 Go 结构体。例如，考虑以下 JSON 结构：

{
  "name": "example",
  "options": [
    {
      "key": "a",
      "value": "b"
    },
    {
      "key": "c",
      "value": "d"
    }
  ]
}

登录后复制

为了解析这个 JSON 数据，我们可以定义以下 Go 结构体：

type Option struct {
    Key   string `json:"key"`
    Value string `json:"value"`
}

type Data struct {
    Name    string   `json:"name"`
    Options []Option `json:"options"`
}

登录后复制

在这个例子中，Option 结构体用于映射 JSON 数组中的每个对象，而 Data 结构体包含了 Name 字段和一个 Option 类型的切片 Options，用于映射 JSON 中的 options 数组。注意 json:"key" 这样的标签，它指示 json.Unmarshal 如何将 JSON 字段映射到结构体字段。

使用 json.Unmarshal

定义好结构体后，就可以使用 json.Unmarshal 函数将 JSON 数据解析到结构体中。以下是一个完整的示例：

即构数智人

即构数智人是由即构科技推出的AI虚拟数字人视频创作平台，支持数字人形象定制、短视频创作、数字人直播等。

查看详情

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

type Option struct {
    Key   string `json:"key"`
    Value string `json:"value"`
}

type Data struct {
    Name    string   `json:"name"`
    Options []Option `json:"options"`
}

func main() {
    jsonData := []byte(`{
        "name": "example",
        "options": [
            {
                "key": "a",
                "value": "b"
            },
            {
                "key": "c",
                "value": "d"
            }
        ]
    }`)

    var data Data
    err := json.Unmarshal(jsonData, &data)
    if err != nil {
        log.Fatalf("Error unmarshalling JSON: %v", err)
    }

    fmt.Printf("Name: %s\n", data.Name)
    for _, option := range data.Options {
        fmt.Printf("Key: %s, Value: %s\n", option.Key, option.Value)
    }
}

登录后复制

在这个示例中，我们首先定义了一个包含 JSON 数据的字节切片 jsonData。然后，我们声明了一个 Data 类型的变量 data，并将 jsonData 解析到 data 中。json.Unmarshal 函数的第二个参数必须是指向结构体的指针。如果解析过程中发生错误，err 变量将包含错误信息。最后，我们打印解析后的数据，验证解析是否成功。

处理更复杂的 JSON 结构

对于更复杂的 JSON 结构，例如嵌套的 JSON 对象和数组，需要相应地调整结构体的定义。考虑以下 JSON 结构：

{
  "petfinder": {
    "pets": {
      "pet": [
        {
          "options": {
            "option": [
              {
                "$t": "altered"
              },
              {
                "$t": "hasShots"
              }
            ]
          },
          "breeds": {
            "breed": {
              "$t": "Dachshund"
            }
          }
        },
        {
          "options": {
            "option": [
              {
                "$t": "hasShots"
              }
            ]
          },
          "breeds": {
            "breed": {
              "$t": "American Staffordshire Terrier"
            }
          },
          "shelterPetId": {
            "$t": "13-0164"
          },
          "status": {
            "$t": "A"
          },
          "name": {
            "$t": "HAUS"
          }
        }
      ]
    }
  }
}

登录后复制

为了解析这个 JSON 数据，我们可以定义以下 Go 结构体：

type PetFinder struct {
    Pets Pets `json:"pets"`
}

type Pets struct {
    Pet []Pet `json:"pet"`
}

type Pet struct {
    Options Options `json:"options"`
    Breeds  Breeds  `json:"breeds"`
    ShelterPetId ShelterPetId `json:"shelterPetId,omitempty"`
    Status Status `json:"status,omitempty"`
    Name Name `json:"name,omitempty"`
}

type Options struct {
    Option []OptionDetail `json:"option"`
}

type OptionDetail struct {
    T string `json:"$t"`
}

type Breeds struct {
    Breed BreedDetail `json:"breed"`
}

type BreedDetail struct {
    T string `json:"$t"`
}

type ShelterPetId struct {
    T string `json:"$t"`
}

type Status struct {
    T string `json:"$t"`
}

type Name struct {
    T string `json:"$t"`
}

登录后复制

并使用类似下面的代码进行解析：

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

// 上面的结构体定义...

func main() {
    jsonData := []byte(`{
        "petfinder": {
            "pets": {
                "pet": [
                    {
                        "options": {
                            "option": [
                                {
                                    "$t": "altered"
                                },
                                {
                                    "$t": "hasShots"
                                }
                            ]
                        },
                        "breeds": {
                            "breed": {
                                "$t": "Dachshund"
                            }
                        }
                    },
                    {
                        "options": {
                            "option": [
                                {
                                    "$t": "hasShots"
                                }
                            ]
                        },
                        "breeds": {
                            "breed": {
                                "$t": "American Staffordshire Terrier"
                            }
                        },
                        "shelterPetId": {
                            "$t": "13-0164"
                        },
                        "status": {
                            "$t": "A"
                        },
                        "name": {
                            "$t": "HAUS"
                        }
                    }
                ]
            }
        }
    }`)

    var petFinder PetFinder
    err := json.Unmarshal(jsonData, &petFinder)
    if err != nil {
        log.Fatalf("Error unmarshalling JSON: %v", err)
    }

    fmt.Printf("Number of pets: %d\n", len(petFinder.Pets.Pet))
    for _, pet := range petFinder.Pets.Pet {
        fmt.Printf("Pet Name: %s\n", pet.Name.T)
    }
}

登录后复制

注意事项

结构体字段标签： 使用 json:"field_name" 标签来指定 JSON 字段与结构体字段之间的映射关系。
错误处理： 始终检查 json.Unmarshal 函数的返回值，以确保解析过程中没有发生错误。
omitempty 标签： 使用 omitempty 标签可以忽略 JSON 中不存在的字段，避免解析错误。例如：ShelterPetId ShelterPetIdjson:"shelterPetId,omitempty"`
数据类型匹配： 确保 Go 结构体字段的数据类型与 JSON 字段的数据类型匹配。

总结

通过定义合适的 Go 结构体，并结合 json.Unmarshal 方法，可以轻松地将包含 JSON 数组的复杂数据结构解析到 Go 语言中。理解结构体定义和 json.Unmarshal 函数的工作原理，可以帮助开发者更有效地处理 JSON 数据。在实际应用中，需要根据具体的 JSON 结构调整结构体的定义，并注意错误处理和数据类型匹配。

以上就是使用 Go 语言解析 JSON 数组：结构体定义与 Unmarshal 方法详解的详细内容，更多请关注php中文网其它相关文章！