Use parentheses to evaluate $key early as in:

 jq --null-input --arg key foobar '{($key): "value"}'

See also: Parentheses in JQ for .key

The main problem seems to be in your json data because you have:

{'a': 'apple', 'b', 'bananna'}

As far as I know using single quotes is not valid (use double quotes): json format.
The another problem I see is that you have a comma , between 'b' and 'bannana' (I assume you didn't notice that and you typed , instead of :)

So Your json data should be like this:

{"a": "apple", "b": "bananna"}

What is the proper syntax to get a key?

I usually see that the syntax '.key' is more used. However I think you should use any which works. For example, I see in your case that you are using a variable $key to get specific value from a json key. So, you should use something like ".$key" or maybe ."$key", .$key (I'm not sure if these are recommended):

Solution 1

FRUIT=$(echo $ALIASES | jq ".$key" -r)
#or
FRUIT=$(echo $ALIASES | jq ."$key" -r)
#or
FRUIT=$(echo $ALIASES | jq .$key -r)

If you use or want to use single quotes then you will not be able to pass any variable value to jq command. According to man bash:

Enclosing characters in single quotes (') preserves the literal value of each character within the quotes. A single quote may not occur between single quotes, even when preceded by a backslash

Therefore If you want to use single quotes to a json value by specifying some key you should use:

FRUIT=$(echo $ALIASES | jq '.somekey' -r)
#e.g.
FRUIT=$(echo $ALIASES | jq '.a' -r)
echo $FRUIT
#Output:
apple

You can check these answers for a better understanding about single quotes and double quotes

Solution 2 (using jq --arg)
I'm not sure why the code above doesn't work for you (using the double quotes). However there is another possible solution to pass variables to jq, you can try:

val="a"
echo $ALIASES | jq --arg key "$val" '.[$key]' -r

As you are using python to get the json then you should use the method json.dumps(your_json), for example:

python3 -c 'import json;aliases = json.load(open("file"));print(json.dumps(aliases))'

Fetching the value of a jq variable doesn't cause it to be executed as jq code.

Furthermore, jq lacks the facility to take a string, compile it as jq code, and evaluate the result. (This is commonly known as eval.)

So, short of a writing a jq parser and evaluator in jq, you will need to impose limits and/or accept a different format.

For example,

keys='[ [ "key1", "childkey" ], [ "key2", "childkey2" ] ]'  # JSON
jq --argjson keys "$keys" '.[] | [ getpath( $keys[] ) ]' file.json

or

keys='key1.childkey,key2.childkey2'
jq --arg keys "$keys" '
   ( ( $keys / "," ) | map( . / "." ) ) as $keys |
   .[] | [ getpath( $keys[] ) ]
' file.json

You can use square bracket indexing on all objects in jq, so [$name] works for what you're trying:

jq --arg key1 true --arg name "$name" '.Linux.script_executed[$name] = $key1 ...' 

This use of square brackets is not very well documented in the manual, which makes it look like you can only use .[xyz], but ["x"] works anywhere that .x would have as long as it's not right at the start of an expression (that is, .a.x and .a["x"] are the same, but ["x"] is an array construction).

Note the use of single quotes above - that is so Bash won't try to interpret $name and $key1 as shell variables. You should keep the double quotes for --arg name "$name", because that really is a shell variable, and it should be quoted to make it safe to use.

You almost got it right, but need the object value iterator construct, .[] to get the value corresponding to the key

.facts | keys_unsorted[] as $k | .[$k].stuff

This assumes that, inside facts you have one object containing the IP address as the key and you want to extract .stuff from it.

Optionally, to guard against objects that don't contain stuff inside, you could add ? as .[$k].stuff?. And also you could optionally validate keys against a valid IP regex condition and filter values only for those keys.

When a variable is used to specify a key name, it must be enclosed in parentheses:

{($key): .}

In fact, whenever a key-value pair is specified with a colon, the key must be enclosed in parentheses unless it is a JSON string constant.

Consider also passing in the shell variable (EMAILID) as a jq variable (here also EMAILID, for the sake of illustration):

   projectID=$(jq -r --arg EMAILID "$EMAILID" '
        .resource[]
        | select(.username==$EMAILID) 
        | .id' file.json)

Postscript

For the record, another possibility would be to use jq's env function for accessing environment variables. For example, consider this sequence of bash commands:

[email protected]  # not exported
EMAILID="$EMAILID" jq -n 'env.EMAILID'

The output is a JSON string:

"[email protected]"

shell arrays

Unfortunately, shell arrays are a different kettle of fish. Here are two SO resources regarding the ingestion of such arrays:

JQ - create JSON array using bash array with space

Convert bash array to json array and insert to file using jq

Congratulations on figuring out how to use to_entries.

One small suggestion is to avoid using shell interpolation to "construct" the jq program. A much better way to achieve the desired goal is to pass in the relevant values on the command-line. In your case, the following would be appropriate:

$ jq --arg username "$defaultusername" '
  .orgs | to_entries[] | select(.value == $username ).key'

Another small point is to avoid using echo to send JSON to STDIN. There are several possibilities, including these patterns:

• if you are using bash: jq .... <<< "$JSON"
• use printf "%s" "$JSON" | jq ...
• jq -n --argjson JSON "$JSON" '$JSON | ...'

In your case, the last of these alternatives would look like this:

$ jq --arg username "$defaultusername" --argjson JSON "$aliasConfig" '
    $JSON
    | .orgs | to_entries[] | select(.value == $username ).key'

Your original version isn't going to be evalable because the author name has spaces in it - it would be interpreted as running a command Doe with the environment variable AUTHOR set to John. There's also virtually never a need to pipe jq to itself - the internal piping & dataflow can connect different filters together.

All of this is only sensible if you completely trust the input data (e.g. it's generated by a tool you control). There are several possible problems otherwise detailed below, but let's assume the data itself is certain to be in the format you expect for the moment.

You can make a much simpler version of your jq program:

jq -r '.SITE_DATA | to_entries | .[] | .key + "=" + (.value | @sh)'

which outputs:

URL='example.com'
AUTHOR='John Doe'
CREATED='10/22/2017'

There's no need for a map: .[] deals with taking each object in the array through the rest of the pipeline as a separate item, so everything after the last | is applied to each one separately. At the end, we just assemble a valid shell assignment string with ordinary + concatenation, including appropriate quotes & escaping around the value with @sh.

All the pipes matter here - without them you get fairly unhelpful error messages, where parts of the program are evaluated in subtly different contexts.

This string is evalable if you completely trust the input data and has the effect you want:

eval "$(jq -r '.SITE_DATA | to_entries | .[] | .key + "=" + (.value | @sh)' < data.json)"
echo "$AUTHOR"

As ever when using eval, be careful that you trust the data you're getting, since if it's malicious or just in an unexpected format things could go very wrong. In particular, if the key contains shell metacharacters like $ or whitespace, this could create a running command. It could also overwrite, for example, the PATH environment variable unexpectedly.

If you don't trust the data, either don't do this at all or filter the object to contain just the keys you want first:

jq '.SITE_DATA | { AUTHOR, URL, CREATED } | ...'

You could also have a problem in the case that the value is an array, so .value | tostring | @sh will be better - but this list of caveats may be a good reason not to do any of this in the first place.

It's also possible to build up an associative array instead where both keys and values are quoted:

eval "declare -A data=($(jq -r '.SITE_DATA | to_entries | .[] | @sh "[\(.key)]=\(.value)"' < test.json))"

After this, ${data[CREATED]} contains the creation date, and so on, regardless of what the content of the keys or values are. This is the safest option, but doesn't result in top-level variables that could be exported. It may still produce a Bash syntax error when a value is an array, or a jq error if it is an object, but won't execute code or overwrite anything.