Bagaimanakah saya boleh memproses tatasusunan JSON yang besar dengan cekap tanpa memuatkannya sepenuhnya ke dalam memori dalam Go?

Menyahkod JSON Strim Besar

Apabila berurusan dengan tatasusunan JSON besar-besaran yang disimpan dalam fail, adalah penting untuk mengelak daripada memuatkan keseluruhan tatasusunan ke dalam memori, kerana ini boleh menyebabkan keluar- ralat ingatan. Sebaliknya, pertimbangkan untuk menstrim elemen data JSON mengikut elemen.

Satu pendekatan untuk mencapai ini ditunjukkan dalam pengekodan/dokumentasi json:

package main

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

func main() {
    const jsonStream = `
                [
                    {"Name": "Ed", "Text": "Knock knock."},
                    {"Name": "Sam", "Text": "Who's there?"},
                    {"Name": "Ed", "Text": "Go fmt."},
                    {"Name": "Sam", "Text": "Go fmt who?"},
                    {"Name": "Ed", "Text": "Go fmt yourself!"}
                ]
            `
    type Message struct {
        Name, Text string
    }
    dec := json.NewDecoder(strings.NewReader(jsonStream))

    // read open bracket
    t, err := dec.Token()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%T: %v\n", t, t)

    // while the array contains values
    for dec.More() {
        var m Message
        // decode an array value (Message)
        err := dec.Decode(&m)
        if err != nil {
            log.Fatal(err)
        }

        fmt.Printf("%v: %v\n", m.Name, m.Text)
    }

    // read closing bracket
    t, err = dec.Token()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%T: %v\n", t, t)

}

Dalam kod sampel ini:

• Objek penyahkod (dec) dicipta untuk membaca data JSON daripada rentetan.
• Penyahkod membaca token satu demi satu, bermula dengan kurungan pembuka tatasusunan.
• Gelung untuk melelang ke atas elemen tatasusunan, menghuraikan setiap satu ke dalam struktur Mesej.
• Nama dan teks setiap mesej dicetak .
• Gelung diteruskan sehingga tiada lagi elemen tersedia dalam tatasusunan, ditunjukkan oleh dec.More() fungsi.
• Akhir sekali, penyahkod membaca dan mencetak kurungan penutup tatasusunan.

Pendekatan ini membolehkan anda menstrim tatasusunan JSON yang besar tanpa memuatkan keseluruhan struktur data ke dalam memori, mengoptimumkan penggunaan sumber dan membolehkan pemprosesan yang cekap.

Atas ialah kandungan terperinci Bagaimanakah saya boleh memproses tatasusunan JSON yang besar dengan cekap tanpa memuatkannya sepenuhnya ke dalam memori dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!