Parsing JSON from the Command Line with Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup

  4. Parsing JSON from the Command Line - Using the encoding/json Package - A Real-World Example

  5. Conclusion

Introduction

In this tutorial, you will learn how to parse JSON data from the command line using the Go programming language. JSON (JavaScript Object Notation) is a popular data interchange format, and being able to parse it is a valuable skill in various scenarios. By the end of this tutorial, you will be able to write Go programs that can extract information from JSON strings or files.

Prerequisites

To follow along with this tutorial, you need to have a basic understanding of the Go programming language and how to write and execute Go programs. It’s also helpful to have some knowledge of JSON syntax.

Setup

Before we dive into parsing JSON, make sure you have Go installed on your system. Visit the official Go website (https://golang.org/) and download and install the Go distribution suitable for your operating system.

Once Go is installed, you should set up your Go workspace. Create a directory for your Go projects, and set the GOPATH environment variable to that directory.

Parsing JSON from the Command Line

Using the encoding/json Package

Go provides the encoding/json package, which makes it easy to parse JSON data. To use this package, you need to import it in your Go program:

import "encoding/json"

Parsing JSON Strings

We can start by parsing a JSON string using the Unmarshal function from the encoding/json package. The Unmarshal function takes a byte slice representing the JSON data and a pointer to a struct into which the data will be parsed.

Here’s an example that demonstrates how to parse a JSON string:

package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name    string `json:"name"`
	Age     int    `json:"age"`
	Country string `json:"country"`
}

func main() {
	jsonStr := `{"name": "John Doe", "age": 30, "country": "USA"}`

	var person Person
	err := json.Unmarshal([]byte(jsonStr), &person)
	if err != nil {
		fmt.Println("Error parsing JSON:", err)
		return
	}

	fmt.Println("Name:", person.Name)
	fmt.Println("Age:", person.Age)
	fmt.Println("Country:", person.Country)
}

In this example, we define a Person struct with corresponding JSON tags. The json.Unmarshal function is then used to parse the JSON string into a Person object. Finally, we can access the parsed data from the person variable.

Parsing JSON Files

Besides parsing JSON strings, we can also parse JSON data from files. To achieve this, we need to read the JSON file content into a byte slice and then use the Unmarshal function to parse it.

Here’s an example that demonstrates how to parse JSON from a file:

package main

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

type Person struct {
	Name    string `json:"name"`
	Age     int    `json:"age"`
	Country string `json:"country"`
}

func main() {
	filePath := "data.json"

	jsonData, err := ioutil.ReadFile(filePath)
	if err != nil {
		fmt.Println("Error reading JSON file:", err)
		return
	}

	var person Person
	err = json.Unmarshal(jsonData, &person)
	if err != nil {
		fmt.Println("Error parsing JSON:", err)
		return
	}

	fmt.Println("Name:", person.Name)
	fmt.Println("Age:", person.Age)
	fmt.Println("Country:", person.Country)
}

In this example, we read the JSON data from the file specified by filePath using ioutil.ReadFile. Then, we use the json.Unmarshal function to parse the JSON data into a Person object as before.

A Real-World Example

Let’s imagine we have a JSON file containing an array of person objects, each with a name and an age. We want to load this JSON file and find the average age of all the persons.

Here’s an example that demonstrates this scenario:

package main

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

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

func main() {
	filePath := "people.json"

	jsonData, err := ioutil.ReadFile(filePath)
	if err != nil {
		fmt.Println("Error reading JSON file:", err)
		return
	}

	var people []Person
	err = json.Unmarshal(jsonData, &people)
	if err != nil {
		fmt.Println("Error parsing JSON:", err)
		return
	}

	sum := 0
	for _, person := range people {
		sum += person.Age
	}

	averageAge := float64(sum) / float64(len(people))
	fmt.Printf("Average age: %.2f\n", averageAge)
}

In this example, we define a Person struct with Name and Age fields. We load the JSON data from the file specified by filePath and unmarshal it into a slice of Person objects. Then, we calculate the sum of all ages and divide it by the number of persons to find the average age. Finally, we print the average age with two decimal places.

Conclusion

In this tutorial, you learned how to parse JSON data from the command line using the Go programming language. You explored how to use the encoding/json package to parse JSON strings and files. Additionally, a real-world example was provided to demonstrate parsing an array of objects and performing some calculations on the parsed data.

Parsing JSON is a valuable skill, and being able to extract relevant information from JSON data is crucial in many applications. With the knowledge gained from this tutorial, you can now write Go programs that can handle JSON effectively.

Published:

Related Articles