How to remove trailing commas from array in JSON

Install jq and use it to generate JSON files. Bash and sed are not the right tools to manipulate JSON.

In your case, building the JSON cannot be done in a single step. Let’s start with the list of images:

for i in "${ITEMS[@]}"; do
  echo "$i"
done |
jq -sRc '. | rtrimstr("n") | split("n")'

The for command above lists the items of the $ITEMS Bash array variable one per line. The output is piped to jq that processes it as follows:

• the command line option -s tells it to "slurp" all the input data into an array instead of processing each line individually;
• the option -R means "raw input"; combined with s it tells jq to read the whole input in a big string and apply the program only once to it;
• the option -c tells it to produce compact output (the entire JSON on a single line, without extra spaces).

The short options can be combined into a single word. -sRc is the same as -s -R -c.

The jq program:

.                  # `.` always means "the current item"; this means the input string here
|                  # pipe the value produced by the previous filter to the next filter
rtrimstr("n")     # trim "n" on the right side of the current item
|                  # pass (the trimmed string) to the next item
split("n")        # split the input string using newlines as the separator

The jq program basically does the opposite of the for loop but, very important, it processes raw data and produces a JSON (an array of strings).

Assuming the array is initialized as:

ITEMS=(foo bar "baz boo")

… the script above produces:

["foo","bar","baz boo"]

This allows us to write a larger command line that does what you need:

jq -n 
  --arg name "$itemName" 
  --argjson images "$(for img in "${imgArray[@]}"; do echo $img; done | jq -sRc '. | rtrimstr("n") | split("n")')" 
  --argjson types "$(for type in "${typeArray[@]}"; do echo $type; done | jq -sRc '. | rtrimstr("n") | split("n")')" 
  '{ itemName: $name, images: $images, type: $types, link: "/" }'

The command line options:

• -n tells jq to not read anything from stdin;
• --arg defines a variable (name) whose value is a raw string, the next argument); Bash computes that argument by expanding "$itemName";
• --argjson defines a variable (images) whose value is a JSON; jq parses this JSON before starting the execution of the program; "$(…)" produces the evaluation of the command between parentheses and the result is a single word; the command is the one described above, that produces an array encoded as JSON from a Bash array variable;
• { itemName: $name, images: $images, type: $types, link: "/" } is the jq program; it produces an object having the keys itemName, image, type and link, whose values are produced from the values of the jq variables set using --arg and --argjson; the value of link is the string literal /.

All in all, this big command line that invokes jq three times does what you need and you don’t have to worry about trailing commas or other JSON details. All you need to care is about wrapping everything in quotes properly.

Check it online.

Update

Because the code that renders imgArray into a JSON that encodes an array of strings runs in a sub-shell, we can change the IFS and use a single echo instead of a for loop to get the same outcome faster:

IFS=$'n'; echo "${imgArray[*]}"

The complete script becomes:

jq -n 
  --arg name "$itemName" 
  --argjson images "$(IFS=$'n'; echo "${imgArray[*]}" | jq -sRc '. | rtrimstr("n") | split("n")')" 
  --argjson types "$(IFS=$'n'; echo "${typeArray[*]}" | jq -sRc '. | rtrimstr("n") | split("n")')" 
  '{ itemName: $name, images: $images, type: $types, link: "/" }'

It has the same output but it’s shorter and it should run faster. Check it oneline.