Decoding JSON to Go values

decode-json-01-to-string.go

// Decode JSON to a string
package main

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

var j []byte = []byte(`"foo"`)

func main() {
	var s string
	err := json.Unmarshal(j, &s)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: foo
	fmt.Printf("%+v\n", s)
}

decode-json-02-to-array.go

// Decode JSON to an array
package main

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

var j []byte = []byte(`["foo","bar","baz"]`)

func main() {
	var a []string
	err := json.Unmarshal(j, &a)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: [foo bar baz]
	fmt.Printf("%+v\n", a)
}

decode-json-03-to-map-1.go

// Decode JSON to a map
package main

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

var j []byte = []byte(`{"foo":1,"bar":2,"baz":3}`)

func main() {
	var m map[string]int
	err := json.Unmarshal(j, &m)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: map[bar:2 baz:3 foo:1]
	fmt.Printf("%+v\n", m)
}

decode-json-04-to-map-2.go

// Decode JSON to a map
package main

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

var j []byte = []byte(`{"name":"Alice","address":{"street":"Wonder Lane 42","city":"Wonderland"},"interests":["K8s","Go","JSON"]}`)

func main() {
	var m map[string]interface{}
	err := json.Unmarshal(j, &m)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: map[address:map[city:Wonderland street:Wonder Lane 42] interests:[K8s Go JSON] name:Alice]
	fmt.Printf("%+v\n", m)
}

decode-json-05-to-struct-1.go

// Decode JSON to a struct
package main

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

var j []byte = []byte(`{"Round":3,"Exact":3.14,"hidden":"hidden"}`)

type Number struct {
	Round  int
	Exact  float64
	hidden string // Non-exported field (lower case) => no assignment
}

func main() {
	var n Number
	err := json.Unmarshal(j, &n)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: {Round:3 Exact:3.14 hidden:}
	fmt.Printf("%+v\n", n)
}

decode-json-06-to-struct-2.go

// Decode JSON to a struct
package main

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

// Note: matching of JSON keys to struct fields is CASE-INSENSITIVE
var j []byte = []byte(`{"round":3,"exact":3.14,"hidden":"hidden"}`)

type Number struct {
	Round  int
	Exact  float64
	hidden string // Non-exported field (lower case) => no assignment
}

func main() {
	var n Number
	err := json.Unmarshal(j, &n)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: {Round:3 Exact:3.14 hidden:}
	fmt.Printf("%+v\n", n)
}

decode-json-07-to-struct-3.go

// Decode JSON to a struct
package main

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

// Note: matching of JSON keys to struct fields is CASE-INSENSITIVE
var j []byte = []byte(`{"ROUND":3,"exact":3.14,"hidden":"hidden"}`)

type Number struct {
	Round  int
	EXACT  float64
	hidden string // Non-exported field (lower case) => no assignment
}

func main() {
	var n Number
	err := json.Unmarshal(j, &n)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: {Round:3 Exact:3.14 hidden:}
	fmt.Printf("%+v\n", n)
}

decode-json-08-to-struct-4.go

// Decode JSON to a struct
package main

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

// Note: JSON keys with no matching fields in destination struct are ignored
var j []byte = []byte(`{"round":3,"exact":3.14,"superfluous":"superfluous"}`)

type Number struct {
	Round int
	Exact float64
}

func main() {
	var n Number
	err := json.Unmarshal(j, &n)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: {Round:3 Exact:3.14}
	fmt.Printf("%+v\n", n)
}

decode-json-09-to-struct-5.go

// Decode JSON to a struct
package main

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

// Note: struct fields with no matching JSON keys get default value
var j []byte = []byte(`{"round":3,"exact":3.14}`)

type Number struct {
	Round       int
	Exact       float64
	Superfluous int
}

func main() {
	var n Number
	err := json.Unmarshal(j, &n)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: {Round:3 Exact:3.14 Superfluous:0}
	fmt.Printf("%+v\n", n)
}

decode-json-10-to-struct-6.go

// Decode JSON to a struct
package main

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

var j []byte = []byte(`{"name":"Alice","address":{"street":"Wonder Lane 42","city":"Wonderland"},"interests":["K8s","Go","JSON"]}`)

type Message struct {
	Name      string
	Address   Address
	Interests []string
}

type Address struct {
	Street string
	City   string
}

func main() {
	var m Message
	err := json.Unmarshal(j, &m)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: {Name:Alice Address:{Street:Wonder Lane 42 City:Wonderland} Interests:[K8s Go JSON]}
	fmt.Printf("%+v\n", m)
}

decode-json-11-to-struct-with-tags-1.go

// Decode JSON to a struct with tags
package main

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

var j []byte = []byte(`{"myRound":3,"myExact":3.14}`)

type Number struct {
	Round int     `json:"myRound"`
	Exact float64 `json:"myExact"`
}

func main() {
	var n Number
	err := json.Unmarshal(j, &n)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: {Round:3 Exact:3.14}
	fmt.Printf("%+v\n", n)
}

decode-json-12-to-struct-with-tags-2.go

// Decode JSON to a struct with tags
package main

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

// Note: matching of JSON keys to struct tags is CASE-INSENSITIVE
var j []byte = []byte(`{"MYROUND":3,"myExact":3.14}`)

type Number struct {
	Round int     `json:"myRound"`
	Exact float64 `json:"myexACT"`
}

func main() {
	var n Number
	err := json.Unmarshal(j, &n)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: {Round:3 Exact:3.14}
	fmt.Printf("%+v\n", n)
}

decode-json-13-to-struct-with-tags-3.go

// Decode JSON to a struct with tags
package main

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

var j []byte = []byte(`{"myRound":3,"myExact":"3.14"}`)

// Note: "string" decodes JSON string to type of struct field
type Number struct {
	Round int     `json:"myRound"`
	Exact float64 `json:"myExact,string"`
}

func main() {
	var n Number
	err := json.Unmarshal(j, &n)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: {Round:3 Exact:3.14}
	fmt.Printf("%+v\n", n)
}

decode-json-14-to-unknown-1.go

// Decode JSON to a generic value
package main

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

var j []byte = []byte(`{"name":"Alice","address":{"street":"Wonder Lane 42","city":"Wonderland"},"interests":["K8s","Go","JSON"]}`)

func main() {
	// Note: this is useful if you don't know the JSON structure beforehand
	var f interface{}
	err := json.Unmarshal(j, &f)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: map[address:map[city:Wonderland street:Wonder Lane 42] interests:[K8s Go JSON] name:Alice]
	fmt.Printf("%+v\n", f)
}

decode-json-15-to-unknown-2.go

// Decode JSON to a generic value
package main

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

var j []byte = []byte(`["foo", "bar", "baz"]`)

func main() {
	// Note: this is useful if you don't know the JSON structure beforehand
	var f interface{}
	err := json.Unmarshal(j, &f)
	if err != nil {
		log.Fatal(err)
	}
	// Prints: [foo bar baz]
	fmt.Printf("%+v\n", f)
}