golang json type conversion

In Golang, JSON is an important data format because it can facilitate data transmission and storage. Type conversion is a very common operation when processing JSON data. This article will introduce JSON type conversion in Golang.

JSON data type

Before performing JSON type conversion, we need to understand the data types in JSON. The JSON data type does not completely correspond to the data type in Golang. There are the following 6 data types in JSON:

• Object (Object): Surrounded by curly brackets {}, it represents a collection of key-value pairs. Use commas to separate pairs of values.
• Array (Array): Surrounded by square brackets [], it represents an ordered list of values, separated by commas.
• String (String): Surrounded by double quotes ", it represents a string value.
• Number (Number): It represents a numeric value, which can be an integer or a floating point number.
• Boolean: Represents a Boolean value true or false.
• Null: Represents an empty object or empty value.

In Golang, we can use the following types To represent JSON data type:

• Object: map[string]interface{}
• Array: []interface{}
• String: string
• Value: float64
• Boolean: bool
• Null value: nil

JSON parsing and encoding

Before JSON type conversion , first you need to understand JSON parsing and encoding.

JSON parsing

You can convert a string through the Decode method in the encoding/json package Or a byte array is parsed into a JSON object. For example:

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

In the above code, the Unmarshal method parses the JSON string into a Person object. Of course, if we only want It is also possible to parse into basic data types such as map[string]interface{} or []interface{}.

JSON encoding

pass encoding/json The Encode method in the package can encode a JSON object into a string or byte array. For example:

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

In the above code, # The ##Marshal method encodes the Person object into a JSON string. Of course, if we only want to encode map[string]interface{} or []interface{ } and other basic data types are also possible.

JSON type conversion

After parsing the JSON data, we can convert the JSON object to the basic data type in Golang, such as

int, string, bool, etc. You can also convert JSON arrays to arrays in Golang, or convert JSON objects to structures in Golang.

Convert JSON numbers to int and float64

There are two common ways to convert numbers in JSON to data types in Golang, namely

float64() and int(). For example:

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

In the above code, we first parse the JSON string into a

data object of type map[string]interface{}, and then # through assertions float in the ##data object is converted to floatValue of type float64 and int is converted to int Type intValue. Convert JSON string to string

Convert the string in JSON to the

string

type in Golang is very simple, just use assertions. For example: <pre class='brush:php;toolbar:false;'>import ( &quot;encoding/json&quot; &quot;fmt&quot; ) func main() { jsonStr := `{&quot;name&quot;: &quot;Tom&quot;}` var data map[string]interface{} err := json.Unmarshal([]byte(jsonStr), &amp;data) if err != nil { fmt.Println(err) return } name := data[&quot;name&quot;].(string) fmt.Println(name) }</pre>In the above code, we parse the JSON string into a

data

object of type map[string]interface{}, and then ## through assertions name in the #data object is converted to name of type string. Convert JSON array to []interface{}

Convert array in JSON to

[]interface{}

type in Golang is very simple, directly through assertion That’s it. For example:

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

In the above code, we parse the JSON string into a data

array of type

[]interface{}. You can see through the output Each element of the data array is parsed correctly. Convert JSON objects to map[string]interface{}

Convert objects in JSON to

map[string]interface{}

The type is also very Simple, just pass assertions directly. For example:

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

In the above code, we parse the JSON string into a data

object of type

map[string]interface{}, which can be seen through the output# The ##data object contains two key-value pairs name and age. Convert JSON object to structureConverting an object in JSON to a structure in Golang requires specifying the fields of the structure, and then assigning the structure field values ​​through assertions. For example:

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

In the above code, we parse the JSON string into a

data

object of type

map[string]interface{}

, and then ## through assertions #data The key-value pairs in the object are assigned to the fields of the structure Person.

Summary

JSON type conversion in Golang is very common, so you should have a full understanding of it when processing JSON data. By introducing JSON data types, JSON parsing and encoding methods, JSON type conversion, etc. in Golang, this article hopes to help readers better apply Golang to process JSON data.

The above is the detailed content of golang json type conversion. For more information, please follow other related articles on the PHP Chinese website!