You can get something fairly similar with fzf, using the --preview trick from [1]:

    echo '' | fzf --print-query --preview "cat *.json | jq {q}"

https://paweldu.dev/posts/fzf-live-repl/

A little slow with large json datasets, but a major game changer. Thank you for sharing!

fzf is so amazing. it basically replaced filemanagers completely for me.

This uses https://github.com/itchyny/gojq which is a pure Go re-implementation of jq. Can be used as a cli tool or as a library. Didn't know about this, very cool that it exists!

I made a VSCode extension for jq[0], so I really like when people see the power of jq.

I should probably update it with a couple of life improvements now that I think about it.

[0]: https://github.com/ldd/vscode-jq

Thanks for your plugin. I wish it had up arrow history. I keep a separate text log with commands and it would be nice if the plugin tracked them. Especially given the high numbers of jq syntax errors.

Great feature request. I've been there.

I'll look into it for sure!

If this hasn’t been said:

Is there a way to instantly find out what filter to use when you click on a certain row? Kind of like doing exploratory jq on VSCode so you can quickly move it to the shell?

So, I don't really understand. but! Suppose you have a JSON file like this:

  [
    {
      "a": 1,
      "b": 2
    },
    {
      "a": 5,
      "b": 6
    },
  ]

what exactly do you want to do with it?

If I was to click on the part that saus ’”b”:2’, could you show me the jq query I could use to get just that part of the json file?

Kind of similar to how some Git extensions show who has the last commit on a certain line of code when you click/place cursor on a line

Gotcha. I'd honestly also would want this, but I don't see an easy way of implementing it.

It sort of makes me wonder how xpath queries work and what algorithms are used.

At face value, for certain JSON files, it is probably possible to do quickly, like in my example above, but the devil is always in the details...

I too was falling into the trap of jq, but then I discovered gron, and it turned my world upside down. Long live gron!

gron looks pretty cool, but it doesn't really seem like a substitute for jq? jq does all sorts of transformations.

yep, gron simply rewrites json into a sane format that can be then transformed by the standard tools (grep, cut, sed, awk, ...). In practice, I use gron mostly to print json data in a human readable and editable format.

https://github.com/jcsalterego/jqq/ is similar, written in Ruby by HN user https://news.ycombinator.com/user?id=jcsalterego

If you're on macOS, I can't recommend this app enough:

https://apps.apple.com/us/app/json-editor/id567740330?mt=12

jq and the like are great, but when you're trying to understand something... NSTableView is often times easier to fall back to, haha.

jq is nice because it can handle massive json files. Do you know if this app handles hundreds of mb files?

It likely works about as fine as NSJSONSerialization does, which is to say: I've had no issues, although the "validating" does sometimes lag and that can be annoying.

If someone else uses it I'd be interested in their thoughts.

I started using `jq` for my API project and I have to say it makes JSON munging much nicer on the command line. I think it'd be really cool in order to have a `jq` based redirection service, where you can paste in the URL of the API you want and a query parameter of the `jq` query you want to create.

Something like:

https://jq.io/https://myapi.com/endpoint?jqparams=$PARAMS

So like bash via HTTP :)

That exists: https://github.com/captn3m0/jqaas

Oh cool! Kinda wish you had url params vs. having to curl with request data (kinda like https://cors-anywhere.herokuapp.com/), but wayyy better than nothing!

are you saying you want to use a json object as input to a query?

Retool does this btw. I work there because the product is SICK!

I think `jq`'s syntax is a bit different than bare JSON (I do basic stuff like `echo $CHANNELS_RESPONSE | jq -r ".public_identifier"`), I think it'd be like running a bash script as an input to a query :)

Also not sure whether to start repping TinyDev (my project) but I can pass in an arbitrary read-only SQL query via HTTP to create a materialized view from table(s). HTTP + local procedures is like a very simple RPC :)

Related tools for those working with JSON:

- jo: convert shell ouput to JSON

- jiq: interactive jq, useful when building complex jq queries

Also, catj - Displays JSON files in a flat, concise format.

https://github.com/soheilpro/catj

This is my favorite json viewer gui: https://github.com/ashwin/json-viewer

it's a single file python/tk script, requires no installation and no dependencies other than standard python

jid as well

Please explain what that's for.

Json Incremental Digger - https://github.com/simeji/jid

"..drill down JSON interactively by using filtering queries like jq"

This is pretty tangential, but it’s interesting to me that the examples use Mises, Hayek, and Menger. These are three famous economists that of which Menger is a shared ancestor in the other two’s academic-advisor-genealogy. In academic advisor genealogy being a direct descendant of one academic advisor just means that you had them as an advisor, thus since an advisor has multiple Ph.D. students It creates a family tree like structure. Anyways, I only learned this, because my Dad is actually an academic advisor descendant of Mises and Menger. Anyways if there is any Ph.D.s lurking here on hacker news in a mathematical field you might be able to find your own advisor genealogy here: https://www.genealogy.math.ndsu.nodak.edu/id.php?id=200008

Happy to see a few Austrian school economists in the example data!

jq seemed super useful when I first found it, but ultimately it was always easier to write a few lines of python to do what I needed

This doesn't seem to work that well. If you type invalid syntax, like '.[' then the window suddenly resizes to accomodate the error message, but not all of the text boxes resize.

jiq is probably a better tool.

Indeed. That is fault of my inexistent experience making "native" UIs -- or maybe the Fyne GUI framework wasn't smart enough.

Your hat tip to the famous Austrian economists in your examples, and the "fiat" part of your username are enough to indicate to me that we could be good friends ;-)

Nice project! Though as others already said, you can use fzf very effectively to get a GUI-like experience for such tools.

If you're not a fan of jq for its syntax, check out jql[1]. It too helps you to transform json files, but does so with a consistent, lispy syntax.

[1]:https://github.com/cube2222/jql

You mean?

    cat json | jq | less

I checked the code, it's concatenating the output with newlines. Not necessary at all.

If you want to preserve colors:

    jq . -C | less -R

No, that's not what it does.

To be fair, the readme doesn't explain it well. This is a GUI app that allows you to see the jq results in real time. Here [1] is a video.

[1] https://gfycat.com/oddtartbrahmanbull

Yay, useless use of cat. I think you mean

  jq . < json | less

Sorry for being pedantic. Moving on.

Yes, you can re-write it without using cat, but many people (including me) think it's clearer to read from left-to-right. Plus the mixing of sending the file through stdin and then using a pipe always makes my brain pause.

I just personally find that using cat as the first part of the pipeline makes everything easier.

Plus, if you're going to argue against useless use of cat, there's also no reason to send the file in through stdin. jq can read the file directly.

Agreed. Keeping the source on the far left (whether cat or curl) just makes things easiest to follow.

You can put `<json` on the left no problem.

(But it makes the pipeline harder to edit so actually I have no problem with `cat JSON`)

The input redirection pipe is not necessary either:

  jq . json | less

It's not useless if it makes it much more readable :)

I think you mean

    < json jq . | less

Congrats on saving two characters?

Wasn't able to run this yet.

For browsing a JSON file I can also recommend jsonfui. I've been using it for many years now and I'm actually surprised it doesn't have more stars on GitHub.

https://github.com/AdrianSchneider/jsonfui

I like https://github.com/akavel/up as this works on the command line and helps building fast pipes not only with jq, but also with every other text wrangling tool. But I wish it would be a little bit more polished.

I wish jq had a different name. I don't know its functions and (JSONPath's?) syntax well, so I'm frequently trying to use it in a hurry and digging through jQuery search results to find what I need.

You should be able to add -jquery to your query to remove it as a term. Or do "jq" most of the time it works to clear your results

Also duckduckgo can be better than google sometimes

DDG is terrible with this. I've had so many jq searches with the -jquery, and yet, I still many jquery results. It's super annoying.

I use DDG exclusively and yes of course I add -jquery after kicking myself for forgetting.

Plenty of results still slip through, and it seems some people abbreviate jQuery to jq anyway.

I built a small tool named jl to convert JSON to lines of text.

https://github.com/ajbruin/jl

Nice tool, and nice choice of example names!

fantastic work! installed.