JSON to Go Struct

Vad är JSON till Go-konvertering?

JSON till Go-konvertering omvandlar rå JSON-data till Go-typdefinitioner som fungerar med paketet encoding/json i Go:s standardbibliotek. Go är statiskt typat, vilket innebär att varje JSON-fält behöver ett motsvarande struct-fält med korrekt typ och en struct-tagg som talar om för serialiseraren vilket JSON-nyckel som ska mappas. Att skriva dessa definitioner för hand för stora eller djupt nästlade API-svar är tidskrävande och lätt att göra fel på.

Paketet encoding/json, som har funnits i Go-specifikationen sedan Go 1.0, använder reflektion för att matcha JSON-nycklar mot exporterade struct-fält. Matchningen är skiftlägesokänslig som standard, men explicita json struct-taggar är standardpraxis eftersom de eliminerar tvetydighet och låter dig använda Go:s PascalCase-konvention medan JSON behåller camelCase eller snake_case. En konverterare automatiserar detta: den läser din JSON, härleder Go-typer från värdena och producerar struct-definitioner med korrekta taggar.

Go:s typsystem mappas på ett naturligt sätt till JSON. Strängar blir string, booleaner blir bool, heltal blir int och flyttal blir float64. Nästlade JSON-objekt blir separata namngivna strukturer och arrayer blir slices. Det enda gapet är null: Go saknar en universell nullbar typ, så null-värden blir vanligtvis pekare (*string, *int) eller interface{}. En generator hanterar allt detta på millisekunder.

Varför använda en JSON till Go-konverterare?

Att definiera Go-strukturer från JSON för hand innebär att räkna klammerparenteser, gissa typer och skriva om taggar varje gång API:et ändras. En konverterare tar bort det friktionsmomentet.

Användningsfall för JSON till Go

JSON till Go-typmappning

Paketet encoding/json följer specifika regler när JSON-värden mappas till Go-typer. Tabellen nedan visar standardmappningen och vanliga alternativ. Kolumnen "Standard" visar vad de flesta generatorer producerar. Kolumnen "Alternativ" visar typer du kan välja baserat på dina krav, till exempel int64 för stora ID:n eller pekartyper för nullbara fält.

Referens för Go JSON struct-taggar

Struct-taggar styr hur encoding/json serialiserar och deserialiserar fält. json-taggen är överlägset vanligast, men du kan kombinera den med andra taggar (db, yaml, xml) på samma fält. Taggsyntaxen är en backtick-avgränsad sträng efter fälttypen. Här är de json-taggsalternativ som encoding/json stöder.

json.Unmarshal vs json.NewDecoder

Go erbjuder två sätt att avkoda JSON: json.Unmarshal för byte-slices och json.NewDecoder för io.Reader-strömmar. Båda använder samma struct-taggregler, men de skiljer sig åt i när de bör användas.

Kodexempel

Dessa exempel visar hur man använder Go-strukturer genererade från JSON i verkliga program, samt hur man genererar dem från andra språk. Go-exemplen använder encoding/json från standardbiblioteket.

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	ID       int      `json:"id"`
	Name     string   `json:"name"`
	Email    string   `json:"email"`
	IsActive bool     `json:"is_active"`
	Tags     []string `json:"tags"`
}

func main() {
	data := []byte(`{"id":1,"name":"Alice","email":"alice@example.com","is_active":true,"tags":["admin","editor"]}`)

	var user User
	if err := json.Unmarshal(data, &user); err != nil {
		panic(err)
	}
	fmt.Println(user.Name)  // → Alice
	fmt.Println(user.Tags)  // → [admin editor]
}

// JSON response from API — this is the shape you'd convert to Go:
const res = await fetch("https://api.example.com/users/1");
const user = await res.json();
// user → { "id": 1, "name": "Alice", "email": "alice@example.com" }

// Equivalent Go struct:
// type User struct {
//     ID    int    `json:"id"`
//     Name  string `json:"name"`
//     Email string `json:"email"`
// }

import json

def json_to_go(data: dict, name: str = "Root") -> str:
    lines = [f"type {name} struct {{"]
    type_map = {str: "string", int: "int", float: "float64", bool: "bool"}

    for key, value in data.items():
        go_type = type_map.get(type(value), "interface{}")
        field = key.title().replace("_", "")  # snake_case → PascalCase
        lines.append(f'\t{field} {go_type} `json:"{key}"`')
    lines.append("}")
    return "\n".join(lines)

data = json.loads('{"user_name": "Alice", "age": 30, "verified": true}')
print(json_to_go(data))
# type Root struct {
#     UserName string `json:"user_name"`
#     Age      int    `json:"age"`
#     Verified bool   `json:"verified"`
# }

package main

import (
	"encoding/json"
	"fmt"
	"strings"
)

type Event struct {
	Type    string `json:"type"`
	Payload string `json:"payload"`
}

func main() {
	stream := strings.NewReader(`{"type":"click","payload":"btn-1"}
{"type":"scroll","payload":"page-2"}`)

	dec := json.NewDecoder(stream)
	for dec.More() {
		var ev Event
		if err := dec.Decode(&ev); err != nil {
			break
		}
		fmt.Printf("%s: %s\n", ev.Type, ev.Payload)
	}
	// → click: btn-1
	// → scroll: page-2
}

Vanliga frågor