Bagaimanakah json.RawMessage Boleh Menghalang Double Unmarshaling in Go Apabila Mengendalikan Struktur JSON Heterogen?

Menggunakan RawMessage untuk Mengelakkan Penyahmarshalan Berganda dalam Go

Dalam Go, apabila bekerja dengan data JSON, kadangkala perlu untuk menyahmarshal sebahagian data untuk mengakses medan yang tidak diketahui atau mengendalikan struktur JSON heterogen. Walau bagaimanapun, proses ini boleh membawa kepada unmarshaling berganda, yang boleh menjadi tidak cekap. Artikel ini membentangkan penyelesaian untuk mengelakkan isu ini menggunakan json.RawMessage.

Pertimbangkan senario di mana sambungan soket web menghantar pelbagai jenis mesej JSON dan anda ingin menyahmarshalkannya ke dalam struktur yang diketahui. Pendekatan tradisional melibatkan pembongkaran JSON ke dalam peta [rentetan]antara muka{} generik, mencari kunci yang dikehendaki, dan kemudian cuba menghantar nilai kepada jenis yang diingini. Walau bagaimanapun, pendekatan ini boleh gagal apabila bekerja dengan struktur JSON bersarang.

Untuk menyelesaikan isu ini, bukannya menyahmarshalkan nilai ke dalam antara muka{}, kita boleh menyahmarshalkannya ke dalam json.RawMessage. Ini membolehkan kami mengakses data JSON mentah tanpa kehilangan maklumat jenis. Kemudian, dalam penyataan suis, kita boleh menyahmarshal data JSON mentah secara terus ke dalam struct yang diingini tanpa perlu mengawalnya semula.

import (
    "encoding/json"
    "fmt"
)

type Ping struct {
    Ping string `json:"ping"`
}

type Ack struct {
    Messages []Message `json:"messages"`
}

type Message string

func main() {
    testJSON := []byte(`{"ack":{"messages":["Hi there","Hi again"]}}`)
    var myAck = Ack{}
    var myMap map[string]json.RawMessage
    err := json.Unmarshal(testJSON, &myMap)
    if err != nil {
        fmt.Println("error unmarshalling: ", err)
    }

    for k, v := range myMap {
        fmt.Printf("key: %s, value: %s \n", k, v)

        switch k {
        case "ping":
            fmt.Println(k, " is a ping", v)
        case "ack":
            fmt.Println(k, " is an ack containing a message list")
            err = json.Unmarshal(v, &myAck)
            if err != nil {
                fmt.Println("unmarshal error", err)
            } else {
                fmt.Println("New ack object: ", myAck)
            }
        default:
            fmt.Printf("%s is of a type (%T) I don't know how to handle", k, v)
        }
    }
}

Dengan pendekatan ini, kami mengelakkan langkah berlebihan untuk mengawal dan menyahkamar data JSON, menjadikannya lebih cekap dan mudah untuk mengendalikan data JSON dengan struktur heterogen.

Atas ialah kandungan terperinci Bagaimanakah json.RawMessage Boleh Menghalang Double Unmarshaling in Go Apabila Mengendalikan Struktur JSON Heterogen?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!