6. map string interface{}

map[string]interface{}

Sometimes you have to deal with JSON data of unknown or varying structure in Go. In those instances map[string]interface{} offers a flexible way to handle it without predefined structs.

Think about it: a JSON object is a key-value pair, where the key is a string and the value can be any JSON type. map[string]interface{} is a map where the key is a string and the value can be any Go type.

var data map[string]interface{}
jsonString := `{"name": "Alice", "age": 30, "address": {"city": "Wonderland"}}`
json.Unmarshal([]byte(jsonString), &data)
fmt.Println(data["name"])  // Output: Alice
fmt.Println(data["address"].(map[string]interface{})["city"])  // Output: Wonderland

any is an alias for interface{}

Go JSON - map[string]interface{} Notes

The Problem

Sometimes you don't know the JSON structure ahead of time, or it varies. You can't create a struct for it.

Example varying JSON:

// Sometimes:
{"type": "user", "name": "Alice"}

// Other times:
{"type": "org", "company": "Acme", "employees": 50}

Different fields! Can't use one struct.

The Solution: map[string]interface{}

var data map[string]interface{}

What this means:

• map[string]___ = keys are strings (JSON keys are always strings)

• interface{} = values can be any type

Breaking Down the Type

map[string]interface{}
^^^ ^^^^^^ ^^^^^^^^^^^
 |    |        |
 |    |        └─ Value type: anything
 |    └─ Key type: string
 └─ It's a map

Why This Works for JSON

JSON structure:

{
  "name": "Alice",        // string value
  "age": 30,              // number value
  "active": true,         // boolean value
  "address": {            // object value
    "city": "Wonderland"
  }
}

Go map equivalent:

map[string]interface{}{
    "name": "Alice",           // interface{} holds string
    "age": 30,                 // interface{} holds int
    "active": true,            // interface{} holds bool
    "address": map[string]interface{}{ // interface{} holds another map
        "city": "Wonderland",
    },
}

Example Usage

var data map[string]interface{}
jsonString := `{"name": "Alice", "age": 30, "address": {"city": "Wonderland"}}`

json.Unmarshal([]byte(jsonString), &data)

fmt.Println(data["name"])  // Alice
fmt.Println(data["age"])   // 30

Accessing Nested Values

fmt.Println(data["address"].(map[string]interface{})["city"])
//          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//          This is complex, let me break it down...

1

Step by step

1. data["address"] - get the address value (type interface{})

2. .(map[string]interface{}) - type assertion (tell Go it's a map)

3. ["city"] - access the "city" key in that map

Type Assertions Explained

When you pull a value out of interface{}, you need to tell Go what type it is:

// Get value as interface{}
nameInterface := data["name"]

// Type assert to string
name := nameInterface.(string)
// or in one line:
name := data["name"].(string)

Common type assertions:

data["name"].(string)                    // string value
data["age"].(float64)                    // JSON numbers become float64
data["active"].(bool)                    // boolean value
data["address"].(map[string]interface{}) // nested object
data["items"].([]interface{})            // array

any is the Same as interface{}

// These are identical:
map[string]interface{}
map[string]any

// You can use either:
var data map[string]interface{}
var data map[string]any

any is just an alias (shorter name) for interface{}.

Complete Example

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonString := `{
        "name": "Alice",
        "age": 30,
        "active": true,
        "address": {
            "city": "Wonderland",
            "zip": "12345"
        },
        "hobbies": ["reading", "coding"]
    }`
    
    var data map[string]interface{}
    json.Unmarshal([]byte(jsonString), &data)
    
    // Access simple values
    name := data["name"].(string)
    age := data["age"].(float64)  // JSON numbers are float64!
    active := data["active"].(bool)
    
    // Access nested object
    address := data["address"].(map[string]interface{})
    city := address["city"].(string)
    
    // Access array
    hobbies := data["hobbies"].([]interface{})
    firstHobby := hobbies[0].(string)
    
    fmt.Println(name, age, active, city, firstHobby)
    // Alice 30 true Wonderland reading
}

Safe Type Assertion (Check for Errors)

// Unsafe - panics if wrong type
name := data["name"].(string)

// Safe - returns ok=false if wrong type
name, ok := data["name"].(string)
if !ok {
    fmt.Println("name is not a string")
}

When to Use map[string]interface{}

Good for:

• Unknown JSON structure

• Varying JSON structure

• Quick prototyping

• Config files with flexible structure

Bad for:

• Known, fixed structure (use structs instead)

• Type safety (you lose it with interface{})

• Performance (type assertions have overhead)

Structs vs map[string]interface{}

With Struct (better when structure is known)

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

var user User
json.Unmarshal(data, &user)
fmt.Println(user.Name)  // Type safe, clear

With map[string]interface{} (when structure unknown)

var data map[string]interface{}
json.Unmarshal(jsonData, &data)
fmt.Println(data["name"].(string))  // Need type assertion

JSON Number Gotcha

Important: JSON numbers always decode to float64, even if they're integers!

jsonString := `{"count": 5}`
var data map[string]interface{}
json.Unmarshal([]byte(jsonString), &data)

// This works:
count := data["count"].(float64)  // 5.0

// This panics:
count := data["count"].(int)  // ❌ PANIC!

// Convert if you need int:
countFloat := data["count"].(float64)
countInt := int(countFloat)

Common Patterns

Check if Key Exists

if value, exists := data["name"]; exists {
    name := value.(string)
    fmt.Println(name)
}

Iterate Over Keys

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

Nested Access with Safety

if address, ok := data["address"].(map[string]interface{}); ok {
    if city, ok := address["city"].(string); ok {
        fmt.Println(city)
    }
}

Key Takeaways

1. map[string]interface{} handles JSON with unknown structure

2. Keys are strings, values can be any type

3. Type assertions required to use values: .(type)

4. any = interface{} (same thing)

5. JSON numbers become float64

6. Use structs when structure is known (better type safety)

Quick Reference

JSON Type	Go Type in interface{}
String	string
Number	float64
Boolean	bool
Object	map[string]interface{}
Array	[]interface{}
null	nil

// Access pattern
data["key"].(expectedType)

// Examples
data["name"].(string)
data["age"].(float64)
data["active"].(bool)
data["address"].(map[string]interface{})
data["items"].([]interface{})

Assignment

A junior developer's deadline is looming. They've been tasked with creating functions to retrieve and log various resources from Jello's API. Rather than making multiple structs and type-safe functions, the junior developer has decided to make two flexible functions. Help them complete their task before their boss, Wayne Lagner, asks them to refactor it.

Complete the getResources and logResources functions.

• getResources takes a url string and returns a slice of maps []map[string]interface{} and an error. It's a slice of maps because the API response is an array of JSON objects.

• logResources takes a slice of maps []map[string]interface{} and prints its keys and values to the console. Because maps are unsorted we will be adding formatted strings to a slice of strings []string which is then sorted.

1

getResources()

• Decode the response body into a slice of maps []map[string]interface{} and return it.

2

logResources()

• Iterate over the slice of map[string]interface{}

• For each map[string]interface{} get its keys and values using range and append it to formattedStrings as Key: %s - Value: %v, where %s is the key and %v is the value.

You do not need to account for nested JSON objects. Assume they are neat key-value pairs, one level deep.

Example output from one issue:

Issue:
Key: estimate - Value: 19
Key: id - Value: 0194fdc2-fa2f-4cc0-81d3-ff12045b73c8
Key: status - Value: TODO
Key: title - Value: Fix that one bug nobody understands

Starter Code

package main

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

func getResources(url string) ([]map[string]any, error) {
	var resources []map[string]any

	res, err := http.Get(url)
	if err != nil {
		return resources, err
	}

	defer res.Body.Close()

	// ?

}

func logResources(resources []map[string]any) {
	var formattedStrings []string

	// ?

	sort.Strings(formattedStrings)

	for _, str := range formattedStrings {
		fmt.Println(str)
	}
}

Solution

package main

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

func getResources(url string) ([]map[string]any, error) {
	var resources []map[string]any
	
	res, err := http.Get(url)
	if err != nil {
		return resources, err
	}

	defer res.Body.Close()
	
	// Solution Below
	decoder := json.NewDecoder(res.Body)
	err = decoder.Decode(&resources)
	if err != nil {
		return resources, err
	}

	return resources, nil
}

func logResources(resources []map[string]any) {
	var formattedStrings []string
	
	// Solution Below
	for _, resource := range resources {
		for key, value := range resource {
			formattedStrings = append(formattedStrings, fmt.Sprintf("Key: %s - Value: %v", key, value))
		}
	}

	sort.Strings(formattedStrings)

	for _, str := range formattedStrings {
		fmt.Println(str)
	}
}