How to Improve Readability of JSON with Shell Script Formatting

Making JSON Readable in Unix Shell Scripts

Working with JSON data in its raw form can be difficult, particularly when it comes to readability. In Unix-based systems, having a shell script that can pretty-print JSON facilitates analysis and debugging.

In this post, we'll look at how to use simple Unix shell commands to transform compressed JSON documents to more human-readable formats. This method ensures that JSON data is presented in an ordered and structured format.

Understanding JSON Pretty Printing in Shell Scripts

The first script leverages the power of the jq command-line tool to pretty-print JSON data. The #!/bin/bash shebang indicates that the script should be run in the Bash shell. It starts by checking if jq is installed using command -v jq > /dev/null. If jq is not found, the script exits with an error message. When jq is available, the script reads JSON input from stdin and processes it with jq '.', which outputs the JSON in a formatted and readable way. This approach is efficient for Unix-based systems where jq is readily available.

The second script uses Python to complete the same purpose. The #!/bin/bash shebang refers to the Bash shell, whereas python3 -c 'import sys, json; print(json.dumps(json.load(sys.stdin), indent=4))' is a one-liner that imports required modules and pretty-prints JSON data. The script takes JSON from stdin with sys.stdin, parses it with json.load, then converts it to human-readable format using json.dumps and a indent of 4 spaces. This approach is very handy when jq is not installed but Python is present.

Exploring Perl for JSON formatting

The third script utilizes Perl to format JSON data. The #!/usr/bin/perl shebang specifies that the script should be run in the Perl interpreter. It starts by loading the JSON module with use JSON;, which provides the necessary functions for handling JSON data. The script reads the entire JSON input at once using local $/ and , decodes it with decode_json, and finally pretty-prints it using to_json with the pretty option set to 1. This script is advantageous when working in environments where Perl is the preferred scripting language.

Each of these programs offers a reliable method for transforming compressed JSON data to a readable format. Users can utilize jq, Python, or Perl to select the tool that best suits their environment and tastes. These scripts improve readability while also making it easier to troubleshoot and comprehend JSON data structures.

#!/bin/bash
# This script uses jq to pretty-print JSON data

# Check if jq is installed
if ! command -v jq > /dev/null; then
  echo "jq is not installed. Please install jq to use this script."
  exit 1
fi

# Read JSON input from stdin and pretty-print it
jq '.'

#!/bin/bash
# This script uses Python to pretty-print JSON data

# Read JSON input from stdin and pretty-print it using Python
python3 -c 'import sys, json; print(json.dumps(json.load(sys.stdin), indent=4))'

#!/usr/bin/perl
# This script uses Perl to pretty-print JSON data
use JSON;
use strict;
use warnings;

my $json_text = do { local $/; <STDIN> };
my $json = decode_json($json_text);
print to_json($json, { pretty => 1 });

Advanced Techniques for JSON Formatting in Unix Shell

Aside from using simple tools like jq, Python, and Perl, there are more advanced methods for handling and pretty-printing JSON in Unix shell scripts. One such option is to use Node.js with its built-in JSON capabilities. Node.js offers a robust and adaptable framework for managing JSON, particularly when dealing with more complicated data structures. A simple Node.js script can be written to read from stdin and return structured JSON. This strategy is very handy when working in JavaScript-heavy environments or when JSON data needs to be processed further.

Another advanced technique is to use sed and awk to prepare JSON. While these tools are commonly used for text processing, they can be creatively combined to prepare JSON. For example, awk can be used to add newlines and indentation based on the structure of the JSON data, while sed can be used to fine-tune the output. Although this method is more complicated and less obvious than utilizing dedicated JSON tools, it can be useful in situations where only basic Unix utilities are available.