Heim  >  Artikel  >  Backend-Entwicklung  >  Golang-JSON-Typkonvertierung

Golang-JSON-Typkonvertierung

王林
王林Original
2023-05-13 11:09:07997Durchsuche

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
Wert: float64

Boolescher Wert: bool
  • 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
JSON-Kodierung

über die Methode Encode im Mit dem Paket „encoding/json“ können Sie ein JSON-Objekt in einen String oder ein Byte-Array kodieren:

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)
}

Im obigen Code kodiert die Methode Marshal die Person -Objekt in einen JSON-String umwandeln, wenn wir nur grundlegende Datentypen wie map[string]interface{} oder []interface{}codieren möchten >, es ist auch möglich

JSON-Typkonvertierung

encoding/json 包中的 Decode 方法,可以将一个字符串或字节数组解析为 JSON 对象。例如:

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 中的基础数据类型,例如 intstringbool 等,也可以将 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 对象中包含了两个键值对 nameage

将 JSON 对象转换为结构体

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

rrreee

上述代码中,我们将 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

🎜JSON-Zahlen in int und float64 konvertieren🎜🎜Es gibt zwei Möglichkeiten, Zahlen zu konvertieren in JSON zu Datentypen in Golang. Häufig verwendete Methoden sind <code>float64() und int(). Zum Beispiel: 🎜rrreee🎜Im obigen Code analysieren wir zunächst die JSON-Zeichenfolge in ein data-Objekt vom Typ map[string]interface{} und verwenden dann Assertionen dazu Konvertieren Sie das <code>float in data-Objekt in <code>floatValue vom Typ <code>float64 und int wird in <code>intValue vom Typ int konvertiert. 🎜🎜JSON-String in String konvertieren🎜🎜Das Konvertieren von Strings in JSON in den Typ string in Golang ist sehr einfach, verwenden Sie einfach Assertionen. Zum Beispiel: 🎜rrreee🎜Im obigen Code analysieren wir die JSON-Zeichenfolge in ein data-Objekt vom Typ map[string]interface{} und verwenden dann Assertionen zum Konvertieren Die data Der <code>name im -Objekt wird in name vom Typ string konvertiert. 🎜🎜Das Konvertieren eines JSON-Arrays in []interface{}🎜🎜Das Konvertieren eines Arrays in JSON in den Typ []interface{} in Golang ist sehr einfach, verwenden Sie einfach Behauptungen. Zum Beispiel: 🎜rrreee🎜Im obigen Code analysieren wir die JSON-Zeichenfolge in ein data-Array vom Typ []interface{}. Sie können data Jedes Element des Arrays wird korrekt analysiert. 🎜🎜Das Konvertieren von JSON-Objekten in „map[string]interface{}🎜🎜Das Konvertieren von Objekten in JSON in den Typ <code>map[string]interface{} in Golang ist ebenfalls sehr einfach, verwenden Sie einfach Behauptungen. Zum Beispiel: 🎜rrreee🎜Im obigen Code analysieren wir den JSON-String in ein data-Objekt vom Typ map[string]interface{}. Sie können sehen durch die Ausgabe Das Datenobjekt enthält zwei Schlüssel-Wert-Paare name und age. 🎜🎜JSON-Objekte in Strukturen konvertieren🎜🎜Das Konvertieren von Objekten in JSON in Strukturen in Golang erfordert die Angabe der Felder der Struktur und die anschließende Zuweisung der Strukturfeldwerte durch Zusicherungen. Zum Beispiel: 🎜rrreee🎜Im obigen Code analysieren wir die JSON-Zeichenfolge in ein data-Objekt vom Typ map[string]interface{} und verwenden dann Assertionen zum Konvertieren Die data Die Schlüssel-Wert-Paare im -Objekt werden jeweils den Feldern der Struktur Person zugeordnet. 🎜

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!

Stellungnahme:
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Vorheriger Artikel:Kommentare zur Golang-StrukturNächster Artikel:Kommentare zur Golang-Struktur