Heim > Artikel > Backend-Entwicklung > 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.
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:
Decode
im Paket encoding/json
, um einen String oder ein Byte-Array in ein JSON-Objekt zu analysieren 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 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-Typkonvertierungencoding/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{}
等基础数据类型也是可以的。
通过 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 对象转换为 Golang 中的基础数据类型,例如 int
、string
、bool
等,也可以将 JSON 数组转换为 Golang 中的数组,或是将 JSON 对象转换为 Golang 中的结构体。
将 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 中的字符串转换为 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 中的数组转换为 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 中的对象转换为 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 中的对象转换为 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
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. 🎜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!