conversion de type golang json

Dans Golang, JSON est un format de données important car il peut faciliter la transmission et le stockage des données. La conversion de type est une opération très courante lors du traitement des données JSON. Cet article présentera la conversion de type JSON dans Golang.

Type de données JSON

Avant d'effectuer la conversion de type JSON, nous devons comprendre les types de données dans JSON. Le type de données JSON ne correspond pas complètement au type de données dans Golang. Il existe les 6 types de données suivants dans JSON :

• Object (Object) : Entouré d'accolades {}, il représente une collection de paires clé-valeur, et des virgules sont utilisées entre les paires clé-valeur séparées.
• Array (Array) : Entouré de crochets [], il représente une liste ordonnée de valeurs, séparées par des virgules.
• String (String) : entouré de guillemets doubles", représentant une valeur de chaîne.
• Number (Number) : représentant une valeur numérique, qui peut être un entier ou un nombre à virgule flottante.
• Boolean (Boolean) : représentant un Valeur booléenne true ou false
• Null : représente un objet vide ou une valeur nulle

Dans Golang, nous pouvons utiliser les types suivants pour représenter les types de données JSON :

• Object : map[string]interface{}
• . Array : []interface{}
• String : string
• Valeur : float64
• Boolean : bool
• Valeur nulle : nil

Analyse et encodage JSON

Avant d'effectuer une conversion de type JSON, vous devez d'abord comprendre l'analyse JSON. et encoding .

Analyse JSON

Utilisez la méthode Decode dans le package encoding/json pour analyser une chaîne ou un tableau d'octets dans un objet JSON. Par exemple : encoding/json 包中的 Decode 方法，可以将一个字符串或字节数组解析为 JSON 对象。例如：

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

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

JSON 编码

通过 encoding/json 包中的 Encode 方法，可以将一个 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))
}

上述代码中，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 := `{"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)
}

上述代码中，我们首先将 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 := `{"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 对象中的 name 转换为 string 类型的 name。

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

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

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 字符串解析为 []interface{} 类型的 data 数组，通过输出可以看到 data 数组的每个元素都被正确解析了。

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

将 JSON 中的对象转换为 Golang 中的 map[string]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 字符串解析为 map[string]interface{} 类型的 data 对象，通过输出可以看到 data 对象中包含了两个键值对 name 和 age。

将 JSON 对象转换为结构体

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

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 对象中的键值对分别赋值给结构体 Personrrreee.

Dans le code ci-dessus, la méthode Unmarshal analyse la chaîne JSON en un objet Person Bien sûr, si nous voulons uniquement l'analyser en map[string]. interface{} Ou des types de données de base tels que []interface{} sont également possibles 🎜🎜Encodage JSON🎜🎜via la méthode Encode dans le encoding/json , vous pouvez encoder un objet JSON dans une chaîne ou un tableau d'octets. Par exemple : 🎜rrreee🎜Dans le code ci-dessus, la méthode Marshal encode la Person. dans une chaîne JSON Bien sûr, si nous voulons uniquement encoder des types de données de base tels que map[string]interface{} ou []interface{}, c'est également possible 🎜🎜Conversion de type JSON🎜🎜 Après avoir analysé les données JSON, nous pouvons convertir l'objet JSON en types de données de base dans Golang, tels que <code>int, stringcode>, <code>bool, etc., ou Convertir un tableau JSON en tableau dans Golang, ou convertir un objet JSON en structure dans Golang 🎜🎜Convertir les nombres JSON en int et float64🎜🎜Il existe deux façons de convertir des nombres en JSON vers les types de données en Golang. Les méthodes couramment utilisées sont <code>float64() et int(). Par exemple : 🎜rrreee🎜Dans le code ci-dessus, nous analysons d'abord la chaîne JSON dans un objet data de type map[string]interface{}, puis utilisons des assertions pour convertir l'objet <code>float en données est converti en <code>floatValue de type <code>float64 et int est converti en <code>intValue de type int. 🎜🎜Convertir une chaîne JSON en chaîne🎜🎜La conversion de chaînes en JSON en type string dans Golang est très simple, utilisez simplement des assertions. Par exemple : 🎜rrreee🎜Dans le code ci-dessus, nous analysons la chaîne JSON en un objet data de type map[string]interface{}, puis utilisons des assertions pour convertir les data Le <code>name dans l'objet est converti en name de type string. 🎜🎜Convertir un tableau JSON en []interface{}🎜🎜La conversion d'un tableau en JSON en type []interface{} dans Golang est très simple, utilisez simplement des assertions. Par exemple : 🎜rrreee🎜Dans le code ci-dessus, nous analysons la chaîne JSON dans un tableau data de type []interface{}. Vous pouvez voir data<. via la sortie> Chaque élément du tableau est analysé correctement. 🎜🎜Convertir des objets JSON en map[string]interface{}🎜🎜La conversion d'objets en JSON en type <code>map[string]interface{} dans Golang est également très simple, utilisez simplement des assertions. Par exemple : 🎜rrreee🎜Dans le code ci-dessus, nous analysons la chaîne JSON en un objet data de type map[string]interface{}. Vous pouvez voir . via la sortie L'objet data contient deux paires clé-valeur name et age. 🎜🎜Convertir des objets JSON en structures🎜🎜La conversion d'objets en JSON en structures en Golang nécessite de spécifier les champs de la structure, puis d'attribuer les valeurs des champs de structure via des assertions. Par exemple : 🎜rrreee🎜Dans le code ci-dessus, nous analysons la chaîne JSON en un objet data de type map[string]interface{}, puis utilisons des assertions pour convertir les data Les paires clé-valeur dans l'objet sont respectivement affectées aux champs de la structure Person. 🎜

Résumé

La conversion de type JSON dans Golang est très courante, vous devez donc en avoir une compréhension complète lors du traitement des données JSON. En introduisant les types de données JSON, les méthodes d'analyse et d'encodage JSON, la conversion de type JSON, etc. dans Golang, cet article espère aider les lecteurs à mieux appliquer Golang pour traiter les données JSON.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!