Bagaimanakah Penghuraian Terdorong Peristiwa Boleh Meningkatkan Kecekapan Penyahkodan Strim JSON untuk Respons JSON yang Besar?

Menyahkod Strim JSON dengan Penghuraian Didorong Peristiwa

Apabila berurusan dengan respons JSON besar yang mengandungi tatasusunan besar, menyahkod keseluruhan respons ke dalam memori boleh menggunakan sumber yang ketara dan memberi kesan kepada prestasi. Untuk mengurangkan isu ini, kami boleh menggunakan penghuraian terdorong peristiwa dengan json.Decoder untuk membahagikan strim JSON kepada bahagian yang lebih kecil dan memprosesnya secara berperingkat.

Penghuraian Terdorong Peristiwa dengan Decoder.Token()

Json.Decoder menyediakan kaedah Token(), yang membenarkan kami menghuraikan hanya yang seterusnya token dalam aliran JSON tanpa menggunakan keseluruhan input. Ini membolehkan kami menghuraikan dan memproses strim JSON secara berperingkat, objek demi objek.

Memproses Strim JSON

Untuk memproses strim JSON, kita boleh menggunakan mesin keadaan yang menjejaki struktur objek JSON dan mengendalikan token dengan sewajarnya. Langkah berikut menggariskan proses:

1. Baca Pembatas Objek Pembukaan: Kami menjangkakan respons JSON akan bermula dengan pendakap kerinting pembukaan ({), yang menunjukkan permulaan objek .
2. Parse Properties and Values: Sambil kita berulang melalui strim JSON, kita jumpa nama harta (kunci) dan nilai yang sepadan. Kami boleh menyahkod sifat dan nilai ini menggunakan Penyahkod.Dekod().
3. Kendalikan Tatasusunan: Apabila kami menemui kunci tatasusunan ("item" dalam contoh anda), kami menjangkakan pembatas tatasusunan ( [). Kami kemudian mengulangi elemen tatasusunan, menghuraikan dan memproses setiap item.
4. Memproses Item Individu: Untuk setiap item (objek besar), kami menyahkodnya kepada jenis berstruktur (cth., LargeObject) menggunakan Decoder.Decode().
5. Baca Pembatas Penutup: Selepas memproses tatasusunan, kami menjangkakan kurungan empat segi penutup (]). Begitu juga, kami menjangkakan pendakap kerinting penutup (}) untuk menunjukkan penghujung objek JSON.

Pengendalian Ralat

Pengendalian ralat sepanjang proses adalah penting untuk memastikan pelaksanaan yang betul dan konsisten. Fungsi pengendali ralat tersuai boleh memudahkan pengurusan ralat dan menyediakan mesej ralat yang jelas.

Contoh Pelaksanaan

Berikut ialah contoh pelaksanaan berdasarkan format JSON input yang anda berikan:

package main

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

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

// Simplified error handling function
func he(err error) {
    if err != nil {
        log.Fatal(err)
    }
}

func main() {
    // Example JSON stream
    jsonStream := `{
        "somefield": "value",
        "otherfield": "othervalue",
        "items": [
            { "id": "1", "data": "data1" },
            { "id": "2", "data": "data2" },
            { "id": "3", "data": "data3" },
            { "id": "4", "data": "data4" }
        ]
    }`

    dec := json.NewDecoder(strings.NewReader(jsonStream))

    // Read opening 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 prop != "items" {
            var v interface{}
            he(dec.Decode(&v))
            log.Printf("Property '%s' = %v", prop, v)
            continue
        }

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

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

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

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

Perhatikan bahawa pelaksanaan ini menjangkakan objek JSON yang sah. Pengendalian ralat boleh dikembangkan untuk meliputi input JSON yang salah bentuk atau tidak lengkap.

Atas ialah kandungan terperinci Bagaimanakah Penghuraian Terdorong Peristiwa Boleh Meningkatkan Kecekapan Penyahkodan Strim JSON untuk Respons JSON yang Besar?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!