How to read json data format in Go [Practical examples]

In this article, we will discuss different ways we can read JSON data format into a map, struct, decode and encode, and save data into a JSON format in Golang.
Modern applications such as REST-APIs, Microservices, and MobileApps use JSON for easy communication across the services mainly for storing and transferring data across the server and web application.

We shall discuss the following:-

Advertisement
  • What is JSON?
  • Read JSON Data to map
  • Read JSON Data to struct
  • Save JSON Data
  • Using Marshal() (converting from a Go data type to an encoding)
  • Using UnMarshal() (converting to a Go data type)

 

What is JSON?

JSON is a JavaScript Object Notation very lightweight, text-based representation of javascript object literals, arrays, and scalar data type and language-independent data interchange format. It originated in the Javascript programming language and has built-in support from all other programming languages. Its main purpose is used to store and transfer data from server to web and vice versa.
Example of a JSON data format.

{
"companyname":"GoLinuxCloud",
"year":"5",
"services":"Online Academy"
"staffs":"10"
}

In JSON, the data are in Key/value pairs separated by a comma. The key must be a string based on the JSON schema definition while the value can be of a different scalar/type i.e string, object, list of objects, or strings.

Go offers built-in support for JSON encoding and decoding, including to and from built-in and custom data types.

 

Method-1: Reading JSON data To Map in Go

In Go, encoding/json package contains json.Unmarshal() method which parses JSON-encoded data and stores the results as pointer values by the interface method. In case the interface is nil or zero pointers, we shall obtain an error from json.Unmarshal() method as InvalidUnmarshalError. The interface accepts data in either object or an array format. Go interface is suitable when the data is unstructured hence no struct is created and desired output can be achieved by parsing the JSON data.

Example

//main.go
package main

import (
	"encoding/json"
	"fmt"
)

// sample json object to be parsed
var companyJSON = `{
	"name" : "GOLinuxCloud",
        "years_of_service" : "5",
        "nature_of_company" : "Online Academy",
        "no_of_staff" : "10"
}`

func main() {
	// Declared an empty map interface
	var dataResult map[string]interface{}

	// Unmarshal the JSON to the interface.its same as decode
	err := json.Unmarshal([]byte(companyJSON), &dataResult)
	if err != nil {
		fmt.Println(err)
	}

	// Print elements in map on the terminal the key and its value
	for key, value := range dataResult {
		fmt.Printf("%s : %v \n", key, value)
	}
}

Output:

Advertisement
$ go run main.go
name : GOLinuxCloud 
years_of_service : 5 
nature_of_company : Online Academy 
no_of_staff : 10 

Explanation

We he imported all required packages namely :- "encoding/json", "fmt". fmt package contain Printf() function to display key and values while encoding/json has unmarshall() function to convert data.

var companyJSON =`{}` Defined and declared company JSON as a global variable of specific JSON.

main():- Declared an empty interface of map of string map[string]interface{} to hold the parsed data from companyJSON variable. To convert the json object to a map, we used json.Unmarshall() function which unmarshall the json string by converting it byte into the map[string] interface and stores the value pointed to the interface as well as checking if there is error encountered during conversion.

We can finally create a for key, value:= range dataResult{} to loop through the mapped data and print the key and value because the data is stored in key/value pair in a map.

 

Method-2: Reading JSON data into struct in Go

Example-1: Decode JSON data into struct

Decoding json data into struct , the data must be of a certain format defined before. for example company details

 `{
"companyname":"GoLinuxCloud",
"year":"5",
}`

Its a formatted data and we can create a struct for that data to be parsed.

Example

package main

import (
	"encoding/json"
	"fmt"
)

// sample json object to be parsed
var companyJSON = `{
		"name" : "GOLinuxCloud",
        "year" : "5"}`

type Company struct {
	Name string
	Year string
}

func main() {
	//initialize the struct
	var company Company
	// Unmarshal the JSON string into byte into &company struct to store parsed data
	err := json.Unmarshal([]byte(companyJSON), &company)
	if err != nil {
		fmt.Println(err)
	}
	// Print struct values
	fmt.Printf("Name: %s, \nYear: %s \n", company.Name, company.Year)

}

Output:

$ go run main.go
Name: GOLinuxCloud, 
Year: 5 

Explanation

We define struct based on the JSON raw data provided. the struct attributes must be the same as one in the json though the json attributes are case insensitive

 

Example-2: Decoding JSON Array into struct

We can as well read json data in an array structure into Go struct.

Advertisement
package main

import (
	"encoding/json"
	"fmt"
)

// sample json object to be parsed
var companyJSON = `[{"name" : "GOLinuxCloud","year" : "2000"},
{"name" : "Google","year" : "1998"}]`

type Company struct {
	Name string
	Year string
}

func main() {
	//initialize the struct
	var company []Company
	// Unmarshal the JSON string into byte into &company struct to store parsed data
	err := json.Unmarshal([]byte(companyJSON), &company)
	if err != nil {
		fmt.Println(err)
	}
	// Print array of values in the struct
	fmt.Printf("Company : %+v \n", company)

}

Output:

$ go run main.go
Company : [{Name:GOLinuxCloud Year:2000} {Name:Google Year:1998}] 

 

Method-3: Writing data into JSON file in Go

In Go, encodig/jsn package provide a marshalIndent function which encode json data with an indentation \n,\t,comma or space, . ioutil pacjkage enable us to save data into a file using writeFile function which accepts a file_name, well indented json data and file write and read permission 0644 means file is readable by all the user groups, but writable by the user only. i.e ioutil.WriteFile(filename,data,0644)

Example

// main
package main

import (
	"encoding/json"
	"io/ioutil"
	"log"
)

//struct
type company struct {
	Name        string
	Year        int64
	Description string
	Country     string
	Address     Address
}
type Address struct {
	Street   string
	City     string
	Region   string
	PostCode int64
}
var saveJSON = "struct_to_Json.json"
func main() {

	// sample data from struct
	companyData := []company{
		{Name: "Google", Year: 1998, Description: "Cloud services", Country: "USA", Address: Address{
			Street:   "Parkway",
			City:     "California",
			Region:   "US",
			PostCode: 1600,
		}},
		{Name: "GoLinuxCloud", Year: 2019, Description: "Provides Online study material", Country: "USA", Address: Address{
			Street:   "Broadway",
			City:     "NewYork",
			Region:   "US",
			PostCode: 1000,
		}},
	}
	jsonData, err := json.MarshalIndent(companyData, "", " ")
	if err != nil {
		log.Fatalf("could not convert struct data into json file: %v", err)
	}

	//Save Json Data  into a json file
	if err = ioutil.WriteFile(saveJSON, jsonData, 0644); err != nil {
		log.Fatalf("could not saveJSON file: %v", err)
	}
	
}

Output:

$ go run main.go
$ cat struct_to_Json.json
[
 {
  "Name": "Google",
  "Year": 1998,
  "Description": "Cloud services",
  "Country": "USA",
  "Address": {
   "Street": "Parkway",
   "City": "California",
   "Region": "US",
   "PostCode": 1600
  }
 },
 {
  "Name": "GoLinuxCloud",
  "Year": 2019,
  "Description": "Provides Online study material",
  "Country": "USA",
  "Address": {
   "Street": "Broadway",
   "City": "NewYork",
   "Region": "US",
   "PostCode": 1000
  }
 }
]

Explanation

We have imported all required packages. companyData := []company{}Define a sample struct, initialized it and added array of data.
jsonData, err := json.MarshalIndent(companyData, "", " ") we have used space character for indentation,. you can use \t tab or space for formatting data.
Finally, we pass formatted data into ioutil.writefile() function to save the data into a file.

Advertisement

 

Method-4: Using Marshal() In Go

Go encoding/json package has Marshall function used for encoding JSON string from an original data type.

We make use of the following function func Marshal(v interface{}) ([]byte, error) it accepts json data to be encoded and returns an array of bytes as an output and error. errors should be handled during the program.

Example

package main

import (
	"encoding/json"
	"fmt"
)

type Company struct {
	Name string `json:"name"`
	Year string `json:"year"`
}

func main() {
	company := &Company{
		Name: "GoLinuxCloud",
		Year: "2019",
	}

	//Encoding company data using Marshall function
	jsondata, err := json.Marshal(company)
	if err != nil {
		fmt.Println(err)
	}
	// jsonData variable contains a data in form og bytes.
	// we have handled error in cas if encountered during execution
	fmt.Printf("Bytes : %v \n", jsondata) // will show the data inform of bytes

	// we need to convert the bytes of jsondata into json string by typecast it to a string function
	jsonOutput := string(jsondata)
	fmt.Printf("JSONDATA: %v\n", jsonOutput)
}

Output:

$ go run main.go
Bytes : [123 34 110 97 109 101 34 58 34 71 111 76 105 110 117 120 67 108 111 117 100 34 44 34 121 101 97 114 34 58 34 50 48 49 57 34 125] 
JSONDATA: {"name":"GoLinuxCloud","year":"2019"}

 

Method-5: Using UnMarshal() in Go

Go ,encoding/json package provides json.Unmashall() function which decodes json data format into a defined struct. Here is the function syntax used func Unmarshal(data []byte, v interface{}) errorresults are stored as value pointer to an interface v, incase the interface is nil the function return InvalidUnMarshallError which must be handled during the program.

Example

Advertisement
//main.go
package main

import (
	"encoding/json"
	"fmt"
)

type Data struct {
	Msg string `json:"msg"`
}

// data in jsonformat to be decoded
var jsonSample = `{"Msg":"Hello from GoLinuxCloud"}`

func main() {
	// struct instance
	var data Data

	//decoding Data struct from json formatted data
	err := json.Unmarshal([]byte(jsonSample), &data)
	if err != nil {
		fmt.Println(err)
	}
	// print data after decoding
	fmt.Printf(" %s\n", data)
}

Output:

  $ go run main.go
 {Hello from GoLinuxCloud}

 

Summary

In this article, we have used Golang encoding/json package which was helpful in reading JSON data into a map, struct, and save_json files using these JSON functions marshal ,unmarshal and MarshalIndent.

 

References

Encoding/json documentation
Json and Go
Go by Example

 

Didn't find what you were looking for? Perform a quick search across GoLinuxCloud

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

Buy GoLinuxCloud a Coffee

For any other feedbacks or questions you can either use the comments section or contact me form.

Thank You for your support!!

Leave a Comment

X