跳转到主要内容

标签(标签)

资源精选(342) Go开发(108) Go语言(103) Go(99) angular(82) LLM(75) 大语言模型(63) 人工智能(53) 前端开发(50) LangChain(43) golang(43) 机器学习(39) Go工程师(38) Go程序员(38) Go开发者(36) React(33) Go基础(29) Python(24) Vue(22) Web开发(20) Web技术(19) 精选资源(19) 深度学习(19) Java(18) ChatGTP(17) Cookie(16) android(16) 前端框架(13) JavaScript(13) Next.js(12) 安卓(11) typescript(10) 资料精选(10) NLP(10) 第三方Cookie(9) Redwoodjs(9) LLMOps(9) Go语言中级开发(9) 自然语言处理(9) 聊天机器人(9) PostgreSQL(9) 区块链(9) mlops(9) 安全(9) 全栈开发(8) ChatGPT(8) OpenAI(8) Linux(8) AI(8) GraphQL(8) iOS(8) 软件架构(7) Go语言高级开发(7) AWS(7) C++(7) 数据科学(7) whisper(6) Prisma(6) 隐私保护(6) RAG(6) JSON(6) DevOps(6) 数据可视化(6) wasm(6) 计算机视觉(6) 算法(6) Rust(6) 微服务(6) 隐私沙盒(5) FedCM(5) 语音识别(5) Angular开发(5) 快速应用开发(5) 提示工程(5) Agent(5) LLaMA(5) 低代码开发(5) Go测试(5) gorm(5) REST API(5) 推荐系统(5) WebAssembly(5) GameDev(5) CMS(5) CSS(5) machine-learning(5) 机器人(5) 游戏开发(5) Blockchain(5) Web安全(5) Kotlin(5) 低代码平台(5) 机器学习资源(5) Go资源(5) Nodejs(5) PHP(5) Swift(5) 智能体(4) devin(4) Blitz(4) javascript框架(4) Redwood(4) GDPR(4) 生成式人工智能(4) Angular16(4) Alpaca(4) SAML(4) JWT(4) JSON处理(4) Go并发(4) kafka(4) 移动开发(4) 移动应用(4) security(4) 隐私(4) spring-boot(4) 物联网(4) nextjs(4) 网络安全(4) API(4) Ruby(4) 信息安全(4) flutter(4) 专家智能体(3) Chrome(3) CHIPS(3) 3PC(3) SSE(3) 人工智能软件工程师(3) LLM Agent(3) Remix(3) Ubuntu(3) GPT4All(3) 软件开发(3) 问答系统(3) 开发工具(3) 最佳实践(3) RxJS(3) SSR(3) Node.js(3) Dolly(3) 移动应用开发(3) 编程语言(3) 低代码(3) IAM(3) Web框架(3) CORS(3) 基准测试(3) Go语言数据库开发(3) Oauth2(3) 并发(3) 主题(3) Theme(3) earth(3) nginx(3) 软件工程(3) azure(3) keycloak(3) 生产力工具(3) gpt3(3) 工作流(3) C(3) jupyter(3) 认证(3) prometheus(3) GAN(3) Spring(3) 逆向工程(3) 应用安全(3) Docker(3) Django(3) R(3) .NET(3) 大数据(3) Hacking(3) 渗透测试(3) C++资源(3) Mac(3) 微信小程序(3) Python资源(3) JHipster(3) 大型语言模型(2) 语言模型(2) 可穿戴设备(2) JDK(2) SQL(2) Apache(2) Hashicorp Vault(2) Spring Cloud Vault(2) Go语言Web开发(2) Go测试工程师(2) WebSocket(2) 容器化(2) AES(2) 加密(2) 输入验证(2) ORM(2) Fiber(2) Postgres(2) Gorilla Mux(2) Go数据库开发(2) 模块(2) 泛型(2) 指针(2) HTTP(2) PostgreSQL开发(2) Vault(2) K8s(2) Spring boot(2) R语言(2) 深度学习资源(2) 半监督学习(2) semi-supervised-learning(2) architecture(2) 普罗米修斯(2) 嵌入模型(2) productivity(2) 编码(2) Qt(2) 前端(2) Rust语言(2) NeRF(2) 神经辐射场(2) 元宇宙(2) CPP(2) 数据分析(2) spark(2) 流处理(2) Ionic(2) 人体姿势估计(2) human-pose-estimation(2) 视频处理(2) deep-learning(2) kotlin语言(2) kotlin开发(2) burp(2) Chatbot(2) npm(2) quantum(2) OCR(2) 游戏(2) game(2) 内容管理系统(2) MySQL(2) python-books(2) pentest(2) opengl(2) IDE(2) 漏洞赏金(2) Web(2) 知识图谱(2) PyTorch(2) 数据库(2) reverse-engineering(2) 数据工程(2) swift开发(2) rest(2) robotics(2) ios-animation(2) 知识蒸馏(2) 安卓开发(2) nestjs(2) solidity(2) 爬虫(2) 面试(2) 容器(2) C++精选(2) 人工智能资源(2) Machine Learning(2) 备忘单(2) 编程书籍(2) angular资源(2) 速查表(2) cheatsheets(2) SecOps(2) mlops资源(2) R资源(2) DDD(2) 架构设计模式(2) 量化(2) Hacking资源(2) 强化学习(2) flask(2) 设计(2) 性能(2) Sysadmin(2) 系统管理员(2) Java资源(2) 机器学习精选(2) android资源(2) android-UI(2) Mac资源(2) iOS资源(2) Vue资源(2) flutter资源(2) JavaScript精选(2) JavaScript资源(2) Rust开发(2) deeplearning(2) RAD(2)

在这篇文章中,我们将学习如何以最简单的方式在 Go 中使用 JSON。

我们将学习如何将 JSON 原始数据(字符串或字节)转换为 Go 类型,如结构、数组和切片,以及非结构化数据,如映射和空接口。

banner

JSON 被用作数据序列化的事实标准,在本文结束时,您将熟悉如何在 Go Unmarshaling Raw JSON Data 中对 JSON 进行编组(编码)和解组(解码)

Unmarshaling Raw JSON Data


Go 的 JSON 标准库提供的 Unmarshal 函数可以让我们以 []byte 变量的形式解析原始 JSON 数据。

我们可以将 JSON 字符串转换为字节,并将数据解组为变量地址:

import "encoding/json"
//...

// ... 
myJsonString := `{"some":"json"}`

// `&myStoredVariable` is the address of the variable we want to store our
// parsed data in
json.Unmarshal([]byte(myJsonString), &myStoredVariable)
//...


让我们看看 myStoredVariable 的不同变量类型,以及何时应该使用它们。

使用 JSON 时会遇到两种类型的数据:

  • 结构化数据
  • 非结构化数据


结构化数据(将 JSON 解码为结构)


“结构化数据”是指您事先知道格式的数据。例如,假设您有一个鸟类对象,其中每只鸟都有一个种类字段和一个描述字段:

{
  "species": "pigeon",
  "description": "likes to perch on rocks"
}


要使用此类数据,请创建一个反映您要解析的数据的结构。在我们的例子中,我们将创建一个具有 Species 和 Description 属性的鸟类结构:

type Bird struct {
  Species string
  Description string
}

并将其解组如下:

birdJson := `{"species": "pigeon","description": "likes to perch on rocks"}`
var bird Bird    
json.Unmarshal([]byte(birdJson), &bird)
fmt.Printf("Species: %s, Description: %s", bird.Species, bird.Description)
//Species: pigeon, Description: likes to perch on rocks


 

按照惯例,Go 使用与不区分大小写的 JSON 属性中相同的标题大小写属性名称。因此,我们 Bird 结构中的 Species 属性将映射到该物种,或 Species 或 sPeCiEs JSON 属性。

JSON 数组


让我们看看如何解码对象数组,如下所示:

[
  {
    "species": "pigeon",
    "decription": "likes to perch on rocks"
  },
  {
    "species":"eagle",
    "description":"bird of prey"
  }
]


由于数组的每个元素都具有 Bird 结构的结构,因此您可以通过创建一个小鸟切片来解组它:

birdJson := `[{"species":"pigeon","decription":"likes to perch on rocks"},{"species":"eagle","description":"bird of prey"}]`
var birds []Bird
json.Unmarshal([]byte(birdJson), &birds)
fmt.Printf("Birds : %+v", birds)
//Birds : [{Species:pigeon Description:} {Species:eagle Description:bird of prey}]


 

嵌套对象


现在,考虑当您有一个名为 Dimensions 的属性时的情况,该属性测量相关鸟的高度和长度:

{
  "species": "pigeon",
  "decription": "likes to perch on rocks"
  "dimensions": {
    "height": 24,
    "width": 10
  }
}


与我们之前的示例一样,我们需要在 Go 代码中镜像对象的结构。要添加嵌套维度对象,让我们创建一个维度结构:

type Dimensions struct {
  Height int
  Width int
}


现在,Bird 结构将包含一个Dimensions 字段:

type Bird struct {
  Species string
  Description string
  Dimensions Dimensions
}


我们可以使用与以前相同的方法来解组这些数据:

birdJson := `{"species":"pigeon","description":"likes to perch on rocks", "dimensions":{"height":24,"width":10}}`
var birds Bird
json.Unmarshal([]byte(birdJson), &birds)
fmt.Printf(bird)
// {pigeon likes to perch on rocks {24 10}}

 

原始类型


在使用 JSON 时,我们主要处理复杂的对象或数组,但像 3、3.1412 和“birds”这样的数据也是有效的 JSON 字符串。

我们可以使用原始类型将这些值解组为 Go 中对应的数据类型:

numberJson := "3"
floatJson := "3.1412"
stringJson := `"bird"`

var n int
var pi float64
var str string

json.Unmarshal([]byte(numberJson), &n)
fmt.Println(n)
// 3

json.Unmarshal([]byte(floatJson), &pi)
fmt.Println(pi)
// 3.1412

json.Unmarshal([]byte(stringJson), &str)
fmt.Println(str)
// bird

 

JSON 结构标签 - 自定义字段名称


我们之前看到 Go 使用约定来确定映射 JSON 属性的属性名称。

虽然有时,我们需要一个与您的 JSON 数据中提供的属性名称不同的属性名称。例如,考虑以下数据:

{
  "birdType": "pigeon",
  "what it does": "likes to perch on rocks"
}


在这里,我们希望birdType 在我们的 Go 代码中保留为 Species 属性。我们也不可能为“它的作用”之类的键提供合适的属性名称。

为了解决这个问题,我们可以使用结构字段标签:

type Bird struct {
  Species string `json:"birdType"`
  Description string `json:"what it does"`
}


现在,我们可以明确地告诉我们的代码将哪个 JSON 属性映射到哪个属性。

birdJson := `{"birdType": "pigeon","what it does": "likes to perch on rocks"}`
var bird Bird
json.Unmarshal([]byte(birdJson), &bird)
fmt.Println(bird)
// {pigeon likes to perch on rocks}

将 JSON 解码为地图 - 非结构化数据


如果您事先不知道 JSON 属性的结构,则不能使用结构来解组数据。

相反,您可以使用地图。考虑一些 JSON 格式:

{
  "birds": {
    "pigeon":"likes to perch on rocks",
    "eagle":"bird of prey"
  },
  "animals": "none"
}


我们无法构建结构来表示所有情况下的上述数据,因为与鸟对应的键可以更改,这将改变结构。

为了处理这种情况,我们创建了一个字符串到空接口的映射:

birdJson := `{"birds":{"pigeon":"likes to perch on rocks","eagle":"bird of prey"},"animals":"none"}`
var result map[string]any
json.Unmarshal([]byte(birdJson), &result)

// The object stored in the "birds" key is also stored as 
// a map[string]any type, and its type is asserted from
// the `any` type
birds := result["birds"].(map[string]any)

for key, value := range birds {
  // Each value is an `any` type, that is type asserted as a string
  fmt.Println(key, value.(string))
}

 

每个字符串对应一个 JSON 属性,其映射的任意类型对应值,该值可以是任意类型。然后我们使用类型断言将任何类型转换为它的实际类型。
这些映射可以迭代,因此可以通过一个简单的 for 循环来处理未知数量的键。

验证 JSON 数据


在实际应用中,我们有时可能会得到无效(或不完整)的 JSON 数据。我们来看一个例子,其中部分数据被截断,生成的 JSON 字符串无效:

{
  "birds": {
    "pigeon":"likes to perch on rocks",
    "eagle":"bird of prey"


在实际应用中,这可能是由于网络错误或写入文件的数据不完整造成的

如果我们试图解组这个,我们的代码会恐慌:

birdJson := `{"birds":{"pigeon":"likes to perch on rocks","eagle":"bird of prey"`
var result map[string]any
json.Unmarshal([]byte(birdJson), &result)


输出:

panic: interface conversion: interface {} is nil, not map[string]interface {}

 

我们当然可以处理恐慌并从我们的代码中恢复,但这不是惯用的或可读的。

相反,我们可以使用 json.Valid 函数来检查我们的 JSON 数据的有效性:

if !json.Valid([]byte(birdJson)) {
    // handle the error here
    fmt.Println("invalid JSON string:", birdJson)
    return
}


现在,我们的代码将提前返回并给出输出:

invalid JSON string: {"birds":{"pigeon":"likes to perch on rocks","eagle":"bird of prey"


 

封送 JSON 数据


用于解码 JSON 字符串的相同规则也可以应用于编码。

编组结构化数据


让我们考虑之前的 Go 结构,并查看从其类型的数据中获取 JSON 字符串所需的代码:

package main

import (
    "encoding/json"
    "fmt"
)

// The same json tags will be used to encode data into JSON
type Bird struct {
    Species     string `json:"birdType"`
    Description string `json:"what it does"`
}

func main() {
    pigeon := &Bird{
        Species:     "Pigeon",
        Description: "likes to eat seed",
    }

    // we can use the json.Marhal function to
    // encode the pigeon variable to a JSON string
    data, _ := json.Marshal(pigeon)
    // data is the JSON string represented as bytes
    // the second parameter here is the error, which we
    // are ignoring for now, but which you should ideally handle
    // in production grade code

    // to print the data, we can typecast it to a string
    fmt.Println(string(data))
}

这将给出输出:

{"birdType":"Pigeon","what it does":"likes to eat seed"}


 

忽略空字段


在某些情况下,我们希望忽略 JSON 输出中的字段,如果它的值为空。为此,我们可以使用“omitempty”属性。

例如,如果鸽子对象的描述字段缺失,则在我们设置此属性的情况下,密钥将不会出现在编码的 JSON 字符串中:

package main

import (
    "encoding/json"
    "fmt"
)

type Bird struct {
    Species     string `json:"birdType"`
    // we can set the "omitempty" property as part of the JSON tag
    Description string `json:"what it does,omitempty"`
}

func main() {
    pigeon := &Bird{
        Species:     "Pigeon",
    }

    data, _ := json.Marshal(pigeon)

    fmt.Println(string(data))
}

这将为我们提供输出:

{"birdType":"Pigeon"}

 

如果我们想总是忽略一个字段,我们可以使用 json:"-" 结构标签来表示我们永远不希望包含这个字段:

package main

import (
    "encoding/json"
    "fmt"
)

type Bird struct {
    Species     string `json:"-"`
}

func main() {
    pigeon := &Bird{
        Species:     "Pigeon",
    }

    data, _ := json.Marshal(pigeon)

    fmt.Println(string(data))
}

此代码将始终打印一个空的 JSON 对象:

{}
 

编组切片


这与结构没有太大区别。我们只需要将切片或数组传递给 json.Marshal 函数,它就会像您期望的那样对数据进行编码:

pigeon := &Bird{
  Species:     "Pigeon",
  Description: "likes to eat seed",
}

// Now we pass a slice of two pigeons
data, _ := json.Marshal([]*Bird{pigeon, pigeon})
fmt.Println(string(data))

这将给出输出:

[{"birdType":"Pigeon","what it does":"likes to eat seed"},{"birdType":"Pigeon","what it does":"likes to eat seed"}]


 

编组地图


我们可以使用地图对非结构化数据进行编码。

map 的键需要是字符串,或者是可以转换为字符串的类型。这些值可以是任何可序列化的类型。

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // The keys need to be strings, the values can be
    // any serializable value
    birdData := map[string]any{
        "birdSounds": map[string]string{
            "pigeon": "coo",
            "eagle":  "squak",
        },
        "total birds": 2,
    }

    // JSON encoding is done the same way as before    
    data, _ := json.Marshal(birdData)
    fmt.Println(string(data))
}

输出:

{"birdSounds":{"eagle":"squak","pigeon":"coo"},"total birds":2}


最佳实践(结构与地图)


作为一般经验法则,如果您可以使用结构来表示您的 JSON 数据,那么您应该使用它们。 使用映射的唯一充分理由是由于数据中键或值的不确定性而无法使用结构。

如果我们使用映射,我们要么需要每个键具有相同的数据类型,要么使用泛型类型并稍后进行转换。

 

文章链接