Rumah > pembangunan bahagian belakang > Golang > Bagaimanakah Saya Boleh Menyahkod Strim JSON Besar dengan Cekap dalam Go?

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

Mary-Kate Olsen
Lepaskan: 2024-12-21 14:01:14
asal
899 orang telah melayarinya

How Can I Efficiently Decode Large JSON Streams in 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")
    }
}
Salin selepas log masuk

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!

sumber:php.cn
Kenyataan Laman Web ini
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn
Artikel terbaru oleh pengarang
Tutorial Popular
Lagi>
Muat turun terkini
Lagi>
kesan web
Kod sumber laman web
Bahan laman web
Templat hujung hadapan