wwader

Assume input is an array you can do it several ways depending on what you want:

    # output each value in the array separately 
    .[]

    # output each value but transform it in some way
    .[] | . * 2


    # map each value into a new array
    map(. * 2) 

    # same as above but manual iterate/collect
    [.[] | . * 2]

Same! and jq's regexp functions are quite powerful for transforming text into something more structured:

  $ echo -e "10:20: hello\n20:39: world" | jq -cR 'capture("^(?<timestamp>.*): (?<message>.*)$")'
  {"timestamp":"10:20","message":"hello"}
  {"timestamp":"20:39","message":"world"}


  $ echo -e "10:20: hello\n20:39: world" | jq -Rn '[inputs | capture("(?<t>.*): (?<m>.*)$").m] | join(" ")'
  "hello world"

Also using inputs/0 etc in combination with reduce and foreach it's possible to process streams of text that might not end.

Very nice! thanks for building this

The jaq author is working on a formal specification of jq https://github.com/01mf02/jq-lang-spec. I think it has also help that there are several implementations of jq now like, gojq, jaq and jqjq, that has helped finding edge cases and weird behaviours.

The sqlite source includes a CLI tool called showdb that is quite nice for poking around in database files

Note on (b): As i understand it JSONPath by design is limited to only be able to select things from the input, so can't build a new object, array etc.

open -a is nice, i use it with alias, ex:

  alias qt='open -a "quicktime player"'
  alias vlc='open -a "vlc"'

Yeap the syntax and semantics is quite different to other languages and it really took me a long time and deep understanding to really appreciate how expressive and damn well designed it is.

As a heavy jq user and now a days also maintainer i say welcome! happy to help if you run into some problem

Yeap love things like that, ex https://www.imdb.com/title/tt1787791/ and the mystery show podcast. Let me know if you know any!

Reminds me of the documentary Kim's video https://www.imdb.com/title/tt24132144/ recommended!

I think the alpine package format do use this in combination with tar being similar https://wiki.alpinelinux.org/wiki/Apk_spec

Nice haven't seen. Shameless plug fq support elf https://github.com/wader/fq and will have a look if i could lend some ideas from llvm-readelf

I once dumped a cassandra cluster to json (10ish gb i if remember correctly) and used jq to do queries

Comparison of last example from https://axel.leroy.sh/quick-refs#dasel

desel: .data.all().filterOr(moreThan(.quantity,3),equal(.quantity,3)).mapOf(key,key,quantity,quantity)

yq: .data[] | select(.quantity >= 3) | {"key": .key, "quantity": .quantity}

jq: .data[] | select(.quantity >= 3) | {key, quantity}

Hey! thanks for the jqjq shoutout!

> Oh oh, jq has bugs..., I hope you reported them. I wondered more than once whether I could trust the results of my jq invocations.

Yes report, and i'm one of the jq maintainers now a days :) and i think you can trust the result if your doing common things. The bugs i've encountered have usually been in exotic parts, ex https://github.com/jqlang/jq/issues/3128

No sure what your talking about, i get happy every time i get to use jq! :)

Yes it is! see the example in the readme how to run jqjq with jqjq. Sadly you will probably need a lot of memory, it used to work on my laptop but not anymore after some recent changes that seem to have increased memory use.

"thanks" :)

Hey! quite accurate, it was a mix of i just wanted to try to see how hard it would be and wanted to know more about jq. I guess it has limited practical use other than as a learning tool. But i've used it to prototype features for "original" jq like how eval could work, regex literals, some object literal syntax enhancements etc. Also i found a bunch of bugs and confusing behaviours in jq along the way :)

btw i didn't follow what you mean by "overlooked the 2 characters"?

Hey! jqjq author here. Some time :) but surpassingly not that much, after getting over some major hurdles like how to mix recursive decent parsing and infix operators (precedence climbing is nice) and how to eval jq's call semantic that uses thunk/lambdas args it was mostly to grind through the rest. Actually string interpolation was quite tricky also. Also helped that i've worked on various jq other implementations and also written quite a lot of jq in general :)

jq has quite a few more ways to input things more than from stdin and files. Some examples:

  $ abc=123 jq -cn '$ENV | {abc, othername: .abc}'
  {"abc":"123","othername":"123"}

  $ jq -cn --arg abc 123 '{$abc, othername: $abc}'
  {"abc":"123","othername":"123"}

  $ jq -cn --argjson abc 123 '{$abc, othername: $abc}'
  {"abc":123,"othername":123}

It do involve some quite complicated plumbing :) i hope i've made at least some more ppl interested in jq as a langauge and related tools with fq, jqjq, jq-lsp and by helping maintain the original jq project

Thanks for the kind words! I have to pass along most of the credit to the designers of jq and jq CLI interface. Lots of care and thought have gone into those, also gojq was big enabler. I feel more like plumber that half accidentally connected a bitstream decoder with a hacked up version of jq :D

Hey! fq author here, just want to say that i've looked at rq also :) nice to see ppl explore developing tools like this

Note that gojq also fixes and improves on some things compared to jq, like arbitrary-precision arithmetic (jq only preserves), some semantic and parsing improvement and fixes that will likely happen in jq at some point also, time zone/formatting/parsing fixes, etc

Hey, it was discussed a bit some years ago https://github.com/jqlang/jq/issues/1892

jq tries to preserve number precision if you don't do operation with them, but as you noted this is within some sanity. If you do operations the involved numbers will first be converted to binary64 (aka double), same as node and most other languages. This is what is recommended by RFC 7159 for interoperability.

You might want to look into using jq --stream together with inputs/truncate_stream/fromstream and friends if you want to use jq with large inputs. Not a speed daemon but will probably use a lot less memory.