Bagaimanakah Saya Boleh Menyahkod Strim JSON Besar dengan Cekap dalam Go?

Menyahkod Strim JSON dalam Go

Apabila bekerja dengan muatan JSON yang besar, penyahkodan keseluruhan strim dalam ingatan boleh menjadi tidak cekap dan tidak praktikal. Dalam artikel ini, kami meneroka pendekatan alternatif menggunakan json.Decoder untuk menyahkod JSON semasa ia distrim masuk.

Event-Driven Parsing dengan json.Decoder

Json.Decoder menyediakan Dekoder Kaedah .Token(), yang membolehkan kami menghuraikan token seterusnya dalam aliran JSON tanpa menggunakan keseluruhan objek. Ini membolehkan penghuraian dipacu peristiwa, di mana kita boleh memproses token secara berperingkat dan membina mesin keadaan untuk menjejak kemajuan kita dalam struktur JSON.

Pelaksanaan untuk Pemprosesan Objek JSON Bertambah

Mari kita jalani pelaksanaan yang menangani senario khusus yang diterangkan dalam soalan:

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

Pelaksanaan ini memproses objek JSON secara berperingkat, menyahkod sifat dan objek besar secara berasingan. Fungsi he() digunakan untuk mengendalikan ralat dengan jalan keluar yang membawa maut.

Dengan mengelak memuatkan keseluruhan respons JSON ke dalam ingatan, pendekatan ini membolehkan pemprosesan muatan besar yang cekap.

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Menyahkod Strim JSON Besar dengan Cekap dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!