How Can I Efficiently Parse JSON in Go Without Redundant Unmarshaling?-Golang-php.cn

How Can I Efficiently Parse JSON in Go Without Redundant Unmarshaling?

Susan Sarandon

Release： 2024-12-29 11:27:10

Original

472 people have browsed it

How Can I Efficiently Parse JSON in Go Without Redundant Unmarshaling?

Parsing JSON Without Redundant Unmarshaling in Go

When dealing with JSON messages that contain different types of data, a common approach may involve unmarshaling the data into a generic map[string]interface{} to inspect the key and attempt to cast the value into specific structs. However, this approach can lead to unnecessary double unmarshaling.

In the context of Go, there is a more efficient solution to partially unmarshal the JSON data into a json.RawMessage instead of interface{}. This is achieved by declaring the map as:

var myMap map[string]json.RawMessage

Copy after login

When it comes to casting the values to specific structs, the marshaling/unmarshaling step can be eliminated. For instance, in your case, you were casting to your "Ack" struct using:

ackjson, err := json.Marshal(v)
if err != nil {
    fmt.Println("marshal error: ", err)
}
err = json.Unmarshal(ackjson, &amp;myAck)
if err != nil {
    fmt.Println("unmarshal error", err)
}

Copy after login

Instead, it can be simplified to:

err = json.Unmarshal(v, &amp;myAck)

Copy after login

This approach avoids the redundant unmarshaling step, making the parsing more efficient.

Here is an updated version of your code that incorporates this optimization:

package main

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, &amp;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)
        }
    }
}

Copy after login

By utilizing json.RawMessage and eliminating the unnecessary unmarshaling, you can improve the performance of your JSON parsing without compromising functionality.

The above is the detailed content of How Can I Efficiently Parse JSON in Go Without Redundant Unmarshaling?. For more information, please follow other related articles on the PHP Chinese website!