So lesen Sie JSON in Golang

Go-Sprache ist eine stark typisierte Programmiersprache, die häufig für die Netzwerkprogrammierung und die Verarbeitung großer Datenmengen verwendet wird. Als leichtes Datenaustauschformat wird JSON häufig zum Senden und Empfangen von Daten in der Netzwerkübertragung verwendet. Das Lesen von JSON-Daten ist eine sehr häufige Aufgabe in der Go-Sprache. Nun, in diesem Artikel stellen wir vor, wie man Golang zum Lesen von JSON-Daten verwendet.

1. Verwenden der JSON-Struktur in Golang

In Golang können Sie die Struktur verwenden, um das JSON-Format zu definieren, und dann können Sie die Funktion json.Unmarshal() verwenden Analysieren Sie die JSON-Daten, um das Lesen des JSON-Arrays zu implementieren. Der folgende Code zeigt, wie ein Array aus JSON-Daten gelesen wird.

package main
import (
    "encoding/json"
    "fmt"
)
type Book struct {
    Title  string `json:"title"`
    Author string `json:"author"`
    Price  string `json:"price"`
}
func main() {
    jsonData := `[{"title":"Golang实战开发","author":"张三","price":"100元"},
                  {"title":"深入浅出Go","author":"李四","price":"80元"}]`
    var books []Book
    json.Unmarshal([]byte(jsonData), &books)
    for _, book := range books {
        fmt.Println("Book Title: ", book.Title)
        fmt.Println("Book Author: ", book.Author)
        fmt.Println("Book Price: ", book.Price)
    }
}

Im obigen Code definieren wir zunächst eine Buchstruktur, um die Attributinformationen jedes Buches darzustellen. Diese Struktur verwendet das JSON-Tag zum Binden von JSON-Feldern, um sicherzustellen, dass wir JSON-Daten korrekt lesen können.

Als nächstes zeigen wir, wie man einen JSON-String in ein Book-Typ-Slice analysiert. Im Code erstellen wir zunächst ein leeres Slice, um die geparsten Daten zu speichern. Anschließend rufen wir die Funktion json.Unmarshal() auf und übergeben ihr die JSON-Daten und einen Zeiger auf das leere Slice, das wir erstellt haben. Zu diesem Zeitpunkt analysiert die Funktion automatisch die JSON-Zeichenfolge und analysiert die Daten in ein Segment vom Typ Buch. json.Unmarshal()函数，并向其传递JSON数据和指向我们创建的空slice的指针。此时，该函数将会自动解析JSON字符串，并将数据解析为Book类型的slice。

最后，我们遍历刚刚解析出来的slice，并将每本书的属性信息打印到终端中。当我们运行该程序时，可以看到以下输出结果：

Book Title:  Golang实战开发
Book Author:  张三
Book Price:  100元
Book Title:  深入浅出Go
Book Author:  李四
Book Price:  80元

二、使用Interface{}读取JSON数据

在某些场景下，我们并不知道JSON数据的具体结构，此时，我们可以使用interface{}类型的变量来处理JSON数据。下面的代码演示了如何使用interface{}类型来读取未知结构的JSON对象。

package main
import (
    "encoding/json"
    "fmt"
)
func main() {
    jsonData := `{"name":"张三","age":20}`
    var unknown map[string]interface{}
    json.Unmarshal([]byte(jsonData), &unknown)
    for key, value := range unknown {
        fmt.Printf("%v : %v
", key, value)
    }
}

在上面的例子中，我们使用了一个interface{}类型的map来接收未知结构的JSON数据，这样就不需要提前定义结构体了。json.Unmarshal()

Schließlich durchlaufen wir den gerade analysierten Slice und geben die Attributinformationen jedes Buches an das Terminal aus. Wenn wir das Programm ausführen, können wir die folgende Ausgabe sehen:

name : 张三
age : 20

2. Verwenden Sie Interface{}, um JSON-Daten zu lesen

In einigen Szenarien wissen wir das Spezifische nicht Struktur von JSON-Daten. Zu diesem Zeitpunkt können wir Variablen vom Typ interface{} verwenden, um JSON-Daten zu verarbeiten. Der folgende Code zeigt, wie der Typ interface{} zum Lesen eines JSON-Objekts unbekannter Struktur verwendet wird.

package main
import (
    "encoding/json"
    "fmt"
)
func main() {
    jsonData := `{"name":"张三","age":20}`
    var unknown interface{}
    json.Unmarshal([]byte(jsonData), &unknown)
    m := unknown.(map[string]interface{})
    fmt.Println(m["name"], m["age"])
}

Im obigen Beispiel verwenden wir eine Karte vom Typ interface{}, um JSON-Daten unbekannter Struktur zu empfangen, sodass die Struktur nicht im Voraus definiert werden muss. Die Funktion json.Unmarshal() analysiert die JSON-Zeichenfolge in eine Variable vom Typ „map[string]interface{}“ und verwendet eine for-Schleife, um die Variable zu durchlaufen und ihre Schlüssel bzw. Werte auszugeben. Wenn wir das Programm ausführen, können wir die folgende Ausgabe sehen:

张三 20

3. Verwenden Sie nichtstrukturelle Typen, um JSON-Daten zu lesen.

Außerdem, wenn wir kleine JSON-Objekte verarbeiten Wenn Sie nur einen Teil der Daten lesen müssen, müssen Sie möglicherweise nicht zuerst eine Struktur definieren, sondern nur eine Wertvariable definieren und dann die JSON-Zeichenfolge direkt in die Variable analysieren. Der folgende Code zeigt, wie Nichtstrukturtypen zum Lesen von JSON-Objekten verwendet werden.

rrreee

Im obigen Code verwenden wir eine Variable vom Typ interface{}, um JSON-Daten zu empfangen und verwenden Typzusicherungen, um sie in den Typ „map[string]interface{}“ zu konvertieren. Dann haben wir die Felder „Name“ und „Alter“ aus der Karte herausgenommen und die Ausgabe ausgedruckt. #🎜🎜##🎜🎜#Wenn wir das Programm ausführen, können wir die folgende Ausgabe sehen: #🎜🎜#rrreee#🎜🎜#Zusammenfassung#🎜🎜##🎜🎜#Das Lesen von JSON-Daten in Golang ist ein Kinderspiel. Sehr praktische Sache. Die Verwendung einer Struktur zum Definieren des JSON-Formats kann das Programm übersichtlicher machen. Durch die Verwendung von Variablen des Typs interface{} können JSON-Daten unbekannter Struktur empfangen werden, während die Verwendung nichtstruktureller Typen den Code vereinfachen und die Ausführungseffizienz des Programms verbessern kann. Natürlich haben die oben genannten drei Methoden zum Lesen von JSON-Daten ihre Vor- und Nachteile, und wir können die entsprechende Methode je nach Szenario flexibel auswählen. #🎜🎜#

Das obige ist der detaillierte Inhalt vonSo lesen Sie JSON in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!