How Can I Modify a JSON Object with an Unknown Structure in Go?

Handling JSON with Unknown Structure: Unmarshaling and Modification

In many programming scenarios, dealing with JSON data with an unknown structure can be challenging. However, Go provides a solution to overcome this obstacle.

Consider a situation where you receive a JSON string like this:

{
  "votes": {
    "option_A": "3"
  }
}

Your goal is to add a new "count" key with a value of "1" to the JSON object. However, since the JSON structure is unpredictable, you cannot use the standard json.Unmarshal function with a predefined struct.

To address this challenge, you can utilize the map[string]interface{} type. This allows you to unmarshal the JSON into a generic map, where keys are strings and values are interfaces that can represent any type of data.

The code demonstrates how to achieve this:

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    in := []byte(`{
        "votes": {
            "option_A": "3"
        }
    }`)

    var raw map[string]interface{}
    if err := json.Unmarshal(in, &raw); err != nil {
        panic(err)
    }

    raw["count"] = 1

    out, err := json.Marshal(raw)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(out))
}

In this code, we unmarshal the JSON data into the raw map. Since the structure is unknown, the values are represented as interfaces.

We can then modify the map by adding a new key-value pair with "count" as the key and 1 as the value. Finally, we marshal the modified map back into a JSON string using json.Marshal.

The output will be as expected:

{"votes":{"option_A":"3"},"count":1}

This technique provides a flexible way to handle JSON data with unknown structures, allowing you to modify and enrich the data as needed.

The above is the detailed content of How Can I Modify a JSON Object with an Unknown Structure in Go?. For more information, please follow other related articles on the PHP Chinese website!