首页 > 资讯 > 后端开发 > GO >在Go中使用JSON(附demo)

363

分享到

在Go中使用JSON(附demo)

2024-04-02 19:04:59 363人浏览独家记忆

摘要

目录Go编码/JSON包编码。将Go对象转换为jsON什么是Go中的marshaling？装载简单对象对复杂对象进行编码集合功能重命名字段生成具有缩进功能的JSON（pretty-p

Go编码/json包

Go提供了encoding/json包，通过标准库的编码命名空间处理JSON内容。encoding/json包提供了api函数，用于从Go对象生成JSON文档--以及从JSON文档中填充Go对象。此外，它还允许你定制JSON到Go和Go到JSON的翻译过程。

JSON规范同时支持格式化和内联（minified）文档。因此，Go encoding/json包可以让开发者同时生成格式化和最小化的JSON文档。

编码。将 Go 对象转换为 JSON

什么是Go中的marshaling？

将Go对象编码为JSON格式被称为marshaling。我们可以使用Marshal 函数来将 Go 对象转换为 JSON。Marshal 函数的语法如下。

func Marshal(v interface{}) ([]byte, error)

它接受一个空接口。换句话说，你可以向该函数提供任何Go数据类型--整数、浮点、字符串、结构体、地图等--因为所有Go数据类型定义都可以用空接口表示。它返回两个值：一个编码JSON的字节片和error 。

装载简单对象

如上所述，我们可以用原始的Go数据类型生成JSON。例如，你可以将Go字符串转换为JSON字符串。

但由于转换基元在现实世界的软件开发项目中没有帮助，让我们从转换一些简单对象开始。下面的代码片断将从一个map数据结构中编码JSON。

package main
import (
    "fmt"
    "encoding/json"
)
func main() {
    fileCount := map[string]int{
        "cpp": 10,
        "js": 8,
        "go": 10,
    }
    bytes, _ := json.Marshal(fileCount)
    fmt.Println(string(bytes))
}

这里我们使用string() ，将字节转换为字符串。Go将map数据结构编码为JSON键值对象。一旦你运行上述代码，你将得到如下所示的输出。

你也可以从一个结构中对JSON进行编码，如下面的示例代码所示。

package main
import (
    "fmt"
    "encoding/json"
)
type Book struct {
    Title string
    Author string
    Year int
}
func main() {
    myBook := Book{"Hello Golang", "John Mike", 2021}
    bytes, _ := json.Marshal(myBook)
    fmt.Println(string(bytes))
}

在这里，我们必须以大写的英文字母开始结构字段名，以使这些字段可以导出到其他软件包。如果你的结构包含一个以小写字母开头的字段，那么编码/json包在编码过程中不会包含这个特定的字段，也不会出现任何错误。

上述代码将输出以下JSON结构。

{"Title":"Hello Golang","Author":"John Mike","Year":2021}

对复杂对象进行编码

在前面的例子中，我们从Go对象中编码了JSON，比如简单的map和structs。如果你试图对整数数组、字符串数组和原始变量进行编码，Go将为这些元素产生简单的JSON结构。

但大多数时候，我们必须从Go程序中的复杂对象中生成JSON文件，如产品列表、产品详情和各种嵌套数据记录。

首先，让我们从一个产品列表中对JSON进行编码。请看下面的示例代码。

package main
import (
    "fmt"
    "encoding/json"
)
type Seller struct {
    Id int
    Name string
    CountryCode string
}
type Product struct {
    Id int
    Name string
    Seller Seller
    Price int
}
func main() {
    products := []Product{
        Product {
            Id: 50,
            Name: "Writing Book",
            Seller: Seller {1, "ABC Company", "US"},
            Price: 100,
        },
        Product {
            Id: 51,
            Name: "Kettle",
            Seller: Seller {20, "John Store", "DE"},
            Price: 500,
        },
    }
    bytes, _ := json.Marshal(products)
    fmt.Println(string(bytes))
}

上面的代码初始化了一个有两个项目的产品列表。Product 结构有一个Seller 结构作为嵌套对象--所有的产品都放在一个产品片中。接下来，我们将最终的产品列表发送到Marshal 函数，将其编码为JSON结构。

一旦你运行上述代码片断，你将得到以下输出。

[{"Id":50,"Name":"Writing Book","Seller":{"Id":1,"Name":"ABC Company","CountryCode":"US"},"Price":100},{"Id":51,"Name":"Kettle","Seller":{"Id":20,"Name":"John Store","CountryCode":"DE"},"Price":500}]

正如你所看到的，Go可以从任何复杂的Go数据结构中编码JSON。但是现在，当我们看上面的输出时，我们有两个问题。

输出的JSON结构的键总是以大写的英文字母开始--我们怎样才能重命名JSON字段？
当我们对大型复杂的结构进行编码时，输出结果变得简直无法阅读--我们如何才能美化JSON的输出？

Go encoding/json软件包通过额外的库功能回答了上述问题。

集合功能

Go提供了几个功能，通过额外的API函数和结构标签改善和定制JSON输出。

重命名字段

你必须以大写英文字母开始结构字段的声明，以便让JSON包访问它们。因此，你将永远得到大写的英文字母作为JSON键。Go编码/json包允许开发人员通过JSON结构标签随意重命名JSON字段。

下面的代码片断对产品对象的JSON进行编码，并使用蛇形大小写的JSON键。

package main
import (
    "fmt"
    "encoding/json"
)
type Seller struct {
    Id int `json:"id"`
    Name string `json:"name"`
    CountryCode string `json:"country_code"`
}
type Product struct {
    Id int `json:"id"`
    Name string `json:"name"`
    Seller Seller `json:"seller"`
    Price int `json:"price"`
}
func main() {
    book := Product{
        Id: 50,
        Name: "Writing Book",
        Seller: Seller {1, "ABC Company", "US"},
        Price: 100,
    }
    bytes, _ := json.Marshal(book)
    fmt.Println(string(bytes))
}

正如你所看到的，上面的代码使用结构标签来重命名每个导出的字段。结构标签不是JSON编码过程中的必选元素--它是一个可选的元素，在JSON编码过程中重命名一个特定的结构字段。

一旦你执行上述代码，你将得到以下输出。

{"id":50,"name":"Writing Book","seller":{"id":1,"name":"ABC Company","country_code":"US"},"price":100}

生成具有缩进功能的JSON（pretty-print）

Marshal 函数生成最小的内联JSON内容，没有任何格式化。你可以使用MarshalIndent 函数来编码具有缩进功能的可读JSON。下面的代码为上一个结构对象生成了prettified JSON。

package main
import (
    "fmt"
    "encoding/json"
)
type Seller struct {
    Id int `json:"id"`
    Name string `json:"name"`
    CountryCode string `json:"country_code"`
}
type Product struct {
    Id int `json:"id"`
    Name string `json:"name"`
    Seller Seller `json:"seller"`
    Price int `json:"price"`
}
func main() {
    book := Product{
        Id: 50,
        Name: "Writing Book",
        Seller: Seller {1, "ABC Company", "US"},
        Price: 100,
    }
    bytes, _ := json.MarshalIndent(book, "", "\t")
    fmt.Println(string(bytes))
}

一旦你运行上述代码，它将打印出一个格式化的JSON结构，如下图所示。

这里我们使用Tab字符(\t)进行缩进。你可以根据你的要求使用四个空格、两个空格、八个空格等进行格式化。

忽略JSON输出中的特定字段

早些时候，我们使用结构标签来重命名JSON键。我们也可以使用结构标签来省略特定字段。如果我们使用json:”-” 作为标签，相关的结构字段将不会被用于编码。另外，如果我们在结构标签名称字符串中使用,omitempty ，如果相关字段的值为空，则不会被用于编码。

下面的代码省略了产品标识符的编码。此外，它还从输出中省略了空的国家代码值。

package main
import (
    "fmt"
    "encoding/json"
)
type Seller struct {
    Id int `json:"id"`
    Name string `json:"name"`
    CountryCode string `json:"country_code,omitempty"`
}
type Product struct {
    Id int `json:"-"`
    Name string `json:"name"`
    Seller Seller `json:"seller"`
    Price int `json:"price"`
}
func main() {
    products := []Product{
        Product {
            Id: 50,
            Name: "Writing Book",
            Seller: Seller {Id: 1, Name: "ABC Company", CountryCode: "US"},
            Price: 100,
        },
        Product {
            Id: 51,
            Name: "Kettle",
            Seller: Seller {Id: 20, Name: "John Store"},
            Price: 500,
        },
    }
    bytes, _ := json.MarshalIndent(products, "", "\t")
    fmt.Println(string(bytes))
}

上述代码产生以下输出。注意，它不包含产品标识符和第二项的国家代码键。

解除伪装。将JSON转换为Go对象

在Go环境中，JSON文档的解码过程被称为unmarshaling。我们可以使用Unmarshal 函数来将JSON转换为Go对象。Unmarshal 函数的语法如下。

func Unmarshal(data []byte, v interface{}) error

它接受两个参数：一个JSON内容的字节片和一个空的接口引用。如果在解码过程中出现错误，该函数可能会返回一个错误。Unmarshal 函数不创建和返回Go对象，所以我们必须传递一个引用来存储解码后的内容。

解除对简单JSON结构的封存

类似于JSON的marshaling，我们可以解封Go的原始数据类型，如整数、字符串、浮点数和布尔。但同样的，由于原始数据解密在大多数软件开发项目中没有真正的使用案例，我们先将下面的键值结构解码为Go结构。

{
    "width": 500,
    "height": 200,
    "title": "Hello Go!"
}

下面的代码将上述JSON结构解码成一个结构。

package main
import (
    "fmt"
    "encoding/json"
)
type Window struct {
    Width int `json:"width"`
    Height int `json:"height"`
    Title string `json:"title"`
}
func main() {
    jsonInput := `{
        "width": 500,
        "height": 200,
        "title": "Hello Go!"
    }`
    var window Window
    err := json.Unmarshal([]byte(jsonInput), &window)

    if err != nil {
        fmt.Println("JSON decode error!")
        return
    }

    fmt.Println(window) // {500 200 Hello Go!}
}

jsonInput 变量将JSON内容作为一个多行字符串保存。因此，在用byte[]() 类型转换语法将其传递给Unmarshal 函数之前，我们必须将其转换为字节片状。在这里，我们检查了返回的错误对象的值以检测解析错误。

在这种情况下，上述JSON标签是可选的，因为Go编码/json包通常将JSON字段映射为结构字段，并进行不区分大小写的匹配。

同样地，我们也可以将JSON结构解码为Go映射。请看下面的示例代码。

package main
import (
    "fmt"
    "encoding/json"
)
func main() {
    jsonInput := `{
        "apples": 10,
        "mangos": 20,
        "grapes": 20
    }`
    var fruitBasket map[string] int
    err := json.Unmarshal([]byte(jsonInput), &fruitBasket)

    if err != nil {
        fmt.Println("JSON decode error!")
        return
    }

    fmt.Println(fruitBasket) // map[apples:10 grapes:20 mangos:20]
}

解除复杂数据结构的束缚

之前的解密例子向你展示了如何对简单的JSON结构进行解密。我们在软件开发项目中经常要对复杂的嵌套JSON结构进行解码。下面的例子演示了如何从一个JSON格式的产品列表中填充Go对象。

package main
import (
    "fmt"
    "encoding/json"
)
type Product struct {
    Id int `json:"id"`
    Name string `json:"name"`
    Seller struct {
        Id int `json:"id"`
        Name string `json:"name"`
        CountryCode string `json:"country_code"`
    } `json:"seller"`
    Price int `json:"price"`
}
func main() {
    jsonInput := `[
    {
        "id":50,
        "name":"Writing Book",
        "seller":{
            "id":1,
            "name":"ABC Company",
            "country_code":"US"
        },
        "price":100
    },
    {
        "id":51,
        "name":"Kettle",
        "seller":{
            "id":20,
            "name":"John Store",
            "country_code":"DE"
        },
        "price":500
    }]
    `
    var products []Product
    err := json.Unmarshal([]byte(jsonInput), &products)

    if err != nil {
        fmt.Println("JSON decode error!")
        return
    }

    fmt.Println(products)
    // [{50 Writing Book {1 ABC Company US} 100} {51 Kettle {20 John Store DE} 500}]
}

如上面的代码所示，我们需要先通过检查JSON输入来定义一个结构。当你处理大型复杂的JSON结构时，这个过程是一个耗时的任务。因此，你可以使用JSON-to-Go这样的在线工具，根据JSON输入创建结构定义。

也有一种方法可以在Go中不创建结构而访问解析后的值。你可以通过为JSON对象创建map[string]interface{} 类型对象来动态访问任何值，但这种方法会导致非常复杂、质量较差的源代码。

不过，你可以通过下面的示例代码检查动态JSON值的访问，以达到实验目的。但是，在没有建立适当的Go结构的情况下，不要在生产软件系统中使用这种方法，因为它会产生复杂和难以测试的代码。

package main
import (
    "fmt"
    "encoding/json"
)
func main() {
    jsonInput := `[
    {
        "id":50,
        "name":"Writing Book",
        "seller":{
            "id":1,
            "name":"ABC Company",
            "country_code":"US"
        },
        "price":100
    },
    {
        "id":51,
        "name":"Kettle",
        "seller":{
            "id":20,
            "name":"John Store",
            "country_code":"DE"
        },
        "price":500
    }]
    `
    var objMap []map[string]interface{}
    err := json.Unmarshal([]byte(jsonInput), &objMap)

    if err != nil {
        fmt.Println("JSON decode error!")
        return
    }

    fmt.Println("Price of the second product:", objMap\[1\]["price"])
}

上面的代码在没有Go结构的情况下打印了第二个产品项目的价格。

从文件系统中读取JSON文件

我们在前面的例子中使用了硬编码的JSON字符串进行演示。但是，在实践中，我们从不同的来源加载JSON字符串：从文件系统，通过互联网，通过本地网络位置，等等。大多数程序员通常使用JSON格式来存储文件系统上的配置细节。

让我们写一些Go代码，从文件中读取和解码JSON数据，并将其转换成Go对象。首先，创建一个名为config.json 的文件并输入以下内容。

{
    "timeout": 50.30,
    "pluginsPath": "~/plugins/",
    "window": {
        "width": 500,
        "height": 200,
        "x": 500,
        "y": 500
    }
}

现在，运行以下代码，将上述JSON文件解码为合适的结构。

package main
import (
    "fmt"
    "io/ioutil"
    "encoding/json"
)
type Config struct {
    Timeout float32
    PluginsPath string
    Window struct {
        Width int
        Height int
        X int
        Y int
    }
}
func main() {

    bytes, err := ioutil.ReadFile("config.json")

    if err != nil {
        fmt.Println("Unable to load config file!")
        return
    }

    var config Config
    err = json.Unmarshal(bytes, &config)

    if err != nil {
        fmt.Println("JSON decode error!")
        return
    }

    fmt.Println(config) // {50.3 ~/plugins/ {500 200 500 500}}
}

上面的代码用ioutil.ReadFile 函数将JSON文件内容读成字节，并将数据记录解码到Config 结构中。

将JSON文件写到文件系统中

在前面的例子中，我们通过Println 函数将编码后的JSON内容打印到控制台。现在我们可以通过ioutil.WriteFile 函数将这些JSON字符串保存为文件，如下图所示。

package main
import (
    "io/ioutil"
    "encoding/json"
)
type Window struct {
    Width int `json:"width"`
    Height int `json:"height"`
    X int `json:"x"`
    Y int `json:"y"`
}
type Config struct {
    Timeout float32 `json:"timeout"`
    PluginsPath string `json:"pluginsPath"`
    Window Window `json:"window"`
}
func main() {
    config := Config {
        Timeout: 40.420,
        PluginsPath: "~/plugins/etc",
        Window: Window {500, 200, 20, 20},
    }
    bytes, _ := json.MarshalIndent(config, "", "  ")
    ioutil.WriteFile("config.json", bytes, 0644)
}

上面的代码通过将config 对象编码为JSON对象来写入config.json 。这里我们使用了两个空格来缩进，并通过使用结构标签将结构字段转换为骆驼大写的JSON键。

自定义抓取和解除抓取

Go json包非常灵活，它提供了覆盖编码和解码过程的功能。当您在编码/解码过程中需要将JSON数据记录从一种格式转换为另一种格式时，这些功能很有帮助。

自定义编排

假设你正在用Go编写一个联系人管理应用程序，你提供一个功能给所有用户下载JSON格式的联系人列表。假设由于安全策略的原因，你不能让非管理员用户看到所有的电子邮件ID。在这种情况下，你可以通过Go json包中的自定义marshaling功能来定制JSON编码过程，如下所示。

package main
import (
    "fmt"
    "encoding/json"
    "strings"
)
type Person struct {
    Name string `json:"name"`
    Age int `json:"age"`
    Email string `json:"-"`
}
func main() {
    persons := []Person {
            Person {"James Henrick", 25, "james.h@gmail.com"},
            Person {"David Rick", 30, "rick.dvd@yahoo.com"},
    }
    bytes, _ := json.MarshalIndent(persons, "", "  ")
    fmt.Println(string(bytes))
}
func (p *Person) MarshalJSON() ([]byte, error) {
    type PersonAlias Person
    return json.Marshal(&struct{
        *PersonAlias
        Email string `json:"email"`
    }{
        PersonAlias: (*PersonAlias)(p),
        Email: strings.Repeat("*", 4) + "@mail.com", // alter email
    })
}

上面的代码输出了所有的联系方式，但由于安全策略的原因，它改变了原始的电子邮件地址。请注意，这里我们需要从Person 类型中创建另一个类型(alias)，因为如果我们试图为原来的Person 类型调用Marshal 函数，由于编码过程的递归实现，程序将进入无限循环。一旦你运行上述代码片断，你会看到如下的输出。

自定义解密

Go json包也可以让你自定义JSON解码过程。假设你需要处理一个JSON配置文件，并需要在解码过程中转换一些值。假设一个配置字段说的是开尔文的温度，但你需要用摄氏度来存储具体数值。

请看下面的代码，它实现了自定义解密。

package main
import (
    "fmt"
    "encoding/json"
)
type Config struct {
    FunctionName string 
    Temperature float32
}
func main() {
    jsonInput := `{
        "functionName": "triggerModule",
        "temperature": 4560.32
    }`
    var config Config
    err := json.Unmarshal([]byte(jsonInput), &config)

    if err != nil {
        fmt.Println("JSON decode error!")
        return
    }

    fmt.Println(config) // {triggerModule 4287.17}
}
func (c *Config) UnmarshalJSON(data []byte) error {
    type ConfigAlias Config
    tmp := struct {
        Temperature float32
        *ConfigAlias
    }{
        ConfigAlias: (*ConfigAlias)(c),
    }
    if err := json.Unmarshal(data, &tmp); err != nil {
        return err
    }
    c.Temperature = tmp.Temperature - 273.15
    return nil
}

上述代码通过将temperature 字段的值从开尔文转换为摄氏度来解读JSON。这里我们还需要创建另一个类型(alias)，以避免无限循环，这与自定义的marshaling类似。

总结

在本教程中，我们通过实际例子讨论了Go中的JSON编码（marshaling）和解码（unmarshaling）。JSON是一种广泛使用的、独立于语言的编码格式。因此，几乎所有基于Go的网络框架都在内部处理JSON编码和解码。例如，GinHttp框架允许你使用json包直接向API函数发送一个结构体，而不需要手动进行marshaling。

然而，你可以在你的Go程序中使用Go json包，而不需要消耗第三方库，因为json包是标准库的一部分。另外，Go json包还有一些更快的替代品（根据这个基准）。但是，json包是标准库的一部分，由Go开发团队维护。因此，Go开发团队会在即将发布的版本中提高编码/json包的性能。

到此这篇关于在Go中使用JSON(附demo)的文章就介绍到这了,更多相关Go使用JSON内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

Go语言（Golang）教程

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 在Go中使用JSON(附demo)

本文链接: https://www.lsjlt.com/news/140500.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

在Go中使用JSON(附demo)

目录Go编码/json包编码。将Go对象转换为JSON什么是Go中的marshaling？装载简单对象对复杂对象进行编码集合功能重命名字段生成具有缩进功能的JSON（pretty-p...

99+

2024-04-02
在Go中如何使用Json

小编给大家分享一下在Go中如何使用Json，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！ &...

99+

2023-06-22
在 Go 中解组 JSON 中的 JSON

php小编西瓜将为您介绍在Go语言中解析JSON的方法。在开发过程中，处理JSON数据是一项常见的任务。Go语言提供了强大而简单的方式来解组JSON数据，并将其映射到Go语言的结构体中...

99+

2024-02-09

go语言标准库
Go语言中websocket的使用demo分享

服务端代码 main.go package main import ( "errors" "fmt" "net/http" "sync" "time"...

99+

2022-12-28

Go语言 websocket使用 Go语言 websocket Go websocket
如何在 Go 中使用非必需的 JSON 参数？

php小编鱼仔为您带来关于在Go语言中如何使用非必需的JSON参数的技巧。在编写Go程序时，我们经常需要处理JSON数据，有时候我们可能只需要使用其中的一部分参数，而不需要全部参数。本...

99+

2024-02-12

go语言
怎么在Go语言中使用JSON进行请求

这篇文章主要介绍“怎么在Go语言中使用JSON进行请求”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“怎么在Go语言中使用JSON进行请求”文章能帮助大家解决问题。Go语言提供了许多方式发送HTTP请...

99+

2023-07-06
Go中JSON解析时tag的使用

目录struct成员变量标签（Tag）说明struct成员变量标签（Tag）获取自定义tag在处理json格式字符串的时候，经常会看到声明struct结构的时候，属性的右侧还有反引号...

99+

2024-04-02
JSON在Java中如何使用

本篇内容主要讲解“JSON在Java中如何使用”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“JSON在Java中如何使用”吧!1 为什么要使用JSON简介JSON（JavaScript Obje...

99+

2023-07-05
聊聊如何在Go语言中使用JSON进行请求

在现代Web技术中，JSON已经成为了主流的数据格式。Go语言中的json包提供了一系列用于JSON编解码的函数和结构体，使得使用JSON变得非常方便。本文将介绍如何在Go语言中使用JSON进行请求。Go语言提供了许多方式发送HTTP请求，...

99+

2023-05-14
如何在 Go 中使用正则表达式解析 JSON 日期？

如何使用正则表达式解析 json 日期？使用正则表达式 "^(\d{4})-(\d{2})-(\d{2})t(\d{2}):(\d{2}):(\d{2})(.\d+)z$" 匹配格式为 ...

99+

2024-05-14

json 正则表达式
Java安全框架——Shiro的使用详解(附springboot整合Shiro的demo)

目录Shiro简介 Shiro快速入门 SpringBoot-Shiro整合（最后会附上完整代码）附上最后的完整代码 Shiro整合mybatis 认证搞完了，我们再来看看授权 S...

99+

2024-04-02
如何使用 Gin-Gonic 在 Go 中读取蛇形 JSON 请求正文

各位小伙伴们，大家好呀！看看今天我又给各位带来了什么文章？本文标题是《如何使用 Gin-Gonic 在 Go 中读取蛇形 JSON 请求正文》，很明显是关于Golang的文章哈哈哈，其中内容主要会涉...

99+

2024-04-04
Vue.js中使用道具方法demo

目录正文什么是Vue.js中的props？那么，你为什么要使用props呢？如何在Vue.js中使用props？在Vue中使用props与Composition API在Vue.js...

99+

2022-12-14

Vue.js道具使用 Vue.js 道具
如何使用 gin gonic 在 Go 中上传多部分文件和 json？

来到编程网的大家，相信都是编程学习爱好者，希望在这里学习Golang相关编程知识。下面本篇文章就来带大家聊聊《如何使用 gin gonic 在 Go 中上传多部分文件和 json？》，介绍一下，希望...

99+

2024-04-05
如何在HTML5中使用json对象

这期内容当中小编将会给大家带来有关如何在HTML5中使用json对象，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。具体代码如下所示：<!DOCTYPE html><html&g...

99+

2023-06-09
使用 PHP 在邮件中发送附件

我们将介绍在 PHP 中通过电子邮件发送附件的不同方法。使用 PHPMailer 在电子邮件中发送附件我们可以使用 PHPMailer 类来发送电子邮件，允许我们发送附件。我们可以创建一个...

99+

2024-02-27
怎么在PHP语言中使用JSON

这篇文章主要介绍“怎么在PHP语言中使用JSON”，在日常操作中，相信很多人在怎么在PHP语言中使用JSON问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”怎么在PHP语言中使用JSON”的疑惑有所帮助！接下来...

99+

2023-06-17
go语言中使用struct解析嵌套的json

问题内容无法使用 go lang 将嵌套 json 解析为结构对象我有一个嵌套的 json 字符串，我想使用 go 语言中的结构体来解析它。 json 看起来像这样 {"actio...

99+

2024-02-06

go语言
Go 语言 JSON 标准库的使用

目录序列化1. 结构体序列化2. 字典序列化3. 切片序列化反序列化1. 明确知道 JSON 格式2. 无法确定 JSON 格式Go 语言中的 encoding/json 库提供了复...

99+

2024-04-02
深入浅析JSON在java中的使用

一、javaBean和json的互转 JavaBean类 public class Person { private Integer id; private St...

99+

2024-04-02