Comment puis-je décoder efficacement les flux JSON volumineux dans Go ?

Décoder les flux JSON dans Go

Lorsque vous travaillez avec de grandes charges utiles JSON, décoder l'intégralité du flux en mémoire peut s'avérer inefficace et peu pratique. Dans cet article, nous explorons une approche alternative utilisant json.Decoder pour décoder le JSON tel qu'il est diffusé.

Analyse basée sur les événements avec json.Decoder

Le json.Decoder fournit le décodeur Méthode .Token(), qui nous permet d'analyser le jeton suivant dans le flux JSON sans consommer l'intégralité de l'objet. Cela permet une analyse basée sur les événements, où nous pouvons traiter les jetons de manière incrémentielle et créer une machine d'état pour suivre nos progrès au sein de la structure JSON.

Implémentation pour le traitement incrémentiel d'objets JSON

Parcourons une implémentation qui répond au scénario spécifique décrit dans la question :

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

Cette implémentation traite l'objet JSON de manière incrémentielle, décodant les propriétés et les objets volumineux séparément. La fonction he() est utilisée pour gérer les erreurs avec une sortie fatale.

En évitant de charger l'intégralité de la réponse JSON en mémoire, cette approche permet un traitement efficace des charges utiles volumineuses.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!