Home > Article > Backend Development > 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.
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:
In Golang, we can use the following types To represent JSON data type:
Before JSON type conversion , first you need to understand JSON parsing and encoding.
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{}
.
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.
int,
string,
bool, etc. You can also convert JSON arrays to arrays in Golang, or convert JSON objects to structures in Golang.
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
type in Golang is very simple, just use assertions. For example: <pre class='brush:go;toolbar:false;'>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)
}</pre>
In the above code, we parse the JSON string into a
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{}
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{}
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 structure
Converting 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) }
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.
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!