Wie kann ich große JSON-Streams in Go effizient dekodieren?

JSON-Streams in Go dekodieren

Bei der Arbeit mit großen JSON-Nutzlasten kann die Dekodierung des gesamten Streams im Speicher ineffizient und unpraktisch sein. In diesem Artikel untersuchen wir einen alternativen Ansatz, bei dem der json.Decoder verwendet wird, um JSON beim Einströmen zu dekodieren.

Ereignisgesteuertes Parsen mit json.Decoder

Der json.Decoder stellt den Decoder bereit .Token()-Methode, die es uns ermöglicht, das nächste Token im JSON-Stream zu analysieren, ohne das gesamte Objekt zu verbrauchen. Dies ermöglicht ereignisgesteuertes Parsen, bei dem wir Token inkrementell verarbeiten und eine Zustandsmaschine erstellen können, um unseren Fortschritt innerhalb der JSON-Struktur zu verfolgen.

Implementierung für inkrementelle JSON-Objektverarbeitung

Lassen Sie uns eine Implementierung durchgehen Dies befasst sich mit dem in der Frage beschriebenen spezifischen Szenario:

import (
    "encoding/json"
    "fmt"
    "log"
)

type LargeObject struct {
    Id   string `json:"id"`
    Data string `json:"data"`
}

// Helper error handler
he := func(err error) {
    if err != nil {
        log.Fatal(err)
    }
}

// Parse and process a JSON object stream
func ParseStream(reader io.Reader) {
    dec := json.NewDecoder(reader)

    // Expect an object
    t, err := dec.Token()
    he(err)
    if delim, ok := t.(json.Delim); !ok || delim != '{' {
        log.Fatal("Expected object")
    }

    // Read properties
    for dec.More() {
        t, err = dec.Token()
        he(err)
        prop := t.(string)
        if t != "items" {
            var v interface{}
            he(dec.Decode(&v))
            log.Printf("Property '%s' = %v", prop, v)
            continue
        }

        // "items" array
        t, err := dec.Token()
        he(err)
        if delim, ok := t.(json.Delim); !ok || delim != '[' {
            log.Fatal("Expected array")
        }

        // Read large objects
        for dec.More() {
            lo := LargeObject{}
            he(dec.Decode(&lo))
            fmt.Printf("Item: %+v\n", lo)
        }

        // Array closing delim
        t, err = dec.Token()
        he(err)
        if delim, ok := t.(json.Delim); !ok || delim != ']' {
            log.Fatal("Expected array closing")
        }
    }

    // Object closing delim
    t, err = dec.Token()
    he(err)
    if delim, ok := t.(json.Delim); !ok || delim != '}' {
        log.Fatal("Expected object closing")
    }
}

Diese Implementierung verarbeitet das JSON-Objekt inkrementell und dekodiert Eigenschaften und große Objekte getrennt. Die Funktion he() wird verwendet, um Fehler mit einem schwerwiegenden Exit zu behandeln.

Dadurch vermieden wird, dass die gesamte JSON-Antwort in den Speicher geladen wird, ermöglicht dieser Ansatz eine effiziente Verarbeitung großer Nutzlasten.

Das obige ist der detaillierte Inhalt vonWie kann ich große JSON-Streams in Go effizient dekodieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!