Working with JSON in Go

Go is a statically typed, compiled programming language designed at Google. It is known for its simplicity, strong static typing, and for its ability to handle multicore and networked systems.

One of the most common tasks that developers do is working with JSON (JavaScript Object Notation). JSON is a lightweight data-interchange format that is easy for humans to read and write and easy for machines to parse and generate. In this tutorial, we will learn how to work with JSON in Go.

JSON Encoding

To encode JSON data, we use the json.Marshal function. This function takes an input interface and returns a slice of bytes and an error value.

Let's consider the following example:

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    Name string
    Age  int
}

func main() {
    user := User{Name: "John Doe", Age: 30}

    data, err := json.Marshal(user)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(data))
}

In this example, we define a User struct with Name and Age fields. Then we create a User instance and convert it to JSON using json.Marshal. If there is an error during the conversion, we print the error and exit the program. Otherwise, we print the JSON data.

This program outputs: {"Name":"John Doe","Age":30}.

JSON Decoding

To decode JSON data, we use the json.Unmarshal function. This function takes a slice of bytes and a pointer to the value into which the JSON data should be decoded.

Let's consider the following example:

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    Name string
    Age  int
}

func main() {
    data := []byte(`{"Name":"John Doe","Age":30}`)
    
    var user User
    err := json.Unmarshal(data, &user)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(user)
}

In this example, we have a JSON data as a slice of bytes. Then we decode it into a User instance using json.Unmarshal. If there is an error during the decoding, we print the error and exit the program. Otherwise, we print the User instance.

This program outputs: {John Doe 30}.

Working with JSON Arrays

JSON arrays can be encoded and decoded in a similar way. Let's consider the following example:

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    Name string
    Age  int
}

func main() {
    users := []User{
        {Name: "John Doe", Age: 30},
        {Name: "Jane Doe", Age: 20},
    }

    data, err := json.Marshal(users)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(data))

    var decodedUsers []User
    err = json.Unmarshal(data, &decodedUsers)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(decodedUsers)
}

In this example, we have an array of User instances. We encode it into JSON and decode it back into an array of User instances.

This program outputs:

[{"Name":"John Doe","Age":30},{"Name":"Jane Doe","Age":20}]
[{John Doe 30} {Jane Doe 20}]

Conclusion

Working with JSON in Go is straightforward. We use json.Marshal to encode JSON and json.Unmarshal to decode JSON. These functions work not only with single values but also with arrays and other complex types. Keep practicing to become more comfortable with these techniques!