It seems to me that you want to output the two values (VolumeId and Tags[].Value) on the same line?

If that's the case, then a simple string concatenation should be enough:

$ jq -r '.Volumes[] | .VolumeId + " " + .Tags[].Value' volumes.json
vol-00112233 vol-rescue-system
vol-00112234 vol-rescue-swap
vol-00112235 vol-rescue-storage

The above can then be used in a pipeline with while-read:

jq -r '.Volumes[] | .VolumeId + " " + .Tags[].Value' volumes.json \
| while read -r volumeId tagValue; do
  other_command "$volumeId" "$tagValue"
done

You should note that if there is more than one element in Tags the result will reflect that. This can however be avoided by referring the first element in Tags: .Tags[0].Value

$ jq -r '[ .[].list1[] ] | join(" ")' file
val1 val2 val3 val4 val5 val6

Create a new array with all the elements of each list1 array from each top-level key. Then, join its elements with spaces. This would give you the values in the order they occur in the input file.

An alternative (and arguably neater) approach is with map(.list1) which returns an array of arrays that you may flatten and join up:

$ jq -r 'map(.list1) | flatten | join(" ")' file
val1 val2 val3 val4 val5 val6

Your attempt generates one joined string per top-level key due to .list being one of the list1 arrays in turn. Your approach would work if you encapsulated everything up to the last pipe symbol in a [ ... ] (and expand the .list with .list[]) to generate a single array that you then join. This is what I do in my first approach above; only I use a slightly shorter expression to generate the elements of that array.

$ jq -r '[ to_entries[] |  { list: .value.list1 } | .list[] ] | join(" ")' file
val1 val2 val3 val4 val5 val6

I recommend using String Interpolation:

jq '.users[] | "\(.first) \(.last)"'

We are piping down the result of .users[] to generate the string ".first .last" using string interpolation. \(foo) syntax is used for string interpolation in jq. So, for the above example, it becomes "Stevie Wonder" (".users[].first .users[].second" working elementwise) and "Michael Jackson".

jq reference: String interpolation

The -r option should not be used if the output will be fed into another JSON parser; only the last jq in the pipeline should use it – otherwise you risk feeding non-JSON data into the second jq instance.

Your last example with .[0].t seems correct and works with jq 1.6.

$ cat json | jq '.tx' | jq -r '.[0].t'
t for a

But this can be simplified to a single jq invocation, first incrementally to:

$ cat json | jq -r '.tx | .[0].t'
t for a

and then finally to:

$ cat json | jq -r '.tx[0].t'
t for a

You forgot to filter the compontents array when selecting for Redundant System ROM.

A corrected variant of your code with some shortcuts added (note that -r is unneeded as you are outputting JSON, not raw strings):

jq '.members[] |
    {
        serverName,
        "system-firmware":
            .components[] | select(.componentName == "System ROM").componentVersion,
        "system-firmware-backup":
            .components[] | select(.componentName == "Redundant System ROM").componentVersion
    }' file

Given the data in the question, this would give you the following JSON document:

{
  "serverName": "my-host",
  "system-firmware": "A46 v2.80 (07/31/2023)",
  "system-firmware-backup": "A46 v2.60 (08/11/20223)"
}

To change one entry, make sure that the left-hand side of the assignment operator is a path in the original document:

jq --arg name John --arg phone 4321 \
    '( .contacts[] | select(.name == $name) ).phone = $phone' file

You can't use .contacts[] | select(.name == "John") | .phone |= ... since the select() extracts a set of elements from the contacts array. You would therefore only change the elements you extract, separately from the main part of the document.

Notice the difference in

( ... | select(...) ).phone = ...
^^^^^^^^^^^^^^^^^^^^^
path in original document

which works, and

... | select(...) | .phone = ...
      ^^^^^^^^^^^
      extracted bits

which doesn't work.

Using a loop for more than one entry, assuming e.g. bash:

names=( John Jane )
phones=( 4321 4321 )

tmpfile=$(mktemp)

for i in "${!names[@]}"; do
    name=${names[i]}
    phone=${phones[i]}

    jq --arg name "$name" --arg phone "$phone" \
        '( .contacts[] | select(.name == $name) ).phone = $phone' file >"$tmpfile"
    mv -- "$tmpfile" file
done

That is, I put the names in one array and the new numbers in another, then loop over the indexes and update file for each entry that needs changing, using a temporary file an intermediate storage.

Or, with an associative array:

declare -A lookup

lookup=( [John]=4321 [Jane]=4321 )

for name in "${!lookup[@]}"; do
    phone=${lookup[$name]}

    # jq as above
done

Assuming you have some JSON input document with the new phone numbers, such as

{
   "John": 1234,
   "Jane": 5678
}

which you can create using

jo John=1234 Jane=5678

Then you can update the numbers in a single jq invocation:

jo John=1234 Jane=5678 |
jq --slurpfile new /dev/stdin \
    '.contacts |= map(.phone = ($new[][.name] // .phone))' file

This reads our input JSON with the new numbers in a structure, $new, that looks like

[
  {
    "John": 1234,
    "Jane": 5678
  }
]

This is used in the map() call to change the phone numbers of any contact that is listed. The // .phone makes sure that if the name isn't listed, the phone number stays the same.

Sorry didn't see all the attention here, @tony-sol you can do it like this:

yq '.[] |= pick(["name", "status"])' data1.yaml

Explanation:

• You want to pick particular fields from each map in the array
• .[] |= will match each element in the array, and update that element w.r.t itself
• pick([]) will take a given map and pick fields (omitting the rest)

See https://mikefarah.gitbook.io/yq/operators/pick for details.

The different with doing .[] | (.name, .status) is that will match all elements and just pulling out just those values.

You want to run a .context,.score filter on each element of v I think:

$ jq -r '.[] | [.c, .e, .score, (.v[] | .context,.score)] | @csv' file.json
"A","B",0.99,"asdf",0.98,"bcdfd",0.97

This is equivalent to using the builtin map function without assembling the results back into an array.

Evidently one of the items in the array is a string. If your jq supports "?", then one possibility would be to use it:

.response[].text?

Another would be to check the type explicitly, e.g.:

.response[] | objects | .text

Yet another possibility:

.response[] | select(type=="object" and has("text")) | .text

If you want to have a placeholder value when there is no "text" field:

 .response[] | if type=="object" and has("text") then .text else null end

So it really depends on your requirements and perhaps the version of jq that you are using.

$ cat test.jq
# Iterate over "items"

.items[] |

# Place each extracted element into an array

[
    # Select elements

    .metadata.name,

    # Use parentheses to group
    ( .spec.containers[] | .name, .resources.limits["cpu","memory"] )
]

# Join the array together

| join(", ")

$ <input jq -r -f test.jq
kafka-0, kafka, 16, 16Gi, filebeat, 2, 256Mi