Your statement does not work, because you try to feed the data object into match, but match can only work on strings.

The following expression will do what you want. The to_entries converts the object to an array of keys and values. Then we iterate over this array by using map and select all entries where the .key (now a string) has a match. Finally we just print out the value of every element.

.data | to_entries | map(select(.key | match("what a burger";"i"))) | map(.value)

However, two comments:

• The [a,a,3] is not allowed in JSON, because a is not a number.
• It works because the keys ARE actually different, even if only the letter case is not equal. If at least two keys are identical, you will run into problems, because keys should be unique. In fact, jq will only output one of the elements then.

jq's regular expressions filters (test,match,capture) take raw text as their input. To apply a regex to key names, you'll first have to convert those key names into text.

jq provides a function to_entries for that:

cat jsonfile | jq 'to_entries'

output:

[
  {
    "key": "key11",
    "value": 1010
  },
  {
    "key": "key11_yes",
    "value": 13
  },
  {
    "key": "key11_no",
    "value": 14
  },
  {
    "key": "key12",
    "value": 12120
  },
...
]

This can then feed into a filter that extracts the key, tests it against a regexp, then either outputs the whole entry or omits it:

if (.key|test("key[0-9][0-9]$")) then ( {key: .key, value: .value } ) else empty end

The matching from_entries function can convert the remaining entries back to their original form, or with_entries can do it all in one step:

cat jsonfile|jq 'with_entries(if (.key|test("key[0-9][0-9]$")) then ( {key: .key, value: .value } ) else empty end )'

The result is all the pairs from the input whose keys matched the pattern:

{
  "key11": 1010,
  "key12": 12120,
  "key13": 12103
}

If you wanted exact match, save following into script.jq :

.[] | select(.Type == $match) | .Code

Then test with

$ jq -r --argjson match '["A"]' -f script.jq test.json
DEF
$ jq -r --argjson match '["B"]' -f script.jq test.json
GHI
$ jq -r --argjson match '["A", "B"]' -f script.jq test.json
JKL

Here, I would probably do two separate tests for simplicity, instead of trying to get negative/positive look-behinds/aheads right. Also, use test() rather than match() if you're just interested in whether a regular expression matches or not:

jq '.assets[].browser_download_url|select( (test("unstable")|not) and test("iso.sha512$"))' 

As for your script, you use [ !prerelease ] which is not using the prerelease variable. What you probably wanted to say was

if [ "$prerelease" != false ]; then

This could be done without an extra variable, though:

if ! curl -s "$github_latest_api_url" | jq -e .prerelease >/dev/null
then
    ...
fi

The -e option to jq makes the utility exit with an exit status that depends on the last evaluation.

To avoid having to fetch your JSON document three times, save the fetched JSON document in a temporary file. To avoid having to parse it three times, get all the data out of it in one go:

curl -s ... |
jq -r '[.prerelease, .published_at, (.assets[].browser_download_url|select( (test("unstable")|not) and test("iso.sha512$"))) ] | @tsv' |
{
    IFS=$'\t' read -r prerelease r_publish_date checksum_download_url
    if [ "$prerelease" != false ]; then
        # use "$r_publish_date" and "$checksum_download_url"
    fi
}

With

jq 'map_values(select(.value == "auto"))' file

... you pull out the parts of the top-level object that you are interested in:

{
  "package2": {
    "name": "package_2",
    "value": "auto"
  }
}

With map_values(expression), you apply expression to each sub-part of the input object. In this case, the part is kept if the test in the select() statement evaluates to true, and discarded otherwise. It's similar to map(expression), but you'd use map() on arrays and map_values() on objects.

From there, you can choose to get the top-level key:

$ jq -r 'map_values(select(.value == "auto"))|keys[]' file
package2

The keys function creates an array of all keys in the input object, and the [] at the end expands the array into a set of strings.

Note that if there are multiple sub-objects with auto as their .value key's value, you will get multiple strings out of this command.

For a brief moment, I was unsure whether you wanted the value of the .name key or the top-level key. Once I spotted that you only wanted the top-level key, I had already written the text below. I'm leaving it in as a sort of comment.

$ jq -r 'map_values(select(.value == "auto"))[].name' file
package_2

Using [].name at the end, expand the top-level object into a set of sub-objects and then extract the .name key's value from each.

This last one could also have been written

$ jq -r 'map_values(select(.value == "auto").name)[]' file
package_2

... which reduces the original object to only

{
  "package2": "package_2"
}

... and then extracts the values of all remaining keys with the trailing [].

Solution:

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

Found out the answer

jq 'select(.items | index("blue"))'