Creating json from two bash arrays

I have two bash arrays:

arr1="200 300 400"
arr2=(1000 10001 10002)

I would like to produce a json file with a bash script:

{
  "200": {"feature1": 1000},
  "300": {"feature1": 1001},
  "400": {"feature1": 1002}
}

I tried doing it with jq:

jq -n --arg arg1 "${arr1[*]}" \
      --arg arg2 "${arr2[*]}" \
      '{$arg1: {"feature1": $arg2}}'

but this only expands the whole arrays into one entry.

[EDIT]: What if I have the third array with file paths and would like to place them as feature 2:

{
  "200": {
    "feature1": 1000,
    "feature2": "path-to-files/1000.log"
  },
  "300": {
    "feature1": 1001,
    "feature2": "path-to-files/1001.log"
  },
  "400": {
    "feature1": 1002,
    "feature2": "path-to-files/1002.log"
  }
}

[EDIT2]: My workflow:

arr1="200 300 400"
arr2=()
arr3=()
arr2_content=1000
for i in $arr1; do
    arr2+=("$arr2_content")
    touch "$arr2_content.log"
    arr3+=("$PWD/$arr2_content.log")
    arr2_content=$((arr2_content+1))
done

Only arr2 is an array. arr1 is just a string containing spaces. Therefore you can read in arr1 using the --arg option, and / " " to split it at the spaces, and use the --args option for the "real" array arr2:

jq -n --arg arg "$arr1" '[$arg / " ", $ARGS.positional]
  | reduce transpose[] as [$key, $feature1] ({}; .[$key] = {$feature1})
' --args "${arr2[@]}"

{
  "200": {
    "feature1": "1000"
  },
  "300": {
    "feature1": "10001"
  },
  "400": {
    "feature1": "10002"
  }
}

To make the conversion to numbers in the values, use tonumber:

jq -n --arg arg "$arr1" '[$arg / " ", $ARGS.positional]
  | reduce transpose[] as [$key, $val] ({}; .[$key] = {feature1: $val | tonumber})
' --args "${arr2[@]}"

{
  "200": {
    "feature1": 1000
  },
  "300": {
    "feature1": 10001
  },
  "400": {
    "feature1": 10002
  }
}

Generalizing to:

How can I import two (or more) indexed bash arrays into jq

This is less trivial because the trick of using --args (populating the argument stack with the array items) can only be used once. Or more precisely: --args simply passes all remaining arguments to the internal $ARGS object, so even if you pass on both arrays, the items will arrive but the information where the first one ends and the second one starts will be lost. Here are a few workarounds:

Using a separator item

You could sneak in a special item between the two arrays, so that by spotting its index from within jq the arrays can be recovered by slicing around that item. The caveat here is that this separator item must be unique(ly identifiable), otherwise the splitting may occur anywhere across the arrays. Also finding such an item may or may not be easy, depending on the type of data stored in the arrays. Let's assume the empty string "" is such a value that never occurs as item in any of the arrays. Then you may go with something along the lines of:

keys="200 300 400"
arr1=("one" "two" "two and a half")
arr2=("three and four" "five" "six")
sep=""
init=1000
jq -n --arg keys "$keys" --arg sep "$sep" --argjson init "$init" '
  [$keys / " ", ($ARGS.positional | index($sep) as $i | .[:$i], .[$i+1:])]
  | . + [[$init + range(first | length)]]
  | reduce transpose[] as [$key, $feature1, $feature2, $counter] ({};
      .[$key] = {$counter, $feature1, $feature2}
    )
' --args "${arr1[@]}" "" "${arr2[@]}"    # note the special item

Providing array lengths

Instead of determining the index to split at based on the argument array itself, you could provide that information separately, as it is already available in the Bash context. For the use-case at hand, the arrays are believed to have equal lengths, so instead of repeating the indexing from above (which would work too), I will use _nwise which produces slices of equal lengths:

keys="200 300 400"
arr1=("one" "two" "two and a half")
arr2=("three and four" "five" "six")
len=${#arr1}    # note the dynamic computation of the length
init=1000
jq -n --arg keys "$keys" --argjson len "$len" --argjson init "$init" '
  [$keys / " ", ($ARGS.positional | _nwise($len))]
  | . + [[$init + range(first | length)]]
  | reduce transpose[] as [$key, $feature1, $feature2, $counter] ({};
      .[$key] = {$counter, $feature1, $feature2}
    )
' --args "${arr1[@]}" "${arr2[@]}"    # just the two arrays

Preprocessing the arrays

A completely different approach could be to invoke separate instances of jq just to convert the bash arrays into JSON arrays (one call per array - the --args option can be used here as shown above). This is practical, as jq offers more possibilities to read in JSON arrays (after all it's a JSON processor). However, keep in mind that performacewise this can become expensive, especially when loops and iterations are involved. But If there is only a single run with two arrays, the difference between calling jq once and doing it three times will hardly be noticeable. To import the JSON array, using options like --argjson for inline data (as seen in the last approach), or --argfile and --slurpfile for referenced data (using process substitution <() here is quite common) would be one way. As this use-case has no (other) external input (we were using the -n option all the time), the converted arrays can also be streamed in via the "main enterance". Using -s instead also can take care of collecting the stream into a big array (which is the counterpart of what happened in the first line of the previous approaches):

keys="200 300 400"
arr1=("one" "two" "two and a half")
arr2=("three and four" "five" "six")
init=1000
{
  jq -n '$ARGS.positional' --args "${arr1[@]}"
  jq -n '$ARGS.positional' --args "${arr2[@]}"
} |
jq -s --arg keys "$keys" --argjson init "$init" '    # no other parameters here
  [$keys / " "] + . + [[$init + range(first | length)]]
  | reduce transpose[] as [$key, $feature1, $feature2, $counter] ({};
      .[$key] = {$counter, $feature1, $feature2}
    )
'

Output

All these approaches produce the same output:

{
  "200": {
    "counter": 1000,
    "feature1": "one",
    "feature2": "three and four"
  },
  "300": {
    "counter": 1001,
    "feature1": "two",
    "feature2": "five"
  },
  "400": {
    "counter": 1002,
    "feature1": "two and a half",
    "feature2": "six"
  }
}