Emulate gron using jq

Question

I recently discovered jq and gron. For my use case, gron is sufficient, but I am a little worried by lack of development. There are some bugs that have not been addressed in an year, while I see that jq is actively developed.

So I would like to emulate gron using jq. I suspect it is not too difficult, but my knowledge of jq is limited.

As an example, I'd like to use jq to obtain this output:

T424f7496c3a01  -14889.86
demo    -15030.785

from this input:

{
  "T424f7496c3a01": {
    "remaining": -14889.86,
    "ts": 136572.504
  },
  "demo": {
    "remaining": -15030.785,
    "ts": 0.515
  }
}

I have come up with this jq script which does it:

jq -r '[keys,([.[]|.remaining|round|"\t"+tostring])]|transpose|.[]|add'

but it is much less readable than

gron | fgrep '.remaining = '

which produces

json.T424f7496c3a01.remaining = -18079.105;
json.demo.remaining = -18220.029;

that can be easily parsed using an IFS=" .=;" read loop in bash.

So I am asking a question of long-term maintainability: is there a simple script for jq that can give me something easily parseable in bash? I fear that using the jq script above in one month I will have no idea how it works...

P.S. The answer I chose answers the above query. I hoped there would be an equally simple answer for the query mentioned in the title, i.e. emulating gron by using jq. In fact, the comment below by @Kusalananda references How to print path and key values of JSON file, where the chosen answer is near enough to a gron emulation. Unfortunately, that solution is too complex to satisfy my long-term maintenance and readablity objectives.

Answer 1

Convert the input object to a set of "entries" with to_entries. Each entry is an object with a key key (the key from the object) and a value key (the value of that key in the object).

Pick out the .key and the corresponding .value.remaining value from each entry and put them in an array that you pass through @tsv to output a tab-delimited list.

$ jq -r 'to_entries[] | [.key, .value.remaining] | @tsv' file
T424f7496c3a01  -14889.86
demo    -15030.785

You could read this with IFS=$'\t' read -r the_id remaining in a loop, if you wanted, assuming no keys contained literal tabs, or newlines.

---

With intermediate results displayed:

$ jq -r 'to_entries[]' file
{
  "key": "T424f7496c3a01",
  "value": {
    "remaining": -14889.86,
    "ts": 136572.504
  }
}
{
  "key": "demo",
  "value": {
    "remaining": -15030.785,
    "ts": 0.515
  }
}

$ jq -r 'to_entries[] | [.key, .value.remaining]' file
[
  "T424f7496c3a01",
  -14889.86
]
[
  "demo",
  -15030.785
]

$ jq -r 'to_entries[] | [.key, .value.remaining] | @tsv' file
T424f7496c3a01  -14889.86
demo    -15030.785

Answer 2

Cheap gron emulator:

jq -r 'paths(scalars) as $key | "\($key | join(".")) = \(getpath($key))"'

For your data that will output

T424f7496c3a01.remaining = -14889.86
T424f7496c3a01.ts = 136572.504
demo.remaining = -15030.785
demo.ts = 0.515

The output isn't quite the same:

• The initial json. is left out (you can have it back if you really want).
• The ending semicolon is left out (ditto).
• Arrays will be output as foo.0, foo.1, etc. instead of foo[0] and foo[1] (otherwise formatting would be more complicated than just join).
• The "empty" = {} or = [] lines declaring objects and arrays are left out (it would just take a little handling to detect the type of each value).

But in general it's similar and you can grep it in the same way that you do with the gron output.

Overall I think it's more productive to learn how to solve problems directly in jq (you can do more interesting things and get output in exactly the format you want), but this is something you can stick in an alias and use like you would use gron.