51–60 of 65 posts
Earlier quoted context omitted.
Not sure I understand. I mean using the interactive mode to figure out the right query ("[].mumble.whatever...") and then being able to save the text of the query that you figured out by pointing and clicking. Like a graphical SQL query builder allows you to do.
You can do this with `jid -q`: https://github.com/simeji/jid (Its interactivity is keyboard- rather than mouse-based.)
JQ syntax feels too unusual, doesn't resemble known code, gives me the feeling of looking into cryptic Perl or regex, could never remember the simplest things. For example how would you take key k1 from a list of dicts [{k1: v1, k2: v2}, {k1: v3}]?
> For example how would you take key k1 from a list of dicts [{k1: v1, k2: v2}, {k1: v3}]? Do you mean something like: .[].k1 Give it a try. https://jqplay.org/ jq does have a learning curve, but just like any query language, including SQL, first you need to learn the basics of the query language in order to get things to work. In this case: * you know that .[] iterates over objects, so you use it to unpack the root…
This simply evals the argument. Not an alternative to jq. fx “code to eval”
fx .comments[].authors[].names
[1] https://medium.com/@antonmedv/discover-how-to-use-fx-effecti...
I also created Jellex[1], which is a TUI built on Jello to assist with building the python queries.
Jello gives you the power of python but without all of the boilerplate, so it’s nicer to use in Bash scripts.
Looks really nice. I wish it handled yaml as well.
y2j () {
ruby -r json -r yaml -e 'puts JSON.dump(YAML.load(STDIN))'
}
JQ syntax feels too unusual, doesn't resemble known code, gives me the feeling of looking into cryptic Perl or regex, could never remember the simplest things. For example how would you take key k1 from a list of dicts [{k1: v1, k2: v2}, {k1: v3}]?
Dunno if you'll see this given how many replies you already got, but rather than just dumping "how do you do that" here's a realization I had a while ago that made it way easier to understand:
jq's language is a series of filters/transformers more akin to bash pipes on a stream of data than anything else.
For example, just "." selects out the current object (and is needed to match the "root" at the start of the query), and jq pretty-prints the results (when to a terminal):
$ echo '[{"k1": "v1", "k2": "v2"}, {"k1": "v3"}]'
[{"k1": "v1", "k2": "v2"}, {"k1": "v3"}]
$ echo '[{"k1": "v1", "k2": "v2"}, {"k1": "v3"}]' | jq '.'
[
{
"k1": "v1",
"k2": "v2"
},
{
"k1": "v3"
}
]
$ echo '[{"k1": "v1", "k2": "v2"}, {"k1": "v3"}]' | jq '.[]'
{
"k1": "v1",
"k2": "v2"
}
{
"k1": "v3"
}
$ echo '[{"k1": "v1", "k2": "v2"}, {"k1": "v3"}]' | jq '.[].k1'
"v1"
"v3"
$ echo '[{"k1": "v1", "k2": "v2"}, {"k1": "v3"}]' | jq '.[] | .k1'
"v1"
"v3"
The "unwrap/flatten" [] can be used multiple times when nested arrays are involved, with or without the pipe syntax, but only works on arrays. It errors if given something else:
$ echo '[[1,2,3],[4,[5,6]]]' | jq '.[]'
[
1,
2,
3
]
[
4,
[
5,
6
]
]
$ echo '[[1,2,3],[4,[5,6]]]' | jq '.[][]'
1
2
3
4
[
5,
6
]
$ echo '[[1,2,3],[4,[5,6]]]' | jq '.[][][]'
jq: error (at :1): Cannot iterate over number (1)
$ echo '[[1,2,3],[4,[5,6]]]' | jq '.[] | .[]'
1
2
3
4
[
5,
6
]
$ echo '[[1,2,3],[4,[5,6]]]' | jq '.[] | .[] | .[]'
jq: error (at :1): Cannot iterate over number (1)
JQ syntax feels too unusual, doesn't resemble known code, gives me the feeling of looking into cryptic Perl or regex, could never remember the simplest things. For example how would you take key k1 from a list of dicts [{k1: v1, k2: v2}, {k1: v3}]?
> For example how would you take key k1 from a list of dicts [{k1: v1, k2: v2}, {k1: v3}]? Do you mean something like: .[].k1 Give it a try. https://jqplay.org/ jq does have a learning curve, but just like any query language, including SQL, first you need to learn the basics of the query language in order to get things to work. In this case: * you know that .[] iterates over objects, so you use it to unpack the root…
SQL is based on solid mathematical theory, relational algebra. I personally learned that (and tuple relational calculus) in college before learning SQL, which made it easier. It helps making it coherant. Is there something like this for jq? Often when people invent languages that are not based on solid theory, they tend to lack coherence. This can make learning them difficult if you're someone that relies on your mental model of how things "should" work, like I am.