Decode JSON in Golang

Posted on by user

In Go (Golang), there are several ways to decode JSON, each suited for different scenarios. Here’s a list of common methods along with their typical use cases:

1. json.Unmarshal

json.Unmarshal: This is the most straightforward method when you have the entire JSON data available as a byte slice. It’s best used when the JSON data is not too large and can be comfortably loaded into memory.

package main

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

type Person struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email"`
}

func main() {
    jsonData := []byte(`{"name":"John Doe","age":30,"email":"johndoe@example.com"}`)

    var person Person
    err := json.Unmarshal(jsonData, &person)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("%+v\n", person)
}

2. json.NewDecoder with io.Reader

json.NewDecoder with io.Reader: As already discussed, json.Decoder is ideal for processing JSON data from streams. This is particularly useful when dealing with large JSON files or network streams.

package main

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

type Person struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email"`
}

func main() {
    jsonData := `{"name":"John Doe","age":30,"email":"johndoe@example.com"}`
    reader := strings.NewReader(jsonData)

    var person Person
    err := json.NewDecoder(reader).Decode(&person)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("%+v\n", person)
}

3. Streaming with json.Decoder

Streaming with json.Decoder: If your JSON contains an array of objects and you want to process each object as it’s read, json.Decoder can be used in a streaming fashion. This approach is memory-efficient for large arrays.

package main

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

type Person struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email"`
}

func main() {
    jsonData := `[{"name":"John Doe","age":30,"email":"johndoe@example.com"}, {"name":"Jane Doe","age":28,"email":"janedoe@example.com"}]`
    reader := strings.NewReader(jsonData)

    decoder := json.NewDecoder(reader)
    // Read opening bracket of the array
    _, err := decoder.Token()
    if err != nil {
        log.Fatal(err)
    }

    // While the array contains values
    for decoder.More() {
        var person Person
        err := decoder.Decode(&person)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("%+v\n", person)
    }
}

4. json.RawMessage

json.RawMessage: When you need to delay JSON decoding, or only conditionally decode parts of the JSON, json.RawMessage can be used. It allows you to unmarshal a JSON object into a raw byte slice, which can be unmarshalled later.

package main

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

type Person struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email"`
}

func main() {
    jsonData := []byte(`{"name":"John Doe","age":30,"email":"johndoe@example.com"}`)

    var raw json.RawMessage = jsonData

    var person Person
    err := json.Unmarshal(raw, &person)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("%+v\n", person)
}

5. Using map[string]interface{} or interface{}

map[string]interface{} or interface{}: For very dynamic JSON structures where you don’t have a predetermined struct, you can unmarshal JSON into a map[string]interface{} or an empty interface{}. This method requires type assertion for accessing nested data.

package main

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

func main() {
    jsonData := []byte(`{"name":"John Doe","age":30,"email":"johndoe@example.com"}`)

    var data map[string]interface{}
    err := json.Unmarshal(jsonData, &data)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(data)
}

Each of these examples demonstrates a different method of working with JSON in Go, tailored to various use cases and data structures.

10