You can do this:

X=("hello world" "goodnight moon")
printf '%s\n' "${X[@]}" | jq -R . | jq -s .

output

[
  "hello world",
  "goodnight moon"
]

Simply use printf to format the output into JSON

First, you have a very blatant typo in this part of your code right here:

echo "${array[3]:$var-3:4}

Note there is no closing straight quote: ". Fixed it in the rewrite I did below:

But more to the point, doing something like this (using printf) as suggested in this StackOverflow answer. Tested and works in CentOS 7.

#!/bin/bash

readarray -t array <<< "$(df -h)";
var=$(echo "${array[1]}"| grep -aob '%' | grep -oE '[0-9]+');
df_output="${array[3]:$var-3:4}";

manufacturer=$(cat /sys/class/dmi/id/chassis_vendor);
product_name=$(cat /sys/class/dmi/id/product_name);
version=$(cat /sys/class/dmi/id/bios_version);
serial_number=$(cat /sys/class/dmi/id/product_serial);
hostname=$(hostname);
operating_system=$(hostnamectl | grep "Operating System" | cut -d ' ' -f5-);
architecture=$(arch);
processor_name=$(awk -F':' '/^model name/ {print $2}' /proc/cpuinfo | uniq | sed -e 's/^[ \t]*//');
memory$(dmidecode -t 17 | grep "Size.*MB" | awk '{s+=$2} END {print s / 1024"GB"}');
hdd_model=$(cat /sys/block/sda/device/model);
system_main_ip=$(hostname -I);

printf '{"manufacturer":"%s","product_name":"%s","version":"%s","serial_number":"%s","hostname":"%s","operating_system":"%s","architecture":"%s","processor_name":"%s","memory":"%s","hdd_model":"%s","system_main_ip":"%s"}' "$manufacturer" "$product_name" "$version" "$serial_number" "$hostname" "$operating_system" "$architecture" "$processor_name" "$memory" "$hdd_model" "$system_main_ip"

The output I get is this:

{"manufacturer":"Oracle Corporation","product_name":"VirtualBox","version":"VirtualBox","serial_number":"","hostname":"sandbox-centos-7","operating_system":"CentOS Linux 7 (Core)","architecture":"x86_64","processor_name":"Intel(R) Core(TM) i5-1030NG7 CPU @ 1.10GHz","memory":"","hdd_model":"VBOX HARDDISK   ","system_main_ip":"10.0.2.15 192.168.56.20 "}

And if you have jq installed, you can pipe the output of the shell script to jq to “pretty print” the output into some human readable format. Like let’s say your script is named my_script.sh, just pipe it to jq like this:

./my_script.sh | jq

And the output would look like this:

{
  "manufacturer": "Oracle Corporation",
  "product_name": "VirtualBox",
  "version": "VirtualBox",
  "serial_number": "",
  "hostname": "sandbox-centos-7",
  "operating_system": "CentOS Linux 7 (Core)",
  "architecture": "x86_64",
  "processor_name": "Intel(R) Core(TM) i5-1030NG7 CPU @ 1.10GHz",
  "memory": "",
  "hdd_model": "VBOX HARDDISK   ",
  "system_main_ip": "10.0.2.15 192.168.56.20 "
}

There are two main ways to create a valid JSON array from arbitrary lists of strings. One is using jq with its --args option:

jq -c -n '$ARGS.positional' --args "${mylist[@]}"

or, if the elements are not to be encoded as strings (they may be plain numbers, for example, or previously prepared JSON strings or whole JSON objects),

jq -c -n '$ARGS.positional' --jsonargs "${mylist[@]}"

Note that --args and --jsonargs and its arguments need to be the last thing on the command line of jq.

I'm using -n to disable reading any external input and -c to create JSON in the "compact" output format, as shown in the question.

The other way is using jo, a tool specifically made to make it easy to generate JSON on the command line:

jo -a "${mylist[@]}"

The -a option to jo generates an array from the given arguments.

The jo tool infers the type of the object itself, so a list like

mylist=(1 2 3 4 5 b)

would be turned into the JSON array

[1,2,3,4,5,"b"]

If your jq has inputs then the simplest would probably be to use it:

jq -ncR '[inputs]' <<< "$groups"
["group1","group2","group3"]

Otherwise, here are three alternatives:

jq -c -n --arg groups "$groups" '$groups | split("\n")' 

echo -n "$groups" | jq -cRs 'split("\n")'

echo "$groups" | jq -R -s -c 'split("\n") | map(select(length>0))'

In any case, the array can easily be incorporated into a JSON object, e.g. by extending the filter with | {groups: .}

If you really want to produce invalid JSON, consider:

printf "%s" "$groups" | jq -Rrsc 'split("\n") | "{ \(.) }"'

Output:

{ ["group_1","group_2","group_3"] }

Note on select(length>0)

Consider:

 jq -Rsc 'split("\n")' <<< $'a\nb'
 ["a","b",""]

The reason for including select(length>0) is to avoid the trailing "".

If $groups contains consecutive newlines, and if it is important to retain the empty strings, then you might want to use [:-1], e.g.

jq -cRs 'split("\n")[:-1]' <<< "$groups"
["group1","group2","group3"]

If your jq does not support [:-1], make the 0 explicit: [0:-1]

I was also trying to convert a bunch of lines into a JSON array, and was at a standstill until I realized that -s was the only way I could handle more than one line at a time in the jq expression, even if that meant I'd have to parse the newlines manually.

jq -R -s -c 'split("\n")' < just_lines.txt

• -R to read raw input
• -s to read all input as a single string
• -c to not pretty print the output

Easy peasy.

Edit: I'm on jq ≥ 1.4, which is apparently when the split built-in was introduced.

Here is a Unit Tested alternate implementation.

It does not use eval, but jq's builtin @sh filter extensively to safely convert JSON data to properly escaped shell strings.

For the conversion back into JSON, it passes the path elements as shell arguments to jq, so there is no need to escape and reprocess it.

The conversion back to JSON also takes care of recreating numerical indexes. To make Unit Test possible, it uses jq's -S option to sort keys and -c compact output to minimize length of strings to compare.

#!/usr/bin/env bash

read -rd '' obj2bash <<'JQ'
# Collects each leaf paths into a $path array
leaf_paths as $path | {
  # Path array into bash string of space-delimited bash strings
  "key": ($path | @sh) | @sh,
  # Value into a bash sting
  "value": getpath($path) | @sh
} | (
  # Construct bash associative array element delcaration
  "[" + .key + "]=" + .value
)
JQ

read -rd '' bash2obj <<'JQ'
# Json object is passed as variable j
$j |
# Each path element is passed as positional argument array
setpath(
  [
    # Convert back path element to number if it is a number
    $ARGS.positional[] | tonumber? // .
  ];
  # Value is passed as variable v
  $v
)
JQ

json2assoc() {
  jq -r "$obj2bash"
}

assoc2json() {
  # shellcheck disable=SC2034 # shellcheck is nameref illiterate
  local -n ass=${1:?} && [ "${assoc@a}" = A ] || exit 2
  local -- json='{}'
  local -- k

  for k in "${!ass[@]}"; do
    local -a path="($k)"
    local -- v="${ass[$k]}"
    json=$(jq -ncS --argjson j "$json" --arg v "$v" "$bash2obj" --args "${path[@]}")
  done
  printf '%s\n' "$json"
}

jsonFile=${1:?}

# shellcheck disable=SC2155 # Dynamically built assoc declaration
declare -A assoc="($(json2assoc < "$jsonFile"))"

# Unit Test
generatedJson=$(assoc2json assoc)
inputJson=$(jq -cS . < "$jsonFile")

printf 'Input:\n%s\n' "$inputJson"
printf 'Generated:\n%s\n' "$generatedJson"

# Simple assertion function
assert() { eval "$*" || printf 'Assertion fail $?=%d: %s\n' "$?" "$*" >&2;}

assert '[ "$generatedJson" = "$inputJson" ]' || exit 1

Another Variant that merge the path array with / into a bash string to make it more practicable to use, reference and navigate those keys within Bash than with serialized Bash array declarations. It adds a constraint that JSON keys must not contain /:

#!/usr/bin/env bash

read -rd '' obj2bash <<'JQ'
leaf_paths as $path | {
  "key": $path | join("/") | @sh,
  "value": getpath($path) | @sh
} | ("[" + .key + "]=" + .value)
JQ

# shellcheck disable=SC2016 # Not shell variables
bash2obj='$j | setpath([$k | split("/")[] | tonumber? // .]; $v)'

json2assoc() { jq -r "$obj2bash";}

assoc2json() {
  # shellcheck disable=SC2034 # shellcheck is nameref illiterate
  local -n ass=${1:?} && [ "${assoc@a}" = A ] || exit 2
  local -- json='{}' k

  for k in "${!ass[@]}"; do
    json=$(jq -cnS --argjson j "$json" \
      --arg k "$k" --arg v "${ass[$k]}" "$bash2obj")
  done
  printf '%s\n' "$json"
}

jsonFile=${1:?}

# shellcheck disable=SC2155 # Dynamically built assoc declaration
declare -A assoc="($(json2assoc < "$jsonFile"))"

# Debug generated associative array
declare -p assoc

# Unit Test
generatedJson=$(assoc2json assoc)
inputJson=$(jq -cS . < "$jsonFile")

# Simple assertion function
assert() { eval "$*" || printf 'Assertion fail $?=%d: %s\n' "$?" "$*" >&2;}

assert '[ "$generatedJson" = "$inputJson" ]' || exit 1

The problem is that jq is still just outputting lines of text; you can't necessarily preserve each array element as a single unit. That said, as long as a newline is not a valid character in any object, you can still output each object on a separate line.

get_json_array | jq -c '.[]' | while read object; do
    api_call "$object"
done

Under that assumption, you could use the readarray command in bash 4 to build an array:

readarray -t conversations < <(get_json_array | jq -c '.[]')
for conversation in "${conversations[@]}"; do
    api_call "$conversation"
done

I'd get jq to output the results line-wise. Then use the bash mapfile command to read the lines into an array

mapfile -t correct < <(jq -r '.results[] | .correct_answer' <<<"$quiz")
declare -p correct

declare -a correct=([0]="Amazon" [1]="60 lbs" [2]="True")

For the incorrect answers, since bash does not have multi-dimensional arrays, I'd get jq to output the array of incorrect answers as CSV:

mapfile -t incorrect < <(jq -r '.results[] | .incorrect_answers | @csv' <<<"$quiz")
declare -p incorrect

declare -a incorrect=([0]="\"Netflix\",\"BBC\",\"CCTV\"" [1]="\"30 lbs\",\"50 lbs\",\"70 lbs\"" [2]="\"False\"")

Then:

$ echo "q $i: ans=${correct[i]}; wrong=${incorrect[i]}"
q 1: ans=60 lbs; wrong="30 lbs","50 lbs","70 lbs"

Documentation:

• Process Substitution
• Here Strings

Assuming you're interacting with the user:

i=0
read -p "Answer to question $i: " answer

if [[ $answer == "${correct[i]}" ]]; then
    echo Correct
elif [[ ${incorrect[i]} == *"\"$answer\""* ]]; then
    echo Incorrect
else
    echo Invalid answer
fi

Keep in mind that within [[...]] the == operator is not a string equality operator, it is a pattern matching operator.

• the first test is a straightforward string comparison
• the second test sees if the CVS string holding the incorrect answers contains the answer in double quotes

If you really cannot use a proper JSON parser such as jq^[1] , try an awk-based solution:

Bash 4.x:

readarray -t values < <(awk -F\" 'NF>=3 {print $4}' myfile.json)

Bash 3.x:

IFS=$'\n' read -d '' -ra values < <(awk -F\" 'NF>=3 {print $4}' myfile.json)

This stores all property values in Bash array ${values[@]}, which you can inspect with
declare -p values.

These solutions have limitations:

• each property must be on its own line,
• all values must be double-quoted,
• embedded escaped double quotes are not supported.

All these limitations reinforce the recommendation to use a proper JSON parser.

^{Note: The following alternative solutions use the Bash 4.x+ readarray -t values command, but they also work with the Bash 3.x alternative, IFS=$'\n' read -d '' -ra values.}

grep + cut combination: A single grep command won't do (unless you use GNU grep - see below), but adding cut helps:

readarray -t values < <(grep '"' myfile.json | cut -d '"' -f4)

GNU grep: Using -P to support PCREs, which support \K to drop everything matched so far (a more flexible alternative to a look-behind assertion) as well as look-ahead assertions ((?=...)):

readarray -t values < <(grep -Po ':\s*"\K.+(?="\s*,?\s*$)' myfile.json)

Finally, here's a pure Bash (3.x+) solution:

^{What makes this a viable alternative in terms of performance is that no external utilities are called in each loop iteration; however, for larger input files, a solution based on external utilities will be much faster.}

#!/usr/bin/env bash

declare -a values # declare the array                                                                                                                                                                  

# Read each line and use regex parsing (with Bash's `=~` operator)
# to extract the value.
while read -r line; do
  # Extract the value from between the double quotes
  # and add it to the array.
  [[ $line =~ :[[:blank:]]+\"(.*)\" ]] && values+=( "${BASH_REMATCH[1]}" )
done < myfile.json                                                                                                                                          

declare -p values # print the array

^{[1] Here's what a robust jq-based solution would look like (Bash 4.x):
readarray -t values < <(jq -r '.[]' myfile.json)}

Given

$ cat languages.json
{
  "langs": ["JavaScript", "Ruby"]
}

then using jq:

$ jq -r '.langs[]' languages.json
JavaScript
Ruby