jq 1.7 veröffentlicht

 (github.com/jqlang)
3 Punkte von GN⁺ 2023-09-07 | 1 Kommentare | Auf WhatsApp teilen
  • Die nicht mehr unterstützte Option --argfile sowie die Filter leaf_paths und recurse_down wurden entfernt
  • Das Docker-Image wird nicht mehr über Docker Hub, sondern über ghcr.io/jqlang/jq bereitgestellt
  • Für Release-Builds werden mehrere Architekturen für Linux, macOS, Windows und Docker angegeben
  • --raw-output0 wurde hinzugefügt, sodass zwischen Ausgaben NUL-Bytes eingefügt werden können; die Ausgabe von Zeichenketten, die NUL enthalten, wird als Fehler behandelt
  • Unter Windows wurde die Option --binary/-b hinzugefügt, um Zeilenenden mit \n statt \r\n auszugeben
  • Mit JQ_COLORS lässt sich die Farbe von Objektschlüsseln festlegen, und die Umgebungsvariable NO_COLOR wird beachtet, um Farbausgabe zu deaktivieren
  • Das Problem mit dem Exit-Code der Option --exit-code/-e wurde behoben: Wenn der letzte Ausgabewert wahr ist, wird 0 zurückgegeben, bei false oder null 1, und wenn es keine Ausgabe gibt, 4
  • Zur Bewahrung der Präzision numerischer Literale werden dezimale Zahlenliterale verwendet; Vergleichsoperatoren respektieren die Präzision, arithmetische Operationen können sie jedoch abschneiden
  • Neue eingebaute Funktionen pick(stream), debug(msgs), scan($re; $flags) und abs wurden hinzugefügt
  • In if-Anweisungen kann der else-Zweig weggelassen werden; ein ausgelassenes else wird als Verhalten von . behandelt
  • halt und halt_error wurden so geändert, dass sie nicht mit der nächsten Eingabe fortfahren, sondern sofort beendet werden
  • Probleme wurden behoben, bei denen die Darstellung großer Zahlen auf einigen Plattformen fehlerhafte JSON-Ausgaben erzeugte, es bei der Nutzung von libjq mit Threads zu Segmentation Faults kam und --jsonarg einen Assert-Crash auslöste
  • CI, Scan-Builds, Releases und Website-Builds wurden auf GitHub Actions umgestellt, außerdem wurde OSS-Fuzz hinzugefügt

Verwandte Beiträge

1 Kommentare

 
GN⁺ 2023-09-07
Hacker-News-Meinungen

  • JQ ist großartig, ich mag es wirklich sehr.
    In unserem Produkt (einem JVM- und browserbasierten Kafka-Tool) haben wir eine Teilmenge von JQ in Clojure implementiert, damit Nutzer Daten transformieren/filtern können. Das war eine der spaßigsten Aufgaben, für die ich je Code geschrieben habe, und da ich generell gern Syntax schreibe, auch ein großes Dankeschön an Instaparse: https://github.com/Engelberg/instaparse
    Bei der Implementierung habe ich erfahren, dass JQ LISP-2 ist, was mich überrascht hat, weil es sich allein an der Syntax nicht so anfühlt: https://github.com/jqlang/jq/wiki/jq-Language-Description#:~...

    • Ich kann jq einfach nicht mögen. In der Bash-Script-Codebasis bei der Arbeit gibt es viel jq, ein Teil des Codes ist auch von mir, und wenn es die beste Wahl ist, nutze ich es widerwillig.
      Aber mich stören die nicht intuitive Query-Syntax, dass man für winzigste Schritte nachschlagen muss, und dass das Ergebnis wie ein Zauberspruch aussieht, den niemand außer jq-Experten entschlüsseln kann. Gegen DSLs, die wie bei htmx oder Tailwind in Strings eingebettet sind, habe ich generell eine instinktive Abneigung.
      Trotzdem erkenne ich an, dass es gut gemachte Software ist und es manchmal keine bessere Option gibt. Wenn man JSON in Bash verarbeitet, ist es im Vergleich zu sed/awk/cut-Monstern auch die am wenigsten schlechte Option. Trotzdem gehören jq-Befehle, die mitten im Script immer wie unentschlüsselbare Strings stehen, zusammen mit regulären Ausdrücken zu den Dingen, die ich in Code lieber nicht sehen möchte. Als Alternative habe ich auch schon Inline-Python in einem heredoc per Pipe übergeben, aber das wird genauso unordentlich wie jq-Scripts.
    • Ich habe auch einen JQ-Parser/eine JQ-Grammatik zu einem Online-LALR(1)/FLEX-Grammatik-Editor/Tester hinzugefügt: https://mingodad.github.io/parsertl-playground/playground/
      Wenn man in den Beispielen „Jq parser (partially working)“ auswählt und auf „Parse“ klickt, sieht man den Parser-Baum für den Quelltext unter „Input source“. Feedback ist jederzeit willkommen.
    • Für die JVM gibt es bereits eine JQ-Implementierung. Sie ist nicht zu 100 % vollständig, aber nutzbar: https://github.com/eiiches/jackson-jq
    • jq ist sehr gut dafür geeignet, Nutzer ihre eigenen Daten transformieren zu lassen. Wir verwenden einen ähnlichen Ansatz: Nutzer erstellen eingehende Webhook-Endpunkte, senden beliebige JSON-Daten und richten mit Regressionstests und Monitoring nützliche Mappings ein.
      jq macht die meisten Fälle einfach (im Grunde JSON-Punktnotation) und ermöglicht zugleich die komplexen Fälle im Long Tail.
    • Wenn das Produkt bereits nutzbar ist, würde ich es unbedingt ausprobieren wollen.

  • Ich mag jq, nutze aber auch JMESPath (besonders zusammen mit der AWS CLI), yq (einschließlich tomlq und xq) und dasel. Schade, dass hclq praktisch tot ist.
    https://jmespath.org/
    https://kislyuk.github.io/yq/
    https://github.com/TomWright/dasel
    https://hclq.sh/

    • JSON grepbar machen: https://github.com/tomnomnom/gron
      Ich benutze jq seit Jahren und bekomme das, was ich brauche, irgendwie immer zusammengebaut, aber intuitiv hat es sich für mich noch nie angefühlt. Sobald es nur ein wenig komplexer wird, kommt man ohne längeres Lesen der Dokumentation kaum zur Lösung; ich wünschte, es wäre einfacher zu benutzen.
    • Die Seite mit dem interaktiven JMESPath-Tutorial ist wirklich gut: https://jmespath.org/tutorial.html
      Sie hat mir geholfen, als ich die Syntax erstmals gelernt habe, und ich schaue auch heute noch dort nach, wenn ich über seltsame Syntax stolpere.
    • Ich habe ein kleines Tool gebaut, das zwischen mehreren Formaten in mehrere Formate konvertiert.
      Der wichtigste Anwendungsfall ist, Dinge wie CSV, TOML und XML in JSON zu konvertieren, um sie dann an jq zu pipen: https://github.com/sentriz/rsl
    • Als Alternativen gibt es auch diese Tools:
      https://github.com/kellyjonbrazil/jello
      https://github.com/wwkimball/yamlpath
    • Eine weitere hervorragende Alternative ist JSONPath; schade, dass es trotz seiner Stärken nicht breiter unterstützt und bekannter ist.
      Es ist von XPath inspiriert und fühlt sich vertrauter an als eine völlig neue DSL; die Kernfunktion ist aus meiner Sicht die rekursive Schlüsselabfrage. Schreibt man people..address, findet es überall im JSON alle address-Schlüssel unterhalb von „people“. Es ist meine Lieblings-Parsing-Sprache für JSON, und ich habe auch einen Artikel darüber geschrieben, wie man sie zum Parsen von JSON-Datensätzen nutzt.
      https://github.com/JSONPath-Plus/JSONPath
      https://scrapfly.io/blog/parse-json-jsonpath-python/

  • Wenn man jq nur gelegentlich nutzt und jedes Mal in die Doku schauen muss, lohnt sich ein Blick auf gron. Es ist grep-fähiges JSON.
    https://github.com/tomnomnom/gron

    • Simpel, wirkt aber sehr nützlich.
      Ich nutze seit Jahren curl cheat.sh/jq und halte cheat.sh insgesamt für eine hervorragende Ressource. Heutzutage würde ich vermutlich so etwas wie ChatGPT verwenden.
    • Es ist wirklich gut designt.
      Dinge wie gron | grep | sed | gron -u sind ebenfalls möglich.
    • Ich hatte immer mit der jq-Syntax zu kämpfen, bin aber jedes Mal beeindruckt, wie gut ChatGPT den passenden Befehl erzeugt, wenn man ihm ein Beispiel-JSON gibt.

  • Einer der Gründe, warum ich jq mag oder zumindest tolerieren kann, ist seine Stabilität. Skripte, die ich vor Jahren geschrieben habe, funktionieren heute noch genauso.
    Code, den ich dagegen für yq liegen hatte, ist häufig kaputtgegangen, weil yq sich ständig auf nicht abwärtskompatible Weise verbessert hat. Ich habe nicht untersucht, wie oft es solche Änderungen gab, war aber mehrfach betroffen, etwa bei CI-Skripten, wo die Versionen der Basis-Tools unterschiedlich sind und Updates in unterschiedlichem Tempo passieren.
    Deshalb war ich den jq-Maintainern immer dankbar, dass sie die Bedeutung von Abwärtskompatibilität verstanden haben. Ich hoffe, diese Ankündigung bedeutet nicht, dass diese Stabilität nur ein zufälliges Nebenprodukt von Stillstand war und dass beim Beheben dieses Stillstands die Stabilität geopfert wird.

  • Zusätzlich zu jq-ähnlichen Tools gibt es mit jo und jc interessante Werkzeuge, die man zusammen mit jq nutzt.
    https://github.com/jpmens/jo
    https://github.com/kellyjonbrazil/jc

    • Es gibt auch jless und gron.
      Von gron habe ich hier zum ersten Mal gehört, füge es aber der Vollständigkeit halber hinzu. Gleichzeitig scheint JSON so etwas wie das Standardausgabeformat für CLI-Tools zu werden. Idealerweise würden alle CLI-Tools ein Flag wie --json anbieten, sodass jc nicht mehr nötig wäre.
      https://jless.io/
      https://github.com/tomnomnom/gron

  • Verwandter Beitrag vom letzten Monat, „First release of jq in 5 years“: https://news.ycombinator.com/item?id=36951830
    Ich bin ein großer jq-Fan und nutze es ständig.

  • Endlich ist es so weit.
    Es ist wirklich großartig, wie die Community zusammengekommen ist, neue Maintainer rekrutiert und das Projekt wiederbelebt hat. Besonderer Dank gilt, nach GitHub-Benutzernamen, @stedolan, @itchyny und @owenthereal.

  • jq und miller gehören zusammen mit awk und vim zu den unverzichtbaren Dingen in meinem Werkzeugkasten.
    https://github.com/johnkerl/miller

  • Die neue eingebaute Funktion pick(stream) gibt eine Projektion des Eingabeobjekts oder -arrays aus.
    jq -n '{"a": 1, "b": {"c": 2, "d": 3}, "e": 4} | pick(.a, .b.c, .x)'
    Das ist wirklich eine rettende Funktion. Danke an die Beitragenden.

    • Wenn man nicht tief hineingreifen muss, geht es auch so:
      $ jq -n '{"a": 1, "b": {"c": 2, "d": 3}, "e": 4} | {a, e}'
      {
      "a": 1,
      "e": 4
      }
    • Ich habe jq vor ein paar Tagen aus Git installiert, um diese Funktion zu nutzen, und sie ist sehr hilfreich.
    • Eine wirklich großartige neue Funktion. Derzeit scheint das ohne vorheriges erneutes Zusammensetzen des Streams nicht möglich zu sein; eine Version von pick, die auch mit Streaming-Daten funktioniert, wäre daher schön.

  • jaq möchte ich ebenfalls empfehlen. Es ist ein jq-Klon mit Fokus auf Korrektheit, Geschwindigkeit und Einfachheit.
    Es implementiert nur eine Teilmenge von jq, aber bisher nutze ich es ziemlich zufrieden: https://github.com/01mf02/jaq