Working with Dynamic or Unknown JSON Structures in Go

Introduction to Dynamic JSON Handling

Welcome to the final lesson in your journey of mastering JSON handling in Go! In the previous lessons, you learned how to decode JSON data into Go structs, handle nested and optional JSON fields, and manage complex JSON structures. Now, we will explore how to work with dynamic or unknown JSON structures. These are common in real-world API interactions where the JSON structure may not be fixed or known in advance. By the end of this lesson, you will be equipped to handle such dynamic data effectively, ensuring robust and flexible API communication.

Leveraging Go's Map Type for Dynamic JSON

In Go, the map type is a powerful tool for handling dynamic JSON structures. Unlike structs, which require predefined fields, maps allow you to store key-value pairs without knowing the structure in advance. This flexibility makes maps ideal for working with JSON data that can vary in structure. For example, consider a JSON response from an API that returns different fields based on the request: JSON {"name": "John Doe", "age": 30, "email": "john.doe@example.com"} In another scenario, the same API might return additional fields: JSON {"name": "Jane Doe", "age": 25, "email": "jane.doe@example.com", "phone": "123-456-7890"} Using a map in Go, you can handle both responses without needing to define a new struct for each variation. This approach allows you to work with dynamic JSON data in a flexible and efficient manner.

Example: Fetching and Parsing Dynamic JSON from an API

To understand how to work with dynamic JSON data, let’s go through an example where we fetch JSON from an API, parse it into a flexible structure, and navigate its contents .

Step 1: Define a Flexible Data Type

Since the structure of the JSON response is unknown or varies, we use a map with string keys and empty interface values (map[string]interface{}), which allows us to store any kind of JSON data. Go type dynamicJSON map[string]interface{} This means: The keys in the map will be strings (matching JSON field names). The values can be any type (numbers, strings, nested maps, arrays, etc.).

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Final Code: Fetch and Parse JSON

Putting all the steps together, we get:

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

type dynamicJSON map[string]interface{}

func getJSONFromApi() (dynamicJSON, error) {
    resp, err := http.Get("http://localhost:8000/docs")
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    var result dynamicJSON
    err = json.Unmarshal(body, &result)
    if err != nil {
        return nil, err
    }

    return result, nil
}

func main() {
    doc, err := getJSONFromApi()
    if err != nil {
        fmt.Printf("Error: %v", err)
        return
    }

    for path, detail := range doc {
        fmt.Printf("Path: %s\n", path)
        details, ok := detail.(map[string]interface{})
        if !ok {
            continue
        }

        for method, info := range details {
            fmt.Printf("\nMethod: %s\n", method)
            infos, ok := info.(map[string]interface{})
            if !ok {
                continue
            }

            for property, value := range infos {
                fmt.Printf("%s: %v\n", property, value)
            }
        }
        fmt.Println("----------------------------------")
    }
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

type dynamicJSON map[string]interface{}

func getJSONFromApi() (dynamicJSON, error) {
    resp, err := http.Get("http://localhost:8000/docs")
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    var result dynamicJSON
    err = json.Unmarshal(body, &result)
    if err != nil {
        return nil, err
    }

    return result, nil
}

func main() {
    doc, err := getJSONFromApi()
    if err != nil {
        fmt.Printf("Error: %v", err)
        return
    }

    for path, detail := range doc {
        fmt.Printf("Path: %s\n", path)
        details, ok := detail.(map[string]interface{})
        if !ok {
            continue
        }

        for method, info := range details {
            fmt.Printf("\nMethod: %s\n", method)
            infos, ok := info.(map[string]interface{})
            if !ok {
                continue
            }

            for property, value := range infos {
                fmt.Printf("%s: %v\n", property, value)
            }
        }
        fmt.Println("----------------------------------")
    }
}

In this code, we first make an HTTP GET request to the API endpoint. We then read the response body and unmarshal the JSON data into a dynamicJSON map. This allows us to handle any JSON structure returned by the API. Finally, we iterate over the map to print the JSON data, demonstrating how to access and work with dynamic JSON structures.

Introduction to Dynamic JSON Handling

Leveraging Go's Map Type for Dynamic JSON

Example: Fetching and Parsing Dynamic JSON from an API

Step 1: Define a Flexible Data Type

Join the 1M+ learners on CodeSignal

Step 2: Make an HTTP Request

Step 3: Read and Parse the JSON Response

Step 4: Access and Print JSON Data

Loop Through Top-Level Keys

Use Type Assertions to Handle Nested Data

Loop Through Nested Keys

Print Inner Properties

Final Code: Fetch and Parse JSON

Navigating Nested JSON Structures

Common Pitfalls and Best Practices

Summary and Next Steps