JSON to Go Map Formatter

JSON to Go: Typed Structs vs map[string]interface{}

Go developers working with JSON face a fundamental choice: a typed struct with json:"..." tags, or a dynamic map[string]interface{}. The generator produces a typed Go struct — the right default for structured API responses — but the map form is the right tool for genuinely dynamic JSON where keys are unknown at compile time. This page covers both, explains when to use each, and shows how to configure json struct tags for production use.

Live Example: API Response to Go Struct

// Input JSON
{
  "user_id": "usr_4421",
  "username": "gopher_dev",
  "email": "gopher@example.com",
  "follower_count": 1240,
  "is_verified": true,
  "bio": null,
  "created_at": "2024-03-15T10:00:00Z"
}

// Generated Go Struct
type Root struct {
    UserId        string  `json:"user_id"`
    Username      string  `json:"username"`
    Email         string  `json:"email"`
    FollowerCount float64 `json:"follower_count"`
    IsVerified    bool    `json:"is_verified"`
    Bio           *string `json:"bio"`
    CreatedAt     string  `json:"created_at"`
}

Refining After Generation

The generator gives you the shape — you'll want to refine types and add useful tags:

import "time"

type UserProfile struct {
    UserID        string    `json:"user_id"`
    Username      string    `json:"username"`
    Email         string    `json:"email"`
    FollowerCount int       `json:"follower_count"`           // int not float64
    IsVerified    bool      `json:"is_verified"`
    Bio           *string   `json:"bio,omitempty"`            // omitempty skips null/zero on marshal
    CreatedAt     time.Time `json:"created_at"`               // parse ISO 8601 automatically
}

// Unmarshal from JSON bytes
func ParseUserProfile(data []byte) (*UserProfile, error) {
    var u UserProfile
    if err := json.Unmarshal(data, &u); err != nil {
        return nil, fmt.Errorf("parsing user profile: %w", err)
    }
    return &u, nil
}

// Or with http.Response
resp, _ := http.Get("https://api.example.com/users/4421")
defer resp.Body.Close()

var profile UserProfile
if err := json.NewDecoder(resp.Body).Decode(&profile); err != nil {
    log.Fatal(err)
}
fmt.Printf("@%s has %d followers\n", profile.Username, profile.FollowerCount)

Go Struct vs map[string]interface{}

A typed struct is almost always better than a map for structured JSON:

// map[string]interface{}: flexible but unsafe
data := map[string]interface{}{}
json.Unmarshal(body, &data)
username := data["username"].(string)   // panics if key missing or wrong type
count := int(data["follower_count"].(float64)) // awkward double cast

// Typed struct: safe, IDE-complete, compiler-checked
var profile UserProfile
json.Unmarshal(body, &profile)
username := profile.Username   // string, always — compiler guarantees it
count := profile.FollowerCount // int, always

// When map IS appropriate:
// - Genuinely dynamic JSON (unknown keys, user-defined schemas)
// - One-off scripts where struct definition is more effort than value
// - Passing through JSON without reading its content

json Tag Options

type Example struct {
    // Basic: maps JSON key "user_name" to Go field UserName
    UserName string `json:"user_name"`

    // omitempty: omit this field from JSON output if zero/nil
    // (empty string, 0, false, nil pointer, empty slice/map)
    OptionalField *string `json:"optional_field,omitempty"`

    // string: serialize number as a JSON string (useful for large int64 IDs
    // that would lose precision in JavaScript's float64)
    LargeID int64 `json:"large_id,string"`

    // -: exclude this field from JSON entirely
    InternalField string `json:"-"`

    // No tag: Go uses the field name as-is (case-insensitive match on unmarshal)
    Raw string
}

Custom Unmarshaling for Edge Cases

// If the API returns dates as Unix timestamps instead of ISO 8601:
type UnixTime struct {
    time.Time
}

func (t *UnixTime) UnmarshalJSON(data []byte) error {
    var ts int64
    if err := json.Unmarshal(data, &ts); err != nil {
        return err
    }
    t.Time = time.Unix(ts, 0)
    return nil
}

type Event struct {
    Name      string   `json:"name"`
    CreatedAt UnixTime `json:"created_at"` // handles {created_at: 1710000000}
}

Frequently Asked Questions

Why does the generator use float64 for numbers? JSON has one number type; Go's encoding/json defaults to float64 for numbers into interface{}. The generator mirrors this. Change to int, int64, or uint for fields you know are integers — Go's json package handles the conversion correctly as long as the number fits.

Why are nullable JSON fields generated as *string (pointer) instead of just string? A string field can't distinguish between absent and empty string. A *string pointer is nil when the JSON value is null or the key is missing, and points to the actual string otherwise. This distinction matters for database writes and API responses where null ≠ "".

Does Go's json package handle snake_case keys without tags? Yes — Go's json unmarshaler does a case-insensitive match, so user_id in JSON will match a Go field named UserID even without a tag. Tags are still recommended for clarity and correct marshaling (output).

Is my JSON sent to a server? No. TypeMorph runs entirely in your browser — none of your data leaves your machine.