Golang-JSON-Typkonvertierung

In Golang ist JSON ein wichtiges Datenformat, da es die Datenübertragung und -speicherung erleichtern kann. Die Typkonvertierung ist ein sehr häufiger Vorgang bei der Verarbeitung von JSON-Daten. In diesem Artikel wird die JSON-Typkonvertierung in Golang vorgestellt.

JSON-Datentyp

Bevor wir die JSON-Typkonvertierung durchführen, müssen wir die Datentypen in JSON verstehen. Der JSON-Datentyp entspricht nicht vollständig dem Datentyp in Golang. Es gibt die folgenden 6 Datentypen in JSON:

• Object (Objekt): Umgeben von geschweiften Klammern {} stellt es eine Sammlung von Schlüssel-Wert-Paaren dar. und Kommas werden zwischen Schlüssel-Wert-Paaren getrennt.
• Array (Array): Eingerahmt in eckige Klammern [] stellt es eine geordnete Liste von Werten dar, die durch Kommas getrennt sind.
• String (String): umgeben von doppelten Anführungszeichen ", repräsentiert einen String-Wert.
• Number (Number): repräsentiert einen numerischen Wert, der eine Ganzzahl oder eine Gleitkommazahl sein kann.
• Boolean (Boolean): repräsentiert a Boolescher Wert „true“ oder „false“ Array: []interface{}
• String: string

• Nullwert: Null
• JSON-Analyse und -Codierung
• Bevor Sie die JSON-Typkonvertierung durchführen, müssen Sie zunächst die JSON-Analyse verstehen und Kodierung.
• JSON-Analyse
• Verwenden Sie die Methode Decode im Paket encoding/json, um einen String oder ein Byte-Array in ein JSON-Objekt zu analysieren
• Im obigen Code analysiert die Methode Unmarshal die JSON-Zeichenfolge in ein Objekt Person. Natürlich, wenn wir sie nur in map[string] analysieren möchten. interface{} Oder grundlegende Datentypen wie []interface{} sind ebenfalls möglich

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name    string
    Age     int
    Address string
}

func main() {
    jsonStr := `{"Name": "Tom", "Age": 18, "Address": "Beijing"}`
    var p Person
    err := json.Unmarshal([]byte(jsonStr), &p)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(p.Name, p.Age, p.Address)
}

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name    string
    Age     int
    Address string
}

func main() {
    p := Person{Name: "Tom", Age: 18, Address: "Beijing"}
    jsonString, err := json.Marshal(p)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(jsonString))
}

上述代码中，Unmarshal 方法将 JSON 字符串解析为 Person 对象，当然如果我们只想解析为 map[string]interface{} 或 []interface{} 等基础数据类型也是可以的。

JSON 编码

通过 encoding/json 包中的 Encode 方法，可以将一个 JSON 对象编码为一个字符串或字节数组。例如：

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonStr := `{"float": 1.23, "int": 456}`
    var data map[string]interface{}
    err := json.Unmarshal([]byte(jsonStr), &data)
    if err != nil {
        fmt.Println(err)
        return
    }

    floatValue := data["float"].(float64)
    intValue := int(data["int"].(float64))
    fmt.Println(floatValue, intValue)
}

上述代码中，Marshal 方法将 Person 对象编码为 JSON 字符串。当然，如果我们只想编码 map[string]interface{} 或 []interface{} 等基础数据类型也是可以的。

JSON 类型转换

在解析 JSON 数据后，我们可以将 JSON 对象转换为 Golang 中的基础数据类型，例如 int、string、bool 等，也可以将 JSON 数组转换为 Golang 中的数组，或是将 JSON 对象转换为 Golang 中的结构体。

将 JSON 数字转换为 int 和 float64

将 JSON 中的数字转换为 Golang 中的数据类型有两种常用方式，分别是 <code>float64() 和 int()。例如：

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonStr := `{"name": "Tom"}`
    var data map[string]interface{}
    err := json.Unmarshal([]byte(jsonStr), &data)
    if err != nil {
        fmt.Println(err)
        return
    }

    name := data["name"].(string)
    fmt.Println(name)
}

上述代码中，我们首先将 JSON 字符串解析为 map[string]interface{} 类型的 data 对象，然后通过断言将 data 对象中的 <code>float 转换为 <code>float64 类型的 <code>floatValue 和 int 转换为 int 类型的 <code>intValue。

将 JSON 字符串转换为 string

将 JSON 中的字符串转换为 Golang 中的 string 类型很简单，直接通过断言即可。例如：

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonStr := `["Tom", 18, 1.23]`
    var data []interface{}
    err := json.Unmarshal([]byte(jsonStr), &data)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(data)
}

上述代码中，我们将 JSON 字符串解析为 map[string]interface{} 类型的 data 对象，然后通过断言将 data 对象中的 name 转换为 string 类型的 name。

将 JSON 数组转换为 []interface{}

将 JSON 中的数组转换为 Golang 中的 []interface{} 类型很简单，直接通过断言即可。例如：

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonStr := `{"name": "Tom", "age": 18}`
    var data map[string]interface{}
    err := json.Unmarshal([]byte(jsonStr), &data)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(data)
}

上述代码中，我们将 JSON 字符串解析为 []interface{} 类型的 data 数组，通过输出可以看到 data 数组的每个元素都被正确解析了。

将 JSON 对象转换为 map[string]interface{}

将 JSON 中的对象转换为 Golang 中的 map[string]interface{} 类型也很简单，直接通过断言即可。例如：

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name    string
    Age     int
    Address string
}

func main() {
    jsonStr := `{"Name": "Tom", "Age": 18, "Address": "Beijing"}`
    var data map[string]interface{}
    err := json.Unmarshal([]byte(jsonStr), &data)
    if err != nil {
        fmt.Println(err)
        return
    }

    p := Person{
        Name:    data["Name"].(string),
        Age:     int(data["Age"].(float64)),
        Address: data["Address"].(string),
    }
    fmt.Println(p)
}

上述代码中，我们将 JSON 字符串解析为 map[string]interface{} 类型的 data 对象，通过输出可以看到 data 对象中包含了两个键值对 name 和 age。

将 JSON 对象转换为结构体

将 JSON 中的对象转换为 Golang 中的结构体需要指定结构体的字段，然后通过断言将结构体字段值进行赋值。例如：

上述代码中，我们将 JSON 字符串解析为 map[string]interface{} 类型的 data 对象，然后通过断言将 data 对象中的键值对分别赋值给结构体 Person Nach dem Parsen der JSON-Daten können wir das JSON-Objekt in grundlegende Datentypen in Golang konvertieren, wie z. B. int, stringcode>, <code>bool usw. oder JSON-Array in Array in Golang konvertieren oder JSON-Objekt in Struktur in Golang konvertieren

Zusammenfassung

Die JSON-Typkonvertierung in Golang ist sehr verbreitet, daher sollten Sie bei der Verarbeitung von JSON-Daten ein umfassendes Verständnis davon haben. Durch die Einführung von JSON-Datentypen, JSON-Analyse- und Codierungsmethoden, JSON-Typkonvertierung usw. in Golang möchte dieser Artikel den Lesern helfen, Golang besser für die Verarbeitung von JSON-Daten anzuwenden.

Das obige ist der detaillierte Inhalt vonGolang-JSON-Typkonvertierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!