None of your data contains "10.32.0.4:8055 10.32.0.7:8055".

You could pass multiple strings to contains(), using a bash array:

strings=("10.32.0.4:8055" "10.32.0.7:8055")

echo "${_metadatadashjson}" |
jq -r --args '.dashboard.panels[] | select(.targets[].expr | contains($ARGS.positional[])) | .targets[].expr' "${strings[@]}"

But contains will evaluate to true for each match. Ie. if one expr contained both strings, it would be selected (and printed) twice.

With test, that won't happen. Here's how you can add the |s between multiple strings, and pass them in a single jq variable (as well as escape all the dots):

strings=("10.32.0.4:8055" "10.32.0.7:8055")
IFS=\|
echo "${_metadatadashjson}" |
jq -r --arg str "${strings[*]//./\\.}" '.dashboard.panels[] | select(.targets[].expr | test($str)) | .targets[].expr'

Both examples print this:

jvm_threads_current{instance="10.32.0.4:8055",job="prometheus_gyrex"}
jvm_threads_current{instance="10.32.0.7:8055",job="prometheus_gyrex"}

Update: I forgot to escape the dots for test. I edited the test example so that all the dots get escaped (with a single backslash). It's regex, so (unescaped) dots will match any character. The contains example matches the strings literally (not regex).

Very close! In your select expression, you have to use a pipe (|) before contains.

This filter produces the expected output.

. - map(select(.Names[] | contains ("data"))) | .[] .Id

The jq Cookbook has an example of the syntax.

Filter objects based on the contents of a key

E.g., I only want objects whose genre key contains "house".

$ json='[{"genre":"deep house"}, {"genre": "progressive house"}, {"genre": "dubstep"}]'
$ echo "$json" | jq -c '.[] | select(.genre | contains("house"))'
{"genre":"deep house"}
{"genre":"progressive house"}

Colin D asks how to preserve the JSON structure of the array, so that the final output is a single JSON array rather than a stream of JSON objects.

The simplest way is to wrap the whole expression in an array constructor:

$ echo "$json" | jq -c '[ .[] | select( .genre | contains("house")) ]'
[{"genre":"deep house"},{"genre":"progressive house"}]

You can also use the map function:

$ echo "$json" | jq -c 'map(select(.genre | contains("house")))'
[{"genre":"deep house"},{"genre":"progressive house"}]

map unpacks the input array, applies the filter to every element, and creates a new array. In other words, map(f) is equivalent to [.[]|f].

From the manual on contains

The filter contains(b) will produce true if b is completely contained within the input. A string B is contained in a string A if B is a substring of A.

Therefore, contains also matches on substrings. Use == for exact matches, i.e. comparing with the entire string only:

jq --arg NAME "John" '.[] | select(.group == $NAME)'

I think this does what you want:

'.[]|select(index("a"))'

This applies index("a") to each sublist, which returns either the index of a in the list or null. Since null evaluates to false, using that as the select() condition finds only sublists that contain a.

Here it is in practice:

$ jq '.[]|select(index("a"))' <<EOF
> [
    ["a","b","c"],
    ["d","e","f"],
    ["g","h","i"]
]
EOF
[
  "a",
  "b",
  "c"
]

Solution:

jq -r '.[]|select(.hostname | startswith("abcd"))' jjjj

Using map_values to select only the arrays that contain the given value $val, then pulling out the keys of those arrays:

jq -r --argjson val 2 'map_values(select(contains([$val]))) | keys[]' file

contains() returns true if the given array ([$val]) is fully contained in the input to the function. If contains() returns true for an array in the input, select() will return that array.

I'm using map_values() to perform this selection of the arrays associated with the keys in the input object. This will give me a slimmed-down object with the arrays that pass the selection, and passing the result to keys will then give me an array of keys, which I unpack into a set of loose strings with the final [].

For the given input data, with 2 as the value of $val, this returns

18
28

I'm using --argjson rather than --arg to pass the value 2 into the expression as $val as the data is numeric, not strings.