jq - Online in der Cloud

PROGRAMM:

NAME/FUNKTION

jq - Befehlszeilen-JSON-Prozessor

ZUSAMMENFASSUNG

jq [Optionen...] Filter [Dateien...]

jq kann JSON auf verschiedene Weise transformieren, durch Auswählen, Iterieren, Reduzieren usw.
JSON-Dokumente manipulieren. Führen Sie zum Beispiel den Befehl aus jq ´Karte(.Preis) | hinzufügen werden wir
Nehmen Sie ein Array von JSON-Objekten als Eingabe und geben Sie die Summe ihrer "Preis"-Felder zurück.

jq kann auch Texteingaben akzeptieren, aber standardmäßig jq liest einen Stream von JSON-Entitäten
(einschließlich Zahlen und andere Literale) von Standard. Leerzeichen werden nur zum Trennen benötigt
Entitäten wie 1 und 2 sowie true und false. Ein oder mehr Dateien angegeben werden, in denen
Häuser jq wird stattdessen Eingaben von diesen lesen.

Das Optionen sind in der beschrieben AUFRUFEN JQ Sektion; sie betreffen hauptsächlich Input und Output
Formatierung. Das Filter ist in der jq-Sprache geschrieben und gibt an, wie die
Eingabedatei oder Dokument.

FILTER

Ein jq-Programm ist ein "Filter": Es nimmt eine Eingabe und erzeugt eine Ausgabe. Es gibt viele
eingebaute Filter zum Extrahieren eines bestimmten Feldes eines Objekts oder zum Umwandeln einer Zahl in
eine Zeichenfolge oder verschiedene andere Standardaufgaben.

Filter können auf unterschiedliche Weise kombiniert werden - Sie können die Ausgabe eines Filters in
einen anderen Filter oder sammeln Sie die Ausgabe eines Filters in einem Array.

Einige Filter erzeugen mehrere Ergebnisse, zum Beispiel gibt es einen, der alle
Elemente seines Eingabearrays. Wenn dieser Filter in einen zweiten geleitet wird, läuft der zweite Filter für
jedes Element des Arrays. Im Allgemeinen Dinge, die mit Schleifen und Iteration gemacht werden würden
in anderen Sprachen werden einfach Filter in jq zusammengeklebt.

Es ist wichtig, sich daran zu erinnern, dass jeder Filter einen Eingang und einen Ausgang hat. Sogar Literale
wie "Hallo" oder 42 sind Filter - sie nehmen eine Eingabe entgegen, erzeugen aber immer das gleiche Literal wie
Ausgang. Operationen, die zwei Filter kombinieren, wie z. B. Addition, speisen im Allgemeinen den gleichen Input
beides zusammen und kombiniere die Ergebnisse. So können Sie einen Mittelungsfilter implementieren als hinzufügen / Länge
- Einspeisung des Input-Arrays sowohl in die hinzufügen filtern und die Länge filtern und dann durchführen
der Unternehmensbereich.

Aber das eilt uns voraus. :) Fangen wir mit etwas einfacherem an:

AUFRUFEN JQ

jq-Filter werden in einem Stream von JSON-Daten ausgeführt. Die Eingabe von jq wird als Sequenz von geparst
durch Leerzeichen getrennte JSON-Werte, die durch den bereitgestellten Filter eins bei a . geleitet werden
Zeit. Die Ausgabe(n) des Filters werden in Standardausgabe geschrieben, wiederum als Folge von
durch Leerzeichen getrennte JSON-Daten.

Hinweis: Es ist wichtig, die Quotierungsregeln der Shell zu beachten. Als allgemeine Regel ist es am besten,
zitieren (mit einfachen Anführungszeichen) das jq-Programm immer, da zu viele Zeichen mit
eine besondere Bedeutung für jq sind auch Shell-Metazeichen. Zum Beispiel, jq "foo" wird scheitern
die meisten Unix-Shells, weil das dasselbe ist wie jq foo, was in der Regel fehlschlägt
weil foo is nicht definiert. Bei Verwendung der Windows-Befehlsshell (cmd.exe) ist es am besten,
verwenden Sie doppelte Anführungszeichen um Ihr jq-Programm, wenn es auf der Befehlszeile angegeben wird (anstelle des -f
Programmdatei Option), aber dann müssen doppelte Anführungszeichen im jq-Programm einen umgekehrten Schrägstrich als Escapezeichen verwenden.

Sie können beeinflussen, wie jq seine Ein- und Ausgabe liest und schreibt, indem Sie einige Befehlszeilen verwenden
Optionen:

· --Version:

Geben Sie die jq-Version aus und beenden Sie sie mit Null.

· --seq:

Verwenden Sie das application/json-seq MIME-Typ-Schema zum Trennen von JSON-Texten in jqs Eingabe
und Ausgabe. Dies bedeutet, dass ein ASCII-RS-Zeichen (Datensatztrennzeichen) vorher gedruckt wird
jeder Wert bei der Ausgabe und ein ASCII LF (Zeilenvorschub) wird nach jeder Ausgabe gedruckt. Eingang
JSON-Texte, die nicht geparst werden können, werden ignoriert (aber gewarnt) und alle verworfen
nachfolgende Eingabe bis zum nächsten RS. Dies parst auch die Ausgabe von jq ohne die
--seq .

· --Strom:

Analysieren Sie die Eingabe in Streaming-Manier und geben Sie Arrays von Pfad- und Blattwerten aus
(Skalare und leere Arrays oder leere Objekte). Zum Beispiel, "ein" wird [[],"ein"] und
[[],"a",["b"]] wird [[0],[]], [[1],"ein"] und [[1,0],"b"].

Dies ist nützlich, um sehr große Eingaben zu verarbeiten. Verwenden Sie dies in Verbindung mit
Filterung und die Veteran und foreach Syntax, um große Eingaben inkrementell zu reduzieren.

· --schlürfen/-s:

Anstatt den Filter für jedes JSON-Objekt in der Eingabe auszuführen, lesen Sie die gesamte Eingabe
in ein großes Array streamen und den Filter nur einmal ausführen.

· --raw-Eingabe/-R:

Analysieren Sie die Eingabe nicht als JSON. Stattdessen wird jede Textzeile als a . an den Filter übergeben
Schnur. In Kombination mit --schlürfen, dann wird die gesamte Eingabe als a . an den Filter übergeben
einzelne lange Saite.

· --null-eingabe/-n:

Keine Eingaben lesen! Stattdessen wird der Filter einmal mit ausgeführt null als Eingabe.
Dies ist nützlich, wenn Sie jq als einfachen Taschenrechner verwenden oder JSON-Daten daraus erstellen
Kratzer.

· --compact-output / -c:

Standardmäßig druckt jq die JSON-Ausgabe hübsch aus. Die Verwendung dieser Option führt zu mehr
kompakte Ausgabe, indem Sie stattdessen jedes JSON-Objekt in eine einzelne Zeile stellen.

· --Tab:

Verwenden Sie für jede Einrückungsebene einen Tabulator anstelle von zwei Leerzeichen.

· --Einzug n:

Verwenden Sie die angegebene Anzahl von Leerzeichen (nicht mehr als 8) zum Einrücken.

· --Farbausgabe / -C und --monochrom-ausgabe / -M:

Standardmäßig gibt jq farbiges JSON aus, wenn auf ein Terminal geschrieben wird. Du kannst es erzwingen
Farbe erzeugen, auch wenn mit . in eine Pipe oder eine Datei geschrieben wird -C, und deaktivieren Sie die Farbe mit -M.

· --ascii-ausgabe / -a:

jq gibt normalerweise Nicht-ASCII-Unicode-Codepoints als UTF-8 aus, auch wenn die Eingabe angegeben ist
sie als Escape-Sequenzen (wie "\u03bc"). Mit dieser Option können Sie jq zwingen,
erzeugt eine reine ASCII-Ausgabe, bei der jedes Nicht-ASCII-Zeichen durch das Äquivalent ersetzt wird
Fluchtabfolge.

· --ungepuffert

Leeren Sie die Ausgabe, nachdem jedes JSON-Objekt gedruckt wurde (nützlich, wenn Sie langsam
Datenquelle in jq und die Ausgabe von jq an anderer Stelle weiterleiten).

· --sortierschlüssel / -S:

Geben Sie die Felder jedes Objekts mit den Schlüsseln in sortierter Reihenfolge aus.

· --Roh-Ausgabe / -r:

Wenn das Ergebnis des Filters ein String ist, wird es mit dieser Option direkt geschrieben
in die Standardausgabe anstatt als JSON-String mit Anführungszeichen formatiert. Das kann
nützlich sein, um jq-Filter dazu zu bringen, mit nicht-JSON-basierten Systemen zu kommunizieren.

· --Join-Ausgabe / -j:

Like -r aber jq druckt nicht nach jeder Ausgabe einen Zeilenumbruch.

· -f Dateinamen / --aus Datei Dateinamen:

Lesen Sie den Filter aus der Datei und nicht von einer Befehlszeile, wie die Option -f von awk. Du
kann auch ´#´ verwenden, um Kommentare abzugeben.

· -LVerzeichnis / -L Verzeichnis:

Vorbereiten Verzeichnis zur Suchliste für Module. Wenn diese Option verwendet wird, dann nein
eingebaute Suchliste verwendet wird. Siehe den Abschnitt über Module unten.

· -e / --Ausgangsstatus:

Setzt den Exit-Status von jq auf 0, wenn der letzte Ausgabewert keiner war falsch noch null,
1, wenn der letzte Ausgabewert entweder falsch or null, oder 4, wenn nie ein gültiges Ergebnis vorliegt
produziert. Normalerweise wird jq mit 2 beendet, wenn ein Nutzungsproblem oder ein Systemfehler aufgetreten ist, 3
wenn ein jq-Programmkompilierungsfehler aufgetreten ist, oder 0, wenn das jq-Programm ausgeführt wurde.

· --arg Name Wert:

Diese Option übergibt einen Wert als vordefinierte Variable an das jq-Programm. Wenn Sie jq . ausführen
mit --arg foo Bar und dann $ foo ist im Programm vorhanden und hat den Wert "Bar".
Beachten Sie, dass Wert wird als String behandelt, also --arg foo 123 wird binden $ foo zu "123".

· --argjson Name JSON-Text:

Diese Option übergibt einen JSON-codierten Wert als vordefinierte Variable an das jq-Programm. Wenn
du läufst jq mit --argjson foo 123 und dann $ foo ist im Programm vorhanden und hat die
Wert 123.

· --schlürfdatei Variablennamen Dateinamen:

Diese Option liest alle JSON-Texte in der benannten Datei und bindet ein Array der
geparste JSON-Werte in die angegebene globale Variable. Wenn du jq mit ausführst --argfile foo Bar,
dann $ foo ist im Programm verfügbar und hat ein Array, dessen Elemente entsprechen
die Texte in der Datei namens Bar.

· --argfile Variablennamen Dateinamen:

Verwende nicht. Verwenden --schlürfdatei stattdessen.

(Diese Option ist wie --schlürfdatei, aber wenn die Datei nur einen Text enthält, dann ist das
verwendet, sonst wird ein Array von Texten verwendet wie in --schlürfdatei.)

· --run-tests [Dateiname]:

Führt die Tests in der angegebenen Datei oder Standardeingabe aus. Dies muss die letzte gegebene Option sein
und berücksichtigt nicht alle vorhergehenden Optionen. Die Eingabe besteht aus Kommentarzeilen, leer
Zeilen und Programmzeilen gefolgt von einer Eingabezeile, so viele Ausgabezeilen wie es sind
erwartet (eine pro Ausgabe) und eine abschließende Leerzeile. Kompilierungsfehlertests
Beginnen Sie mit einer Zeile, die nur "%%FAIL" enthält, dann eine Zeile, die das Programm enthält, um
kompilieren, dann eine Zeile mit einer Fehlermeldung zum Vergleich mit der tatsächlichen.

Seien Sie gewarnt, dass sich diese Option rückwärts-inkompatibel ändern kann.

BASIC FILTER

.
Der absolut einfachste (und am wenigsten interessante) Filter ist .. Dies ist ein Filter, der seine
Eingabe und erzeugt sie unverändert als Ausgabe.

Da jq standardmäßig die gesamte Ausgabe hübsch druckt, kann dieses triviale Programm eine nützliche Möglichkeit sein,
Formatieren der JSON-Ausgabe von, sagen wir, curl.

jq ´.´
"Hallo Welt!"
=> "Hallo Welt!"

.foo, .foo.bar
Das einfachste nützlich Filter ist .foo. Bei Übergabe eines JSON-Objekts (auch bekannt als Wörterbuch oder Hash) als
input erzeugt es den Wert an der Taste "foo", oder null, wenn keine vorhanden ist.

Wenn der Schlüssel Sonderzeichen enthält, müssen Sie ihn in doppelte Anführungszeichen setzen wie
Dies: ."foo$".

Ein Filter der Form .foo.bar entspricht .foo|.bar.

jq ´.foo´
{"foo": 42, "bar": "weniger interessante Daten"}
=> 42

jq ´.foo´
{"notfoo": true, "alsonotfoo": false}
=> null

jq ´.["foo"]´
{"foo": 42}
=> 42

.fo?
Genau wie .foo, gibt aber nicht einmal einen Fehler aus, wenn . ist kein Array oder Objekt.

jq ´.foo?´
{"foo": 42, "bar": "weniger interessante Daten"}
=> 42

jq ´.foo?´
{"notfoo": true, "alsonotfoo": false}
=> null

jq ´.["foo"]?´
{"foo": 42}
=> 42

jq ´[.foo?]´
[1,2]
=> []

.[ ], .[2], .[10:15]
Sie können Felder eines Objekts auch mit Syntax wie . nachschlagen .["foo"] (.foo oben ist a
Kurzfassung davon). Dies funktioniert auch für Arrays, wenn der Schlüssel eine ganze Zahl ist.
Arrays sind nullbasiert (wie Javascript), also . [2] gibt das dritte Element des Arrays zurück.

Das .[10:15] Syntax kann verwendet werden, um ein Unterarray eines Arrays oder einen Teilstring eines Strings zurückzugeben.
Das von zurückgegebene Array .[10:15] hat die Länge 5 und enthält die Elemente aus dem Index 10
(einschließlich) bis Index 15 (ausschließlich). Jeder Index kann negativ sein (in diesem Fall zählt er)
rückwärts vom Ende des Arrays) oder weggelassen (in diesem Fall bezieht es sich auf den Anfang oder
Ende des Arrays).

Das . [2] Syntax kann verwendet werden, um das Element am angegebenen Index zurückzugeben. Negative Indizes sind
erlaubt, wobei sich -1 auf das letzte Element bezieht, -2 auf das vorletzte Element bezieht,
und so weiter.

Das .foo Syntax funktioniert nur für einfache Schlüssel, dh Schlüssel, die alle aus alphanumerischen Zeichen bestehen.
.[ ] arbeitet mit Schlüsseln, die Sonderzeichen wie Doppelpunkte und Punkte enthalten. Zum
Beispiel .["foo::bar"] und .["foo.bar"] arbeiten während .foo::bar und .foo.bar würde nicht.

Das ? "operator" kann auch mit dem Slice-Operator verwendet werden, wie in .[10:15]?, die ausgibt
Werte, bei denen die Eingaben Slice-fähig sind.

jq ´.[0]´
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> {"name":"JSON", "good":true}

jq ´.[2]´
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> null

jq ´.[2:4]´
["a","b","c","d","e"]
=> ["c", "d"]

jq ´.[2:4]´
"abcdefghi"
=> "CD"

jq ´.[:3]´
["a","b","c","d","e"]
=> ["a", "b", "c"]

jq ´.[-2:]´
["a","b","c","d","e"]
=> ["d", "e"]

jq ´.[-2]´
[1,2,3]
=> 2

.[]
Wenn Sie die .[Index] Syntax, aber lassen Sie den Index vollständig weg, es wird zurückgegeben alle dauert ebenfalls 3 Jahre. Das erste Jahr ist das sog.
Elemente eines Arrays. Laufen .[] mit der Eingabe [1,2,3] ergibt die Zahlen als drei
separate Ergebnisse statt als einzelnes Array.

Sie können dies auch für ein Objekt verwenden und es werden alle Werte des Objekts zurückgegeben.

jq ´.[]´
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> {"name":"JSON", "good":true}, {"name":"XML", "good":false}

jq ´.[]´
[]
=>

jq ´.[]´
{"a": 1, "b": 1}
=> 1, 1

.[]?
Like .[], aber es werden keine Fehler ausgegeben, wenn . ist kein Array oder Objekt.

,
Wenn zwei Filter durch ein Komma getrennt sind, wird die Eingabe in beide und dort eingespeist
werden mehrere Ausgaben sein: zuerst alle Ausgaben, die vom linken Ausdruck erzeugt werden, und
dann alle von der rechten Seite erzeugten Ausgaben. Filtern Sie zum Beispiel .foo, .barproduziert
sowohl die "foo"-Felder als auch die "bar"-Felder als separate Ausgaben.

jq ´.foo, .bar´
{"foo": 42, "bar": "etwas anderes", "baz": true}
=> 42, "etwas anderes"

jq ´.Benutzer, .Projekte[]´
{"user":"stedolan", "projects": ["jq", "wikiflow"]}
=> "stedolan", "jq", "wikiflow"

jq ´.[4,2]´
["a","b","c","d","e"]
=> "e", "c"

|
Die | Operator kombiniert zwei Filter, indem er die Ausgabe(n) des linken in
der Eingang des rechten. Es ist so ziemlich das gleiche wie die Pipe der Unix-Shell, wenn
das bist du gewohnt.

Wenn das linke Ergebnis mehrere Ergebnisse liefert, wird das rechte für
jedes dieser Ergebnisse. Also der Ausdruck .[] | .foo ruft das "foo"-Feld von jedem ab
Element des Eingabearrays.

jq ´.[] | .Name
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> "JSON", "XML"

TYPES UND WERTE

jq unterstützt die gleichen Datentypen wie JSON - Zahlen, Zeichenfolgen, Boolesche Werte, Arrays,
Objekte (die in JSON-Sprache Hashes mit nur String-Schlüsseln sind) und "null".

Boolesche Werte, null, Strings und Zahlen werden wie in Javascript geschrieben. So wie
alles andere in jq, diese einfachen Werte nehmen eine Eingabe und erzeugen eine Ausgabe - 42 ist eine
gültiger jq-Ausdruck, der eine Eingabe entgegennimmt, diese ignoriert und stattdessen 42 zurückgibt.

Feld Baugewerbe - []
Wie bei JSON, [] wird verwendet, um Arrays zu konstruieren, wie in [1,2,3]. Die Elemente der Arrays können
ein beliebiger jq-Ausdruck sein. Alle Ergebnisse, die von allen Ausdrücken erzeugt werden, werden gesammelt
in ein großes Array. Sie können es verwenden, um ein Array aus einer bekannten Anzahl von Werten zu erstellen
(Wie in [.foo, .Bar, .baz]) oder um alle Ergebnisse eines Filters in einem Array zu "sammeln" (wie
in [.Elemente[].Name])

Sobald Sie den ","-Operator verstanden haben, können Sie die Array-Syntax von jq auf eine andere Weise betrachten
Licht: der Ausdruck [1,2,3] verwendet keine integrierte Syntax für kommagetrennte Arrays,
sondern wendet stattdessen die an [] Operator (Ergebnisse sammeln) zum Ausdruck 1,2,3 (was
führt zu drei verschiedenen Ergebnissen).

Wenn Sie einen Filter haben X das vier Ergebnisse liefert, dann ist der Ausdruck [X] wird a produzieren
einzelnes Ergebnis, ein Array von vier Elementen.

jq ´[.Benutzer, .Projekte[]]´
{"user":"stedolan", "projects": ["jq", "wikiflow"]}
=> ["stedolan", "jq", "wikiflow"]

Objekte - {}
Wie JSON, {} dient zum Konstruieren von Objekten (auch bekannt als Wörterbücher oder Hashes), wie in: {"ein": 42,
"B": 17}.

Wenn die Tasten "sinnvoll" sind (alle alphabetischen Zeichen), können die Anführungszeichen weggelassen werden.
Der Wert kann ein beliebiger Ausdruck sein (obwohl Sie ihn möglicherweise in Klammern setzen müssen, wenn er
kompliziert), die auf die Eingabe des {}-Ausdrucks angewendet wird (denken Sie daran, alle Filter
einen Eingang und einen Ausgang haben).

{foo: .bar}

erzeugt das JSON-Objekt {"foo": 42} wenn das JSON-Objekt gegeben wird {"Balken":42, "baz":43}.
Damit können Sie bestimmte Felder eines Objekts auswählen: wenn es sich bei der Eingabe um ein Objekt mit
"Benutzer", "Titel", "ID" und "Inhalt" und Sie wollen nur "Benutzer" und "Titel", können Sie
schreiben

{Benutzer: .Benutzer, Titel: .Titel}

Da das so häufig vorkommt, gibt es eine Abkürzungssyntax: {Benutzer, Titel}.

Wenn einer der Ausdrücke mehrere Ergebnisse liefert, werden mehrere Wörterbücher
produziert. Wenn die Eingaben

{"user":"stedolan","titles":["JQ Primer", "More JQ"]}

dann der Ausdruck

{Benutzer, Titel: .titles[]}

erzeugt zwei Ausgaben:

{"user":"stedolan", "title": "JQ Primer"}
{"user":"stedolan", "title": "More JQ"}

Wenn Sie den Schlüssel in Klammern setzen, wird er als Ausdruck ausgewertet. Mit dem
gleiche Eingabe wie oben,

{(.Benutzer): .Titel}

produziert

{"stedolan": ["JQ Primer", "More JQ"]}

jq ´{Benutzer, Titel: .titles[]}´
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
=> {"user":"stedolan", "title": "JQ Primer"}, {"user":"stedolan", "title": "More JQ"}

jq ´{(.user): .titles}´
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
=> {"stedolan": ["JQ Primer", "More JQ"]}

GEBAUT BETREIBER UND FUNKTIONEN

Einige jq-Operatoren (z. B. +) tun unterschiedliche Dinge, je nach Art ihrer
Argumente (Arrays, Zahlen usw.). jq führt jedoch niemals implizite Typkonvertierungen durch. Wenn
Wenn Sie versuchen, einem Objekt einen String hinzuzufügen, erhalten Sie eine Fehlermeldung und kein Ergebnis.

Zusatz - +
Der Betreiber + nimmt zwei Filter, wendet sie beide auf dieselbe Eingabe an und fügt die
Ergebnisse zusammen. Was "Hinzufügen" bedeutet, hängt von den beteiligten Typen ab:

· Zahlen werden durch normale Arithmetik addiert.

· Arrays werden hinzugefügt, indem sie zu einem größeren Array verkettet werden.

· Streicher werden hinzugefügt, indem sie zu einer größeren Zeichenfolge verbunden werden.

· Objekte werden durch Zusammenführen hinzugefügt, d. h. durch Einfügen aller Schlüssel-Wert-Paare aus beiden
Objekte zu einem einzigen kombinierten Objekt. Wenn beide Objekte einen Wert für denselben enthalten
Schlüssel, das Objekt rechts vom + Gewinnt. (Für rekursive Zusammenführung verwenden Sie die * Operator.)

null kann zu jedem Wert hinzugefügt werden und gibt den anderen Wert unverändert zurück.

jq ´.a + 1´
{"a": 7}
=> 8

jq ´.a + .b´
{"a": [1,2], "b": [3,4]}
=> [1,2,3,4]

jq ´.a + null´
{"a": 1}
=> 1

jq ´.a + 1´
{}
=> 1

jq ´{a: 1} + {b: 2} + {c: 3} + {a: 42}´
null
=> {"a": 42, "b": 2, "c": 3}

Subtraktion - -
Neben der normalen arithmetischen Subtraktion von Zahlen ist die - Operator kann auf Arrays verwendet werden
um alle Vorkommen der Elemente des zweiten Arrays aus dem ersten Array zu entfernen.

jq ´4 - .a´
{"a":3}
=> 1

jq´. - ["xml", "yaml"]´
["xml", "yaml", "json"]
=> ["json"]

Multiplikation, Aufteilung, Form - *, /, und %
Diese Infixoperatoren verhalten sich wie erwartet, wenn zwei Zahlen angegeben werden. Division durch Null erhöht
ein Fehler. x % y berechnet x modulo y.

Das Multiplizieren einer Zeichenfolge mit einer Zahl erzeugt die Verkettung dieser Zeichenfolge so viele
Zeiten. "x" * 0 produziert null.

Wenn Sie einen String durch einen anderen teilen, wird der erste geteilt, wobei der zweite als Trennzeichen verwendet wird.

Durch die Multiplikation zweier Objekte werden sie rekursiv zusammengeführt: Dies funktioniert wie eine Addition, aber wenn beide
Objekte enthalten einen Wert für denselben Schlüssel, und die Werte sind Objekte, die beiden werden zusammengeführt
mit der gleichen Strategie.

jq ´10 / . * 3
5
=> 6

jq´. / ", "´
"a, b, c, d, e"
=> ["a","b,c,d","e"]

jq ´{"k": {"a": 1, "b": 2}} * {"k": {"a": 0,"c": 3}}´
null
=> {"k": {"a": 0, "b": 2, "c": 3}}

jq ´.[] | (1 / .)?´
[1,0,-1]
=> 1, -1

Länge
Die eingebaute Funktion Länge Ruft die Länge verschiedener Arten von Werten ab:

· Die Länge von a Schnur ist die Anzahl der darin enthaltenen Unicode-Codepunkte (die
das gleiche wie seine JSON-codierte Länge in Bytes, wenn es sich um reines ASCII handelt).

· Die Länge von an Array ist die Anzahl der Elemente.

· Die Länge von an Objekt ist die Anzahl der Schlüssel-Wert-Paare.

· Die Länge von null ist null.

jq ´.[] | length´ [[1,2], "string", {"a":2}, null] => 2, 6, 1, 0

Tasten, Schlüssel_unsortiert
Die eingebaute Funktion Tasten, wenn ein Objekt übergeben wird, gibt seine Schlüssel in einem Array zurück.

Die Schlüssel sind "alphabetisch" nach Unicode-Codepoint-Reihenfolge sortiert. Dies ist keine Bestellung
das macht in jeder bestimmten Sprache einen besonderen Sinn, aber Sie können sich darauf verlassen, dass es die
gleich für zwei beliebige Objekte mit demselben Schlüsselsatz, unabhängig von den Gebietsschemaeinstellungen.

Wann Tasten erhält man ein Array, gibt es die gültigen Indizes für dieses Array zurück: die ganzen Zahlen
von 0 bis Länge-1.

Das Schlüssel_unsortiert Funktion ist genau wie Tasten, aber wenn die Eingabe ein Objekt ist, dann die Tasten
werden nicht sortiert, sondern die Schlüssel befinden sich ungefähr in der Einfügereihenfolge.

jq ´Tasten´
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Foo", "abc", "abcd"]

jq ´Tasten´
[42,3,35]
=> [0,1,2]

hat (Schlüssel)
Die eingebaute Funktion hat gibt zurück, ob das Eingabeobjekt den angegebenen Schlüssel oder die Eingabe hat
Array hat ein Element am angegebenen Index.

hat($schlüssel) hat den gleichen Effekt wie die Prüfung, ob $schlüssel ist ein Mitglied des zurückgegebenen Arrays
by TastenObwohl hat wird schneller sein.

jq ´map(has("foo"))´
[{"foo": 42}, {}]
=> [wahr, falsch]

jq ´map(hat(2))´
[[0,1], ["a","b","c"]]
=> [falsch, wahr]

in
Die eingebaute Funktion in gibt den Eingabeschlüssel im angegebenen Objekt oder den Eingabeindex zurück
entspricht einem Element im angegebenen Array. Es ist im Wesentlichen eine umgekehrte Version von
hat.

jq ´.[] | in({"foo": 42})´
["foo", "bar"]
=> wahr, falsch

jq ´map(in([0,1]))´
[2, 0]
=> [falsch, wahr]

Pfad(Pfad_Ausdruck)
Gibt Array-Darstellungen des angegebenen Pfadausdrucks in . aus .. Die Ausgänge sind Arrays von
strings (Schlüssel in object0 und/oder Zahlen (Array-Indizes.

Pfadausdrücke sind jq-Ausdrücke wie .a, aber auch .[]. Es gibt zwei Arten von Pfaden
Ausdrücke: solche, die genau übereinstimmen können, und solche, die nicht übereinstimmen können. Zum Beispiel, .ABC ist ein
exakter Match-Pfadausdruck, während .a[].b ist nicht.

Pfad(genauer_Pfad_Ausdruck) erzeugt die Array-Darstellung des Pfadausdrucks
auch wenn es nicht existiert in .Wenn . is null oder ein Array oder ein Objekt.

Pfad (Muster) erzeugt Array-Darstellungen der passenden Pfade Anleitungen wenn die
Pfade existieren in ..

Beachten Sie, dass sich die Pfadausdrücke nicht von normalen Ausdrücken unterscheiden. Der Ausdruck
path(..|select(type=="boolean")) gibt alle Pfade zu booleschen Werten in . aus ., und nur
diese Wege.

jq ´Pfad(.a[0].b)´
null
=> ["a",0,"b"]

jq ´[Pfad(..)]´
{"a":[{"b":1}]}
=> [[],["a"],["a",0],["a",0,"b"]]

del(Pfad_Ausdruck)
Die eingebaute Funktion Restaurants entfernt einen Schlüssel und seinen entsprechenden Wert aus einem Objekt.

jq ´del(.foo)´
{"foo": 42, "bar": 9001, "baz": 42}
=> {"bar": 9001, "baz": 42}

jq ´del(.[1, 2])´
["foo", "bar", "baz"]
=> ["foo"]

zu_Einträge, von_Einträgen, mit_Einträgen
Diese Funktionen konvertieren zwischen einem Objekt und einem Array von Schlüssel-Wert-Paaren. Wenn zu_Einträge
wird ein Objekt übergeben, dann für jedes k: v Eintrag in der Eingabe enthält das Ausgabe-Array
{"Schlüssel": k, "Wert": v}.

from_entries führt die umgekehrte Umwandlung durch, und mit_Einträgen (foo) ist eine Abkürzung für
zu_Einträge | Karte(foo) | from_entries, nützlich, um alle Tasten zu bedienen und
Werte eines Objekts. from_entries akzeptiert Schlüssel, Schlüssel, Name, Wert und Wert als Schlüssel.

jq ´zu_Einträgen´
{"a": 1, "b": 2}
=> [{"key":"a", "value":1}, {"key":"b", "value":2}]

jq ´von_Einträgen´
[{"key":"a", "value":1}, {"key":"b", "value":2}]
=> {"a": 1, "b": 2}

jq ´with_entries(.key |= "KEY_" + .)´
{"a": 1, "b": 2}
=> {"SCHLÜSSEL_a": 1, "SCHLÜSSEL_b": 2}

select(boolescher_Ausdruck)
Die Funktion auswählen(foo) erzeugt seine Eingabe unverändert, wenn foo gibt true für diese Eingabe zurück,
und erzeugt sonst keine Ausgabe.

Es ist nützlich, um Listen zu filtern: [1,2,3] | Karte(wählen(. >= 2)) werde dir geben [2,3].

jq ´map(select(. >= 2))´
[1,5,3,0,7]
=> [5,3,7]

jq ´.[] | select(.id == "zweite")´
[{"id": "erste", "val": 1}, {"id": "zweite", "val": 2}]
=> {"id": "zweite", "val": 2}

Arrays, Gegenstände, iterierbar, boolesche Werte, zahlen normal, endlich, Streicher, Nullen, Werte,
Skalare
Diese Built-Ins wählen nur Eingaben aus, die Arrays, Objekte, Iterables (Arrays oder
Objekte), Boolesche Werte, Zahlen, normale Zahlen, endliche Zahlen, Strings, null, nicht null
Werte bzw. nicht iterierbare Werte.

jq ´.[]|Zahlen´
[[],{},1,"foo",null,true,false]
=> 1

leer
leer gibt keine Ergebnisse zurück. Überhaupt keine. Nicht mal null.

Es ist gelegentlich nützlich. Du wirst wissen, ob du es brauchst :)

jq ´1, leer, 2´
null
=> 1, 2

jq ´[1,2,leer,3]´
null
=> [1,2,3]

Fehler(Botschaft)
Erzeugt einen Fehler, genau wie .a auf andere Werte als null und Objekte angewendet würde, aber
mit der angegebenen Meldung als Fehlerwert.

$__loc__
Erzeugt ein Objekt mit einem "Datei"-Schlüssel und einem "Zeilen"-Schlüssel, mit dem Dateinamen und der Zeilennummer
woher $__loc__ auftritt, als Werte.

jq ´try error("\($__loc__)") catch .´
null
=> "{\"Datei\":\" \",\"Linie 1}"

Karte(x), Kartenwerte(x)
Für jeden Filter x, Karte(x) führt diesen Filter für jedes Element des Eingabearrays aus, und
erzeugen die Ausgaben ein neues Array. Karte(.+1) wird jedes Element eines Arrays von inkrementieren
Zahlen.

Ebenso Kartenwerte(x) führt diesen Filter für jedes Element aus, gibt aber ein . zurück
Objekt, wenn ein Objekt übergeben wird.

Karte(x) entspricht [.[] | x]. Tatsächlich ist es so definiert. Ähnlich,
Kartenwerte(x) ist definiert als .[] |= x.

jq ´map(.+1)´
[1,2,3]
=> [2,3,4]

jq ´map_values(.+1)´
{"a": 1, "b": 2, "c": 3}
=> {"a": 2, "b": 3, "c": 4}

Wege, Pfade(node_filter), Blattpfade
Pfade gibt die Pfade zu allen Elementen in seiner Eingabe aus (außer es gibt die
leere Liste, die . selbst).

Pfade(f) gibt die Pfade zu beliebigen Werten aus, für die f ist wahr. Das ist, Pfade (Nummern)
gibt die Pfade zu allen numerischen Werten aus.

Blattpfade ist ein Alias ​​von Pfade (Skalare); Blattpfade is veraltet und wird entfernt in
die nächste große Veröffentlichung.

jq ´[Pfade]´
[1,[[],{"a":2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]

jq ´[Pfade(Skalare)]´
[1,[[],{"a":2}]]
=> [[0],[1,1,"a"]]

hinzufügen
Der Filter hinzufügen nimmt als Eingabe ein Array und erzeugt als Ausgabe die Elemente des Arrays
zusammen addiert. Dies kann summiert, verkettet oder zusammengeführt bedeuten, je nach Art der
die Elemente des Eingabearrays - die Regeln sind die gleichen wie für die + Operator
(oben beschrieben).

Wenn die Eingabe ein leeres Array ist, hinzufügen Rückgabe null.

jq ´hinzufügen´
["ABC"]
=> "abc"

jq ´hinzufügen´
[1, 2, 3]
=> 6

jq ´hinzufügen´
[]
=> null

irgendein, irgendeine(Bedingung), beliebig (Generator; Bedingung)
Der Filter jedem nimmt als Eingabe ein Array von booleschen Werten und erzeugt was immer dies auch sein sollte. als Ausgabe wenn
eines der Elemente des Arrays ist was immer dies auch sein sollte..

Wenn die Eingabe ein leeres Array ist, jedem Rückgabe falsch.

Das Beliebige(Bedingung) form wendet die angegebene Bedingung auf die Elemente des Eingabearrays an.

Das beliebig (Generator; Bedingung) form wendet die gegebene Bedingung auf alle Ausgaben der
Generator gegeben.

jq ´beliebig´
[wahr falsch]
=> wahr

jq ´beliebig´
[falsch, falsch]
=> falsch

jq ´beliebig´
[]
=> falsch

alle, alle(Bedingung), alle(Generator; Bedingung)
Der Filter alle nimmt als Eingabe ein Array von booleschen Werten und erzeugt was immer dies auch sein sollte. als Ausgabe wenn
alle Elemente des Arrays sind was immer dies auch sein sollte..

Das alle(Bedingung) form wendet die angegebene Bedingung auf die Elemente des Eingabearrays an.

Das alle(Generator; Bedingung) form wendet die gegebene Bedingung auf alle Ausgaben der
Generator gegeben.

Wenn die Eingabe ein leeres Array ist, alle Rückgabe was immer dies auch sein sollte..

jq ´alle´
[wahr falsch]
=> falsch

jq ´alle´
[Wahr, wahr]
=> wahr

jq ´alle´
[]
=> wahr

[Erfordert 1.5] ebnen, abflachen (Tiefe)
Der Filter ebnen nimmt als Eingabe ein Array von verschachtelten Arrays und erzeugt ein flaches Array in
wobei alle Arrays innerhalb des ursprünglichen Arrays rekursiv durch ihre Werte ersetzt wurden.
Sie können ihm ein Argument übergeben, um anzugeben, wie viele Verschachtelungsebenen abgeflacht werden sollen.

ebnen(2) ist wie ebnen, aber nur bis zu zwei Ebenen tief.

jq ´abflachen´
[1, [2], [[3]]]
=> [1, 2, 3]

jq´ebnen(1)´
[1, [2], [[3]]]
=> [1, 2, [3]]

jq ´abflachen´
[[]]
=> []

jq ´abflachen´
[{"foo": "bar"}, [{"foo": "baz"}]]
=> [{"foo": "bar"}, {"foo": "baz"}]

Reichweite (bis), Bereich (von;bis) Bereich(von;bis;von)
Das Angebot Funktion erzeugt einen Zahlenbereich. Bereich(4;10) erzeugt 6 Zahlen, ab 4
(inklusive) bis 10 (exklusive). Die Zahlen werden als separate Ausgaben erzeugt. Verwenden
[Bereich(4;10)] um einen Bereich als Array zu erhalten.

Die Ein-Argument-Form generiert Zahlen von 0 bis zur angegebenen Zahl mit einer Schrittweite von
1.

Die Zwei-Argument-Form erzeugt Zahlen aus für zu bis mit einer Erhöhung von 1.

Die Drei-Argument-Form erzeugt Zahlen für zu bis mit einem Inkrement von by.

jq ´Bereich(2;4)´
null
=> 2, 3

jq ´[Bereich(2;4)]´
null
=> [2,3]

jq ´[Angebot(4)]´
null
=> [0,1,2,3]

jq ´[Bereich(0;10;3)]´
null
=> [0,3,6,9]

jq ´[Bereich(0;10;-1)]´
null
=> []

jq ´[Bereich(0;-5;-1)]´
null
=> [0,-1,-2,-3,-4]

Boden
Das Boden Die Funktion gibt den Boden ihrer numerischen Eingabe zurück.

jq ´Etage´
3.14159
=> 3

sqrt
Das sqrt Funktion gibt die Quadratwurzel ihrer numerischen Eingabe zurück.

jq ´Quadrat´
9
=> 3

Tonnummer
Das Tonnummer Funktion parst ihre Eingabe als Zahl. Es wird korrekt formatiert konvertiert
Zeichenketten zu ihrem numerischen Äquivalent, lassen Sie Zahlen in Ruhe und geben Sie bei allen anderen einen Fehler aus
Eingang.

jq ´.[] | Tonnummer´
[1, "1"]
=> 1, 1

tostring
Das tostring Funktion gibt ihre Eingabe als String aus. Strings bleiben unverändert, und alle
andere Werte sind JSON-codiert.

jq ´.[] | tostring´
[1, "1", [1]]
=> "1", "1", "[1]"

tippe
Das tippe Die Funktion gibt den Typ ihres Arguments als String zurück, der null,
boolean, Zahl, Zeichenfolge, Array oder Objekt.

jq ´map(Typ)´
[0, false, [], {}, null, "hallo"]
=> ["number", "boolean", "array", "object", "null", "string"]

unendlich, Nee, ist unendlich, isnan, ist endlich, ist normal
Einige arithmetische Operationen können Unendlichkeiten und "keine Zahl"-Werte (NaN) ergeben. Die
ist unendlich eingebaute Renditen was immer dies auch sein sollte. wenn seine Eingabe unendlich ist. Die isnan eingebaute Renditen was immer dies auch sein sollte.
wenn seine Eingabe ein NaN ist. Die unendlich builtin gibt einen positiven unendlichen Wert zurück. Die nan
builtin gibt ein NaN zurück. Die ist normal builtin gibt true zurück, wenn seine Eingabe eine normale Zahl ist.

Beachten Sie, dass eine Division durch Null einen Fehler auslöst.

Derzeit tun die meisten arithmetischen Operationen, die auf Unendlichkeiten, NaNs und Subnormalen operieren, nicht
Fehler aufwerfen.

jq ´.[] | (unendlich * .) < 0´
[-elf]
=> wahr, falsch

jq ´unendlich, nan | Typ
null
=> "Zahl", "Zahl"

Sortieren, sort_by(Pfadausdruck)
Das sortieren Funktionen sortiert seine Eingabe, die ein Array sein muss. Die Werte sind in der sortiert
folgende Reihenfolge:

· null

· falsch

· was immer dies auch sein sollte.

· Zahlen

· Strings in alphabetischer Reihenfolge (nach Unicode-Codepoint-Wert)

· Arrays, in lexikalischer Reihenfolge

· Objekte

Die Anordnung von Objekten ist etwas komplex: Zuerst werden sie verglichen, indem man ihre
Sätze von Schlüsseln (als Arrays in sortierter Reihenfolge) und wenn ihre Schlüssel gleich sind, dann sind die Werte
Schlüssel für Schlüssel verglichen.

sortieren kann verwendet werden, um nach einem bestimmten Feld eines Objekts zu sortieren oder einen beliebigen jq-Filter anzuwenden.

sort_by(foo) vergleicht zwei Elemente durch Vergleich des Ergebnisses von foo auf jedem Element.

jq ´sortieren´
[8,3,null,6]
=> [null,3,6,8]

jq ´sort_by(.foo)´
[{"foo":4, "bar":10}, {"foo":3, "bar":100}, {"foo":2, "bar":1}]
=> [{"foo":2, "bar":1}, {"foo":3, "bar":100}, {"foo":4, "bar":10}]

group_by(Pfadausdruck)
group_by(.foo) nimmt als Eingabe ein Array, gruppiert die Elemente mit dem gleichen .foo Feld
in separate Arrays und erzeugt alle diese Arrays als Elemente eines größeren Arrays,
sortiert nach dem Wert der .foo Feld.

Anstelle von kann jeder jq-Ausdruck verwendet werden, nicht nur ein Feldzugriff .foo. Die Sortierung
Die Reihenfolge ist die gleiche wie im beschrieben sortieren Funktion oben.

jq ´group_by(.foo)´
[{"foo":1, "bar":10}, {"foo":3, "bar":100}, {"foo":1, "bar":1}]
=> [[{"foo":1, "bar":10}, {"foo":1, "bar":1}], [{"foo":3, "bar":100}]]

min max min_by(path_exp), max_by(Pfad_Ausdruck)
Suchen Sie das minimale oder maximale Element des Eingabearrays.

Das min_by(Pfad_Ausdruck) und max_by(Pfad_Ausdruck) Funktionen ermöglichen es Ihnen, einen bestimmten
Feld oder Eigenschaft zu untersuchen, zB min_by(.foo) findet das Objekt mit dem kleinsten foo
Feld.

jq ´min´
[5,4,2,7]
=> 2

jq ´max_by(.foo)´
[{"foo":1, "bar":14}, {"foo":2, "bar":3}]
=> {"foo":2, "bar":3}

einzigartig, unique_by(path_exp)
Das einzigartiges Funktion nimmt als Eingabe ein Array und erzeugt ein Array mit den gleichen Elementen, in
sortierte Reihenfolge, mit entfernten Duplikaten.

Das unique_by(path_exp) Funktion behält nur ein Element für jeden Wert, der durch erhalten wird
das Argument anwenden. Stellen Sie sich das so vor, als würden Sie ein Array erstellen, indem Sie aus jedem ein Element nehmen
Gruppe produziert von Gruppe.

jq ´einzigartig´
[1,2,5,3,5,3,1,3]
=> [1,2,3,5]

jq ´unique_by(.foo)´
[{"foo": 1, "bar": 2}, {"foo": 1, "bar": 3}, {"foo": 4, "bar": 5}]
=> [{"foo": 1, "bar": 2}, {"foo": 4, "bar": 5}]

jq ´einzigartig_durch(Länge)´
["grob", "Speck", "Kätzchen", "Zikade", "Spargel"]
=> ["Speck", "chunky", "Spargel"]

rückgängig machen
Diese Funktion kehrt ein Array um.

jq ´umgekehrt´
[1,2,3,4]
=> [4,3,2,1]

enthält (Element)
Der Filter enthält(b) ergibt true, wenn b vollständig in der Eingabe enthalten ist. EIN
String B ist in einem String A enthalten, wenn B ein Teilstring von A ist. Ein Array B ist enthalten in
ein Array A, wenn alle Elemente von B in einem beliebigen Element von A enthalten sind. Ein Objekt B ist
in Objekt A enthalten, wenn alle Werte in B im Wert in A enthalten sind mit dem
gleicher Schlüssel. Alle anderen Typen werden als ineinander enthalten angenommen, wenn sie gleich sind.

jq ´enthält("Balken")´
"foobar"
=> wahr

jq ´enthält(["baz", "bar"])´
["foobar", "foobaz", "blarp"]
=> wahr

jq ´enthält(["bazzzzz", "bar"])´
["foobar", "foobaz", "blarp"]
=> falsch

jq ´enthält({foo: 12, bar: [{barp: 12}]})´
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> wahr

jq ´enthält({foo: 12, bar: [{barp: 15}]})´
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> falsch

Indizes
Gibt ein Array aus, das die Indizes in . enthält . woher s tritt ein. Die Eingabe kann ein Array sein, in
welcher Fall wenn s ist ein Array, dann werden die Indizes ausgegeben, in denen alle Elemente in .
entsprechen denen von s.

jq ´indizes(", ")´
"a, b, cd, efg, hijk"
=> [3,7,12]

jq´Indizes(1)´
[0,1,2,1,3,1,4]
=> [1,3,5]

jq ´Indizes([1,2])´
[0,1,2,3,1,4,2,5,1,2,6,7]
=> [1,8]

Index(e), Index(e)
Gibt den Index des ersten (Index) oder zuletzt (rindex) das Auftreten von s im Eingang.

jq ´index(", ")´
"a, b, cd, efg, hijk"
=> 3

jq ´rindex(", ")´
"a, b, cd, efg, hijk"
=> 12

innerhalb
Der Filter innen(b) ergibt true, wenn die Eingabe vollständig in b enthalten ist. Es
ist im Wesentlichen eine umgekehrte Version von enthält.

jq ´inside("foobar")´
"Bar"
=> wahr

jq ´inside(["foobar", "foobaz", "blarp"])´
["baz", "bar"]
=> wahr

jq ´inside(["foobar", "foobaz", "blarp"])´
["bazzzzz", "bar"]
=> falsch

jq ´inside({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"foo": 12, "bar": [{"barp": 12}]}
=> wahr

jq ´inside({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"foo": 12, "bar": [{"barp": 15}]}
=> falsch

beginntmit(str)
Ausgänge was immer dies auch sein sollte. wenn . beginnt mit dem angegebenen String-Argument.

jq ´[.[]|startswith("foo")]´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [falsch, wahr, falsch, wahr, falsch]

endet mit (str)
Ausgänge was immer dies auch sein sollte. wenn . endet mit dem angegebenen String-Argument.

jq ´[.[]|endswith("foo")]´
["foobar", "barfoo"]
=> [falsch, wahr]

Kombinationen, Kombinationen(n)
Gibt alle Kombinationen der Elemente der Arrays im Eingabearray aus. Wenn ein gegeben wird
Argument n, es gibt alle Kombinationen von aus n Wiederholungen des Eingabearrays.

jq ´Kombinationen´
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]

jq´Kombinationen(2)´
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]

ltrimstr(str)
Gibt seine Eingabe mit entferntem Präfix-String aus, wenn es damit beginnt.

jq ´[.[]|ltrimstr("foo")]´
["fo", "foo", "barfoo", "foobar", "afoo"]
=> ["fo","","barfoo","bar","afoo"]

rtrimstr(str)
Gibt seine Eingabe mit entferntem Suffix-String aus, wenn es damit endet.

jq ´[.[]|rtrimstr("foo")]´
["fo", "foo", "barfoo", "foobar", "foob"]
=> ["fo","","bar","foobar","foob"]

explodieren
Wandelt einen Eingabestring in ein Array der Codepunktnummern des Strings um.

jq ´explodieren´
"foobar"
=> [102,111,111,98,97,114]

implodieren
Die Umkehrung von explodieren.

jq ´implodieren´
[65, 66, 67]
=> "ABC"

gespalten
Teilt eine Eingabezeichenfolge nach dem Trennzeichenargument.

jq ´split(", ")´
"a, b, c, d, e, "
=> ["a","b,c,d","e",""]

beitreten(str)
Verbindet das als Eingabe angegebene Array von Elementen, wobei das Argument als Trennzeichen verwendet wird. Es ist der
invers von gespalten: das heißt, laufen split("foo") | beitreten("foo") über einen beliebigen Eingabestring
gibt die Eingabezeichenfolge zurück.

jq ´join(", ")´
["a","b,c,d","e"]
=> "a, b, c, d, e"

ascii_downcase, ascii_upcase
Geben Sie eine Kopie der Eingabezeichenfolge mit ihren alphabetischen Zeichen (az und AZ) konvertiert in aus
der angegebene Fall.

während(Bedingung; aktualisieren)
Das während(Bedingung; aktualisieren) Funktion ermöglicht es Ihnen, wiederholt ein Update auf . bis cond
ist falsch.

Beachten Sie, dass während(Bedingung; aktualisieren) ist intern als rekursive jq-Funktion definiert. Rekursiv
Anrufe innerhalb während verbraucht keinen zusätzlichen Speicher, wenn Aktualisierung produziert höchstens einen
Ausgabe für jeden Eingang. Siehe weiterführende Themen unten.

jq ´[während(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

bis(Bedingung; nächste)
Das bis(Bedingung; nächste) Mit der Funktion können Sie den Ausdruck wiederholt anwenden weiter,
zunächst zu . dann zu seinem eigenen Ausgang, bis cond ist wahr. Dies kann zum Beispiel verwendet werden
um eine Fakultätsfunktion zu implementieren (siehe unten).

Beachten Sie, dass bis(Bedingung; nächste) ist intern als rekursive jq-Funktion definiert. Rekursiv
Anrufe innerhalb bis um() verbraucht keinen zusätzlichen Speicher, wenn weiter produziert höchstens einen
Ausgabe für jeden Eingang. Siehe weiterführende Themen unten.

jq ´[.,1]|bis(.[0] < 1; [.[0] - 1, .[1] * .[0]])|.[1]´
4
=> 24

rekursieren (f), wiederkehren, rekurs (f; Zustand), recurse_down
Das rekurs (w) Funktion ermöglicht es Ihnen, eine rekursive Struktur zu durchsuchen und zu extrahieren
interessante Daten aus allen Ebenen. Angenommen, Ihre Eingabe repräsentiert ein Dateisystem:

{"Name": "/", "Kinder": [
{"Name": "/Behälter", "Kinder": [
{"Name": "/bin/ls", "Kinder": []},
{"Name": "/ Bin / sh", "Kinder": []}]},
{"Name": "/ Home", "Kinder": [
{"name": "/home/stephen", "kinder": [
{"name": "/home/stephen/jq", "kinder": []}]}]}]}

Angenommen, Sie möchten alle vorhandenen Dateinamen extrahieren. Sie müssen zurückholen . Name,
.kinder[].name, .kinder[].kinder[].name, und so weiter. Sie können dies tun mit:

rekurs(.kinder[]) | .Name

Wenn ohne Argument aufgerufen wird, rekursiv entspricht rekurs (.[]?).

rekurs (w) ist identisch mit rekurs (f; . != Null) und kann ohne Bedenken verwendet werden
Rekursionstiefe.

rekurs (f; Bedingung) ist ein Generator, der mit dem Aussenden beginnt. und strahlt dann der Reihe nach aus
.|f, .|f|f, .|f|f|f, ... solange der berechnete Wert die Bedingung erfüllt. Zum
Um beispielsweise alle ganzen Zahlen zu generieren, könnte man zumindest im Prinzip schreiben rekurs (.+1;
wahr).

Aus Altlastengründen recurse_down existiert als Alias ​​für den Aufruf rekursiv ohne Argumente.
Dieser Alias ​​wird berücksichtigt veraltet und wird in der nächsten Hauptversion entfernt.

Die rekursiven Aufrufe in rekursiv verbraucht keinen zusätzlichen Speicher, wenn f produziert bei
meistens ein einzelner Ausgang für jeden Eingang.

jq ´recurse(.foo[])´
{"foo":[{"foo": []}, {"foo":[{"foo":[]}]}]}
=> {"foo":[{"foo":[]},{"foo":[{"foo":[]}]}]}, {"foo":[]}, {"foo": [{"foo":[]}]}, {"foo":[]}

jq ´rekurs´
{"a":0,"b":[1]}
=> {"a":0,"b":[1]}, 0, [1], 1

jq ´rekurs(. * .; . < 20)´
2
=> 2, 4, 16

..
Abkürzung für rekursiv ohne Argumente. Dies soll dem XPath ähneln //
Operator. Beachten Sie, dass ..ein funktioniert nicht; verwenden ..|a stattdessen. Im folgenden Beispiel verwenden wir
..|.a? um alle Werte der Objektschlüssel "a" in einem beliebigen "unten" gefundenen Objekt zu finden ..

jq ´..|.a?´
[[{"a":1}]]
=> 1

env
Gibt ein Objekt aus, das die Umgebung von jq repräsentiert.

jq ´env.PAGER´
null
=> "weniger"

transponieren
Transponieren Sie eine möglicherweise gezackte Matrix (ein Array von Arrays). Zeilen werden mit Nullen aufgefüllt, damit die
Ergebnis ist immer rechteckig.

jq ´transponieren´
[[1], [2,3]]
=> [[1,2],[null,3]]

bsuchen(x)
bsearch(x) führt eine binäre Suche nach x im Eingabearray durch. Wenn die Eingabe sortiert ist und
enthält x, dann gibt bsearch(x) seinen Index im Array zurück; andernfalls, wenn das Array . ist
sortiert, gibt es (-1 - ix) zurück, wobei ix ein Einfügepunkt ist, so dass das Array
nach dem Einfügen von x bei ix noch sortiert werden. Wenn das Array nicht sortiert ist, wird bsearch(x)
gibt eine ganze Zahl zurück, die wahrscheinlich nicht von Interesse ist.

jq´bsuchen(0)´
[0,1]
=> 0

jq´bsuchen(0)´
[1,2,3]
=> -1

jq´bsuchen(4) als $ix | wenn $ix < 0 dann .[-(1+$ix)] = 4 sonst . Ende
[1,2,3]
=> [1,2,3,4]

Schnur Interpolation - \(foo)
Innerhalb eines Strings können Sie nach einem Backslash einen Ausdruck in Klammern setzen. Was auch immer der
Ausdrucksrückgaben werden in den String interpoliert.

jq ´"Die Eingabe war \(.), also eins weniger als \(.+1)"´
42
=> "Die Eingabe war 42, also eins weniger als 43"

Konvertieren zu / von JSON
Das tojson und vonjson Builtins geben Werte als JSON-Texte aus oder parsen JSON-Texte in
Werte bzw. Das eingebaute tojson unterscheidet sich von tostring darin, dass tostring zurückgibt
Zeichenfolgen unverändert, während tojson Zeichenfolgen als JSON-Zeichenfolgen codiert.

jq ´[.[]|tostring]´
[1, "foo", ["foo"]]
=> ["1","foo","[\"foo\"]"]

jq ´[.[]|tojson]´
[1, "foo", ["foo"]]
=> ["1","\"foo\"","[\"foo\"]"]

jq ´[.[]|tojson|fromjson]´
[1, "foo", ["foo"]]
=> [1,"foo",["foo"]]

Format Streicher und Flucht
Das @fo Syntax wird zum Formatieren und Escape-Strings verwendet, was zum Erstellen von URLs nützlich ist.
Dokumente in einer Sprache wie HTML oder XML usw. @fo kann als Filter verwendet werden auf
seine eigenen, die möglichen Fluchtwege sind:

@Text:

Aufrufe tostring, siehe diese Funktion für Details.

@json:

Serialisiert die Eingabe als JSON.

@html:

Wendet HTML/XML-Escape an, indem die Zeichen zugeordnet werden <>&´" zu ihrer Entität
Äquivalente <, >, machen auf, ", ".

@uri:

Wendet Prozentcodierung an, indem alle reservierten URI-Zeichen a % XX Sequenz.

@csv:

Die Eingabe muss ein Array sein und wird als CSV mit doppelten Anführungszeichen für . gerendert
Zeichenfolgen und Anführungszeichen, die durch Wiederholung maskiert werden.

@tsv:

Die Eingabe muss ein Array sein und wird als TSV (durch Tabulator getrennte Werte) gerendert. Jeder
Eingabe-Array wird als einzelne Zeile gedruckt. Felder sind durch einen einzelnen Tab getrennt
(ASCII 0x09). Eingabezeichen Zeilenvorschub (ascii 0x0a), Wagenrücklauf (ascii
0x0d), Registerkarte (ascii 0x09) und Backslash (ascii 0x5c) wird als Escape ausgegeben
Sequenzen \n, \r, \t, \\ beziehungsweise.

@Sch:

Die Eingabe wird mit Escapezeichen versehen, die für die Verwendung in einer Befehlszeile für eine POSIX-Shell geeignet ist. Wenn die
input ist ein Array, die Ausgabe besteht aus einer Reihe von durch Leerzeichen getrennten Strings.

@base64:

Die Eingabe wird gemäß RFC 64 in base4648 konvertiert.

Diese Syntax lässt sich sinnvoll mit String-Interpolation kombinieren. Sie können a . folgen
@fo Token mit einem String-Literal. Der Inhalt des String-Literals wird nicht entkommen sein.
Alle Interpolationen, die innerhalb dieses Zeichenfolgenliterals vorgenommen werden, werden jedoch mit Escapezeichen versehen. Zum Beispiel,

@uri "https://www.google.com/search?q=\(.search)"

erzeugt die folgende Ausgabe für die Eingabe {"search":"was is jq?"}:

"https://www.google.com/search?q=what%20is%20jq%3F"

Beachten Sie, dass die Schrägstriche, Fragezeichen usw. in der URL nicht mit Escapezeichen versehen sind, da sie Bestandteil waren
des String-Literals.

jq ´@html´
"Das funktioniert, wenn x < y"
=> "Das funktioniert, wenn x < y"

jq ´@sh "echo \(.)"´
"O´Hara´s Ale"
=> "echo ´O´\\´´Hara´\\´´s Ale´"

Datum
jq bietet einige grundlegende Funktionen zur Datumsbehandlung, mit einigen High-Level und Low-Level
eingebaut. In allen Fällen befassen sich diese Builtins ausschließlich mit der Zeit in UTC.

Das fromdateiso8601 Builtin analysiert Datumsangaben im ISO 8601-Format auf eine Anzahl von Sekunden
seit der Unix-Epoche (1970-01-01T00:00:00Z). Die todateiso8601 Builtin macht das Gegenteil.

Das ab Datum Builtin analysiert Datetime-Strings. Zur Zeit ab Datum unterstützt nur ISO 8601
Datetime-Strings, aber in Zukunft wird es versuchen, Datetime-Strings in mehr zu analysieren
Formate.

Das miteinander ausgehen builtin ist ein Alias ​​für todateiso8601.

Das jetzt an builtin gibt die aktuelle Zeit in Sekunden seit der Unix-Epoche aus.

Es werden auch Low-Level-jq-Schnittstellen zu den Zeitfunktionen der C-Bibliothek bereitgestellt: strptime,
strftime, Zeit und gmtime. Weitere Informationen finden Sie in der Dokumentation Ihres Host-Betriebssystems
Format-Strings, die von verwendet werden strptime und strftime. Hinweis: diese sind nicht unbedingt stabil
Schnittstellen in jq, insbesondere hinsichtlich ihrer Lokalisierungsfunktionalität.

Das gmtime builtin verbraucht seit der Unix-Epoche einige Sekunden und gibt ein "gebrochenes" aus
Ausfallzeit" Darstellung der Zeit als Array von Zahlen, die (in dieser Reihenfolge) darstellen: die
Jahr, der Monat (nullbasiert), der Tag des Monats, die Stunde des Tages, die Minute des
Stunde, die Sekunde der Minute, der Wochentag und der Tag des Jahres – alle
einseitig, sofern nicht anders angegeben.

Das Zeit Builtin verbraucht "gebrochene Zeit"-Darstellungen der Zeitausgabe von gmtime
und strptime.

Das strptime(fmt) Builtin analysiert Eingabestrings, die mit dem übereinstimmen fmt Streit. Die Ausgabe ist in
die Darstellung der "gebrochenen Zeit" verbraucht von gmtime und Ausgabe von Zeit.

Das strftime(fmt) Builtin formatiert eine Zeit mit dem angegebenen Format.

Die Formatzeichenfolgen für strptime und strftime sind in einer typischen C-Bibliothek beschrieben
Dokumentation. Die Formatzeichenfolge für ISO 8601 datetime ist "%Y-%m-%dT%H:%M:%SZ".

jq unterstützt möglicherweise einige oder alle dieser Datumsfunktionen auf einigen Systemen nicht.

jq ´ab Datum´
"2015-03-05T23:51:47Z"
=> 1425599507

jq ´strptime("%Y-%m-%dT%H:%M:%SZ")´
"2015-03-05T23:51:47Z"
=> [2015,2,5,23,51,47,4,63]

jq ´strptime("%Y-%m-%dT%H:%M:%SZ")|mktime´
"2015-03-05T23:51:47Z"
=> 1425599507

BEDINGUNGEN UND VERGLEICH

==, !=
Der Ausdruck ´a == b´ ergibt ´wahr´, wenn das Ergebnis von a und b gleich ist (d.h.
wenn sie äquivalente JSON-Dokumente darstellen) und andernfalls ´false´. Insbesondere Saiten
werden niemals mit Zahlen gleichgesetzt. Wenn Sie von Javascript kommen, ist jq´s == wie
Javascript´s === - Werte nur dann gleich, wenn sie den gleichen Typ haben sowie
der gleiche Wert.

!= ist "ungleich", und ´a != b´ gibt den entgegengesetzten Wert von ´a == b´ . zurück

jq ´.[] == 1´
[1, 1.0, "1", "Banane"]
=> wahr, wahr, falsch, falsch

wenn-dann-sonst
if A dann B sonst C Ende wird genauso handeln wie B if A erzeugt einen anderen Wert als false oder
null, aber verhalten Sie sich genauso wie C Andernfalls.

Die Prüfung auf false oder null ist ein einfacherer Begriff von "Wahrheit" als in Javascript
oder Python, aber das bedeutet, dass Sie die Bedingung manchmal expliziter angeben müssen
Sie wollen: Sie können nicht testen, ob zB ein String leer ist mit if . Name dann A sonst B Ende,
du brauchst etwas mehr wie if (.Name | Länge) > 0 dann A sonst B Ende stattdessen.

Wenn die Bedingung A mehrere Ergebnisse liefert, wird sie als "wahr" angesehen, wenn eines dieser Ergebnisse
Ergebnisse ist nicht falsch oder null. Wenn es keine Ergebnisse liefert, gilt es als falsch.

Weitere Fälle können einer bei Verwendung hinzugefügt werden elif A dann B Syntax.

jq ´wenn . == 0 dann

"null" elif. == 1 dann "eins" sonst "viele" end´ 2 => "viele"

>, >=, <=, <
Die Vergleichsoperatoren >, >=, <=, < zurück, ob ihr linkes Argument größer ist als,
größer oder gleich, kleiner oder gleich oder kleiner als ihr richtiges Argument
(beziehungsweise).

Die Bestellung ist die gleiche wie beschrieben für sortieren, über.

jq´. < 5´
2
=> wahr

und/oder/nicht
jq unterstützt die normalen Booleschen Operatoren und/oder/nicht. Sie haben den gleichen Wahrheitsstandard
als ob Ausdrücke - false und null als "falsche Werte" betrachtet werden und alles andere a
"wahrer Wert".

Wenn ein Operand eines dieser Operatoren mehrere Ergebnisse liefert, wird der Operator selbst
erzeugt für jede Eingabe ein Ergebnis.

nicht ist in der Tat eher eine eingebaute Funktion als ein Operator, daher wird sie als Filter aufgerufen, um
welche Dinge statt mit spezieller Syntax wie in geleitet werden können .foo und .bar | nicht.

Diese drei produzieren nur die Werte "true" und "false" und sind daher nur für echtes nützlich
Boolesche Operationen anstelle des üblichen Perl/Python/Ruby-Idioms von
"value_that_may_be_null oder default". Wenn Sie diese Form von "oder" verwenden möchten, wählen Sie zwischen
zwei Werte, anstatt eine Bedingung auszuwerten, siehe den "//"-Operator unten.

jq ´42 und "ein String"´
null
=> wahr

jq ´(wahr, falsch) oder falsch´
null
=> wahr, falsch

jq ´(wahr, wahr) und (wahr, falsch)´
null
=> wahr, falsch, wahr, falsch

jq ´[wahr, falsch | nicht
null
=> [falsch, wahr]

Alternative Operator - //
Ein Filter der Form a // b liefert die gleichen Ergebnisse wie aWenn a produziert Ergebnisse andere
als falsch und null. Andernfalls, a // b liefert die gleichen Ergebnisse wie b.

Dies ist nützlich, um Standardwerte bereitzustellen: .foo // 1 wird auswerten zu 1 wenn es keine gibt .foo
Element in der Eingabe. Es ist ähnlich wie or wird manchmal in Python verwendet (jq´s or Operator
ist für rein boolesche Operationen reserviert).

jq ´.foo // 42´
{"foo": 19}
=> 19

jq ´.foo // 42´
{}
=> 42

versuchen zu fangen
Fehler können abgefangen werden mit versuchen EXP Fang EXP. Der erste Ausdruck wird ausgeführt, und wenn
es schlägt fehl, dann wird die zweite mit der Fehlermeldung ausgeführt. Die Ausgabe des Handlers, wenn
any, wird so ausgegeben, als ob es die Ausgabe des zu versuchenden Ausdrucks gewesen wäre.

Das versuchen EXP Formular verwendet leer als Ausnahmehandler.

jq ´try .a catch ". is not an object"´
was immer dies auch sein sollte.
=> ". ist kein Objekt"

jq ´[.[]|versuchen .a]´
[{}, wahr, {"a":1}]
=> [null, 1]

jq ´try error("irgendeine Ausnahme") catch .´
was immer dies auch sein sollte.
=> "eine Ausnahme"

Bruch of Smartgeräte App Strukturen
Eine praktische Anwendung von Try/Catch ist das Durchbrechen von Kontrollstrukturen wie Veteran, foreach,
während, Und so weiter.

Beispielsweise:

# Wiederholen Sie einen Ausdruck, bis er "break" als an auslöst
# Fehler, dann hör auf zu wiederholen, ohne den Fehler erneut auszulösen.
# Aber wenn der abgefangene Fehler nicht "break" ist, dann re-raise ihn.
try repeat(exp) catch .=="break" then empty else error;

jq hat eine Syntax für benannte lexikalische Labels zu "break" oder "go (back) to":

Etikett $out | ... ausbrechen ...

Das brechen $label_name Ausdruck bewirkt, dass sich das Programm so verhält, als ob der nächste
(Nach links) Etikette $label_name hergestellt leer.

Die Beziehung zwischen dem brechen und entsprechend Etikette ist lexikalisch: das Etikett muss sein
"sichtbar" aus der Pause.

Aus einem ausbrechen Veteran, Zum Beispiel:

Etikett $out | reduziere .[] als $item (null; if .==false, dann breche $out else ... end)

Das folgende jq-Programm erzeugt einen Syntaxfehler:

ausbrechen

weil kein etikett $aus ist sichtbar.

? Operator
Das ? Operator, verwendet als EXP?, ist die Abkürzung für versuchen EXP.

jq ´[.[]|(.a)?]´
[{}, wahr, {"a":1}]
=> [null, 1]

REGULAR AUSDRÜCKE (PCRE)

jq verwendet die Oniguruma-Bibliothek für reguläre Ausdrücke, ebenso wie php, ruby, TextMate, Sublime Text,
usw., daher konzentriert sich die Beschreibung hier auf die Besonderheiten von jq.

Die jq-Regex-Filter sind so definiert, dass sie mit einem dieser Muster verwendet werden können:

STRING | FILTER ( REGEX )
STRING | FILTER( REGEX; FLAGGEN )
STRING | FILTER([REGEX])
STRING | FILTER( [REGEX, FLAGS])

wobei: * STRING, REGEX und FLAGS sind jq-Strings und unterliegen der jq-String-Interpolation; *
REGEX sollte nach der Zeichenfolgeninterpolation ein gültiger PCRE-Regex sein; * FILTER ist einer von Test,
Spiel, oder Erfassung, wie unten beschrieben.

FLAGS ist eine Zeichenfolge, die aus einem oder mehreren der unterstützten Flags besteht:

· g - Globale Suche (alle Treffer finden, nicht nur die ersten)

· i - Suche ohne Berücksichtigung der Groß-/Kleinschreibung

· m - Multi-Line-Modus (´.´ wird mit Zeilenumbrüchen übereinstimmen)

· n - Leere Übereinstimmungen ignorieren

· p - Sowohl der s- als auch der m-Modus sind aktiviert

· s - Einzeiliger Modus (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - Finden Sie längstmögliche Übereinstimmungen

· x - Erweitertes Regex-Format (Leerzeichen und Kommentare ignorieren)

Um Leerzeichen in einem x-Muster abzugleichen, verwenden Sie ein Escape wie \s, zB

· test( "a\sb", "x" ).

Beachten Sie, dass bestimmte Flags auch innerhalb von REGEX angegeben werden können, z

· jq -n ´("test", "TEST", "teST", "TEST") | test( "(?i)te(?-i)st" )´

ergibt: wahr, wahr, falsch, falsch.

[Erfordert 1.5] test(wert), test(regex; Flaggen)
Like Spiel, gibt aber nur keine Übereinstimmungsobjekte zurück was immer dies auch sein sollte. or falsch für ob oder nicht
regex stimmt mit der Eingabe überein.

jq ´test("foo")´
"foo"
=> wahr

jq ´.[] | test("abc # Leerzeichen werden ignoriert"; "ix")´
["xabcd", "ABC"]
=> wahr, wahr

[Erfordert 1.5] übereinstimmen (val), übereinstimmen(regex; Flaggen)
Spiel gibt für jede gefundene Übereinstimmung ein Objekt aus. Übereinstimmungen haben die folgenden Felder:

· Offset - Offset in UTF-8 Codepoints vom Anfang der Eingabe

· Länge - Länge in UTF-8 Codepoints des Matches

· Schnur - die Zeichenfolge, mit der es übereinstimmt

· Captures - ein Array von Objekten, die einfangende Gruppen darstellen.

Erfassende Gruppenobjekte haben die folgenden Felder:

· Offset - Offset in UTF-8 Codepoints vom Anfang der Eingabe

· Länge - Länge in UTF-8 Codepoints dieser Erfassungsgruppe

· Schnur - die Saite, die gefangen wurde

· Name - der Name der einfangenden Gruppe (oder null wenn es unbenannt war)

Erfassungsgruppen, die mit nichts übereinstimmen, geben einen Offset von -1 . zurück

jq ´match("(abc)+"; "g")´
"abc abc"
=> {"offset": 0, "length": 3, "string": "abc", "captures": [{"offset": 0, "length": 3, "string": "abc", " name": null}]}, {"offset": 4, "length": 3, "string": "abc", "captures": [{"offset": 4, "length": 3, "string" : "abc", "name": null}]}

jq ´match("foo")´
"foo bar foo"
=> {"offset": 0, "length": 3, "string": "foo", "captures": []}

jq ´match(["foo", "ig"])´
"foo bar FOO"
=> {"offset": 0, "length": 3, "string": "foo", "captures": []}, {"offset": 8, "length": 3, "string": "FOO ", "erfasst": []}

jq ´match("foo (? Bar)? foo"; "ig")´
"foo bar foo foo foo"
=> {"offset": 0, "length": 11, "string": "foo bar foo", "captures": [{"offset": 4, "length": 3, "string": "bar" , "name": "bar123"}]}, {"offset": 12, "length": 8, "string": "foo foo", "captures": [{"offset": -1, "length" : 0, "string": null, "name": "bar123"}]}

jq ´[ match("."; "g")] | Länge
"ABC"
=> 3

[Erfordert 1.5] erfassen (val), erfassen (regex; Flaggen)
Sammelt die benannten Captures in einem JSON-Objekt mit dem Namen jedes Captures als Schlüssel.
und die übereinstimmende Zeichenfolge als entsprechenden Wert.

jq ´capture("(? [az]+)-(? [0-9]+)")´
"xyzzy-14"
=> { "a": "xyzzy", "n": "14" }

[Erfordert 1.5] scannen (regex), scannen (regex; Flaggen)
Einen Stream der nicht überlappenden Teilstrings der Eingabe ausgeben, die mit der Regex in übereinstimmen
entsprechend den Flags, falls vorhanden. Wenn es keine Übereinstimmung gibt, ist der Stream
leer. Um alle Übereinstimmungen für jede Eingabezeichenfolge zu erfassen, verwenden Sie das Idiom [ ausdr ], z.B [
scannen (regex) ].

split(regex; Flaggen)
Aus Gründen der Abwärtskompatibilität gespalten teilt sich auf eine Zeichenfolge auf, nicht auf eine Regex.

[Erfordert 1.5] spaltet (regex), spaltet (regex; Flaggen)
Diese liefern die gleichen Ergebnisse wie ihre gespalten Gegenstücke, aber als Strom statt als
Array.

[Erfordert 1.5] sub(Regex; tostring) sub(Regex; Schnur; Flaggen)
Geben Sie die Zeichenfolge aus, die Sie erhalten haben, indem Sie die erste Übereinstimmung von Regex in der Eingabezeichenfolge durch . ersetzen
tostring, nach Interpolation. tostring sollte ein jq-String sein und kann Referenzen enthalten
zu benannten Captures. Die benannten Captures werden tatsächlich als JSON-Objekt (als
gebaut von Erfassung) Um tostring, also würde ein Verweis auf eine erfasste Variable namens "x"
nehmen Sie die Form: "(.x)".

[Erfordert 1.5] gsub(Regex; Schnur), gsub(Regex; Schnur; Flaggen)
gsub ist wie unten aber alle nicht überlappenden Vorkommen der Regex werden durch die ersetzt
Zeichenfolge, nach der Interpolation.

Fortgeschritten MERKMALE

Variablen sind in den meisten Programmiersprachen eine absolute Notwendigkeit, aber sie werden verbannt
zu einer "erweiterten Funktion" in jq.

In den meisten Sprachen sind Variablen das einzige Mittel zur Weitergabe von Daten. Wenn Sie a . berechnen
Wert, und Sie ihn mehr als einmal verwenden möchten, müssen Sie ihn in einer Variablen speichern. Zu
Übergeben Sie einen Wert an einen anderen Teil des Programms, Sie benötigen diesen Teil des Programms, um
Definieren Sie eine Variable (als Funktionsparameter, Objektelement oder was auch immer), in der sie platziert werden soll
die Daten.

Es ist auch möglich, Funktionen in jq zu definieren, obwohl dies eine Funktion ist, deren größte
Verwendung definiert die Standardbibliothek von jq (viele jq-Funktionen wie Karte und gefunden sind in der Tat
geschrieben in jq).

jq hat Reduktionsoperatoren, die sehr mächtig, aber etwas knifflig sind. Das sind wiederum
meist intern verwendet, um einige nützliche Bits der Standardbibliothek von jq zu definieren.

Es mag zunächst nicht offensichtlich sein, aber bei jq dreht sich alles um Generatoren (ja, wie oft in
andere Sprachen). Einige Dienstprogramme werden bereitgestellt, um den Umgang mit Generatoren zu erleichtern.

Etwas minimale I/O-Unterstützung (neben dem Lesen von JSON aus der Standardeingabe und dem Schreiben von JSON in
Standardausgabe) zur Verfügung.

Schließlich gibt es ein Modul-/Bibliothekssystem.

Variablen
In jq haben alle Filter einen Eingang und einen Ausgang, sodass keine manuelle Installation erforderlich ist
einen Wert von einem Teil eines Programms zum nächsten übergeben. Viele Ausdrücke, zum Beispiel a + b,
übergeben ihre Eingabe an zwei verschiedene Unterausdrücke (hier a und b sind beide gleich bestanden
input), sodass Variablen normalerweise nicht notwendig sind, um einen Wert zweimal zu verwenden.

Zum Berechnen des Durchschnittswerts einer Reihe von Zahlen sind beispielsweise einige
Variablen in den meisten Sprachen - mindestens eine für das Array, vielleicht eine für jedes Element
oder für einen Schleifenzähler. In jq ist es einfach hinzufügen / Länge - der hinzufügen Ausdruck ist gegeben
Array und erzeugt seine Summe, und die Länge Ausdruck erhält das Array und erzeugt seine
Länge.

Es gibt also im Allgemeinen einen saubereren Weg, die meisten Probleme in jq zu lösen, als Variablen zu definieren.
Trotzdem erleichtern sie manchmal die Dinge, also können Sie mit jq Variablen definieren mit
Ausdruck as $variabel. Alle Variablennamen beginnen mit $. Hier ist eine etwas hässlichere Version
des Array-Mittelungsbeispiels:

Länge als $array_length | add / $array_length

Wir brauchen ein komplizierteres Problem, um eine Situation zu finden, in der Variablen tatsächlich verwendet werden
macht unser Leben einfacher.

Angenommen, wir haben eine Reihe von Blog-Posts mit den Feldern "Autor" und "Titel" und einem weiteren
-Objekt, das verwendet wird, um Benutzernamen von Autoren echten Namen zuzuordnen. Unsere Eingabe sieht so aus:

{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "Ein gut geschriebener Artikel", "author": "person1"}],
"realnames": {"anon": "Anonymer Feigling",
"person1": "Person McPherson"}}

Wir möchten die Beiträge mit dem Autorenfeld produzieren, das einen echten Namen enthält, wie in:

{"title": "Frist psot", "author": "Anonymous Coward"}
{"title": "Ein gut geschriebener Artikel", "author": "Person McPherson"}

Wir verwenden eine Variable, $names, um das realnames-Objekt zu speichern, damit wir später darauf zugreifen können
beim Nachschlagen von Autoren-Benutzernamen:

.realnames als $names | .posts[] | {Titel, Autor: $names[.author]}

Der Ausdruck exp as $x | ... bedeutet: für jeden Wert des Ausdrucks exp, den Rest laufen lassen
die Pipeline mit der gesamten ursprünglichen Eingabe und mit $x auf diesen Wert setzen. Daher as
fungiert als eine Art foreach-Schleife.

Ebenso {foo} ist eine praktische Art zu schreiben {foo: .foo}, damit {$foo} ist eine praktische Art zu schreiben
{foo:$foo}.

Mehrere Variablen können mit einer einzigen deklariert werden as Ausdruck durch Bereitstellung eines Musters
das mit der Struktur der Eingabe übereinstimmt (dies wird als "Destrukturierung" bezeichnet):

. als {realnames: $names, posts: [$first, $second]} | ...

Die Variablendeklarationen in Array-Mustern (z. B. . as [$erst, $Sekunde]) an die binden
Elemente des Arrays vom Element am Index null aufwärts, der Reihe nach. Wenn es keine gibt
Wert am Index für ein Array-Musterelement, null ist an diese Variable gebunden.

Variablen haben einen Gültigkeitsbereich für den Rest des Ausdrucks, der sie definiert, also

.realnames als $names | (.posts[] | {title, author: $names[.author]})

wird funktionieren, aber

(.realnames als $names | .posts[]) | {Titel, Autor: $names[.author]}

Gewohnheit.

Für Programmiersprachentheoretiker ist es genauer zu sagen, dass jq-Variablen sind
lexikalische Bindungen. Insbesondere kann der Wert einer Bindung nicht verändert werden;
man kann nur eine neue Bindung mit dem gleichen Namen einrichten, die aber dort nicht sichtbar ist
der alte war.

jq ´.bar als $x | .foo | . + $x´
{"foo":10, "bar":200}
=> 210

jq´. als $i|[(.*2|. als $i| $i), $i]´
5
=> [10,5]

jq´. als [$a, $b, {c: $c}] | $a + $b + $c´
[2, 3, {"c": 4, "d": 5}]
=> 9

jq ´.[] als [$a, $b] | {a: $a, b: $b}´
[[0], [0, 1], [2, 1, 0]]
=> {"a":0,"b":null}, {"a":0,"b":1}, {"a":2,"b":1}

Definieren Funktionen
Sie können einem Filter mit der Syntax "def" einen Namen geben:

def-Inkrement: . + 1;

Von da an, Zuwachs ist wie eine eingebaute Funktion als Filter verwendbar (tatsächlich ist dies
ist, wie einige der Built-Ins definiert sind). Eine Funktion kann Argumente annehmen:

def map(f): [.[] | F];

Argumente werden als Filter und nicht als Werte übergeben. Das gleiche Argument kann referenziert werden
mehrfach mit unterschiedlichen Eingaben (hier f wird für jedes Element des Eingabearrays ausgeführt).
Argumente für eine Funktion funktionieren eher wie Callbacks als wie Wertargumente. Das ist
wichtig zu verstehen. Erwägen:

def foo(f): f|f;
5|foo(.*2)

Das Ergebnis wird 20 sein, weil f is . * 2, und beim ersten Aufruf von f . wird 5 sein,
und beim zweiten Mal ist es 10 (5 * 2), also ist das Ergebnis 20. Funktionsargumente
sind Filter, und Filter erwarten beim Aufrufen eine Eingabe.

Wenn Sie das Wert-Argument-Verhalten für die Definition einfacher Funktionen verwenden möchten, können Sie einfach a
Variable:

def addvalue(f): f als $f | Karte(. + $f);

Oder verwenden Sie die Kurzform:

def addvalue($f): ...;

Mit jeder Definition, Mehrwert(.foo) fügt die aktuellen Eingaben hinzu .foo Feld zu jedem
Element des Arrays.

Mehrere Definitionen mit demselben Funktionsnamen sind zulässig. Jede Neudefinition ersetzt
das vorherige für die gleiche Anzahl von Funktionsargumenten, aber nur für Referenzen von
Funktionen (oder Hauptprogramm) nach der Neudefinition.

jq ´def Mehrwert(f): . + [f]; map(addvalue(.[0]))´
[[1,2], [10,20]]
=> [[1,2,1], [10,20,10]]

jq ´def addvalue(f): f als $x | Karte(. + $x); addvalue(.[0])´
[[1,2], [10,20]]
=> [[1,2,1,2], [10,20,1,2]]

Reduziert
Das Veteran Syntax in jq ermöglicht es Ihnen, alle Ergebnisse eines Ausdrucks zu kombinieren durch
akkumulieren sie in einer einzigen Antwort. Als Beispiel gehen wir vorbei [3,2,1] dies
Ausdruck:

.[] als $item (0; . + $item) reduzieren

Für jedes Ergebnis, das .[] produziert, . + $Artikel wird ausgeführt, um eine laufende Summe zu bilden,
beginnend bei 0. In diesem Beispiel .[] ergibt die Ergebnisse 3, 2 und 1, also ist der Effekt
ähnlich dem Ausführen von so etwas:

0 | (3 als $item | . + $item) |
(2 als $item | . + $item) |
(1 als $item | . + $item)

jq ´reduzieren .[] als $item (0; . + $item)´
[10,2,5,3]
=> 20

Grenze(n; exp)
Das begrenzen Funktion extrahiert bis zu n Ausgänge von exp.

jq ´[limit(3;.[])]´
[0,1,2,3,4,5,6,7,8,9]
=> [0,1,2]

zuerst(ausdruck), letzte(ausdruck), n-te(n; Ausdruck)
Das zuerst(ausdruck) und letzte(ausdruck) Funktionen extrahieren den ersten und letzten Wert aus ausdr,
beziehungsweise.

Das n-te(n; Ausdruck) Funktion extrahiert den n-ten Wert ausgegeben um ausdr. Dies kann definiert werden als
def n-te(n; Ausdruck): letzte(Grenze(n + 1; Ausdruck));. Beachten Sie, dass n-te(n; Ausdruck) unterstützt nicht
negative Werte von n.

jq ´[erster(Bereich(.)), letzter(Bereich(.)), nth(./2; Bereich(.))]´
10
=> [0,9,5]

als erstes, letzte, n-te(n)
Das zuerst und letzte Funktionen extrahieren den ersten und letzten Wert aus einem beliebigen Array at ..

Das n-te(n) Funktion extrahiert den n-ten Wert eines beliebigen Arrays at ..

jq ´[Bereich(.)]|[erste, letzte, nth(5)]´
10
=> [0,9,5]

foreach
Das foreach Syntax ist ähnlich wie Veteran, aber beabsichtigt, den Bau von begrenzen
und Reduzierstücke, die Zwischenergebnisse erzeugen (siehe Beispiel).

Die Form ist foreach EXP as $ var (DRIN; AKTUALISIEREN; EXTRAKT). Wie Veteran, INIT wird ausgewertet
einmal, um einen Zustandswert zu erzeugen, dann jede Ausgabe von EXP ist gebunden an $ var, AKTUALISIEREN is
ausgewertet für jede Ausgabe von EXP mit dem aktuellen Stand und mit $ var sichtbar. Jeder Wert
Ausgabe von AKTUALISIEREN ersetzt den vorherigen Zustand. Schließlich, EXTRAKT wird für jedes neue ausgewertet
Zustand, um eine Ausgabe von zu extrahieren foreach.

Dies ist meistens nur für den Bau nützlich Veteran- Und begrenzen-ähnliche Funktionen. Aber es ist
viel allgemeiner, da teilweise Kürzungen möglich sind (siehe Beispiel unten).

jq ´[foreach .[] as $item ([[],[]]; if $item == null then [[],.[0]] else [(.[0] + [$item]),[ ]] end; if $item == null then .[1] else empty end)]´
[1,2,3,4,null,"a","b",null]
=> [[1,2,3,4],["a","b"]]

Rekursion
Wie oben beschrieben, rekursiv verwendet Rekursion, und jede jq-Funktion kann rekursiv sein. Die
während builtin ist auch im Hinblick auf die Rekursion implementiert.

Tail Calls werden immer dann optimiert, wenn der Ausdruck links von den rekursiven Aufrufausgaben
seinen letzten Wert. In der Praxis bedeutet dies, dass der Ausdruck links vom rekursiven
Aufruf sollte nicht mehr als eine Ausgabe für jede Eingabe erzeugen.

Beispielsweise:

def recurse(f): def r: ., (f | select(. != null) | r); R;

def while(cond; aktualisieren):
def _während:
if cond then ., (update | _while) else empty end;
_während;

def wiederholen (exp):
def _wiederholen:
exp, _wiederholen;
_wiederholen;

Generatoren und Iteratoren
Einige jq-Operatoren und -Funktionen sind tatsächlich Generatoren, da sie Null erzeugen können,
ein oder mehrere Werte für jeden Eingang, so wie man es bei anderen Programmierungen erwarten könnte
Sprachen mit Generatoren. Zum Beispiel, .[] generiert alle Werte in seiner Eingabe
(das muss ein Array oder ein Objekt sein), Bereich(0; 10) erzeugt die ganzen Zahlen zwischen 0 und
10 und so weiter.

Auch der Komma-Operator ist ein Generator, der zuerst die Werte generiert, die von der
Ausdruck links vom Komma, dann werden für jeden von diesen die Werte generiert durch die
Ausdruck rechts vom Komma.

Das leer Builtin ist der Generator, der null Ausgänge erzeugt. Die leer builtin
führt zum vorherigen Generatorausdruck zurück.

Alle jq-Funktionen können Generatoren sein, indem sie nur eingebaute Generatoren verwenden. Es ist auch möglich
um neue Generatoren zu definieren, die nur die Rekursion und den Kommaoperator verwenden. Wenn das rekursive
call(s) ist(sind) "in Tail Position", dann ist der Generator effizient. Im Beispiel
unter dem rekursiven Aufruf von _Bereich zu sich selbst ist in Schwanzposition. Das Beispiel zeigt sich
drei fortgeschrittene Themen: Tail-Rekursion, Generatorkonstruktion und Unterfunktionen.

jq ´def range(init; upto; by): def _range: if (by > 0 und . < upto) or (by < 0 und . > upto) then ., ((.+by)|_range) else . Ende; if by == 0 then init else init|_range end | select((von > 0 und . < bis) oder (von < 0 und . > bis)); Bereich(0; 10; 3)´
null
=> 0, 3, 6, 9

jq ´def while(cond; update): def _while: wenn cond dann ., (update | _while) else empty end; _während; [während(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

MATHE

jq unterstützt derzeit nur Gleitkommazahlen mit doppelter Genauigkeit (754-Bit) nach IEEE64.

Neben einfachen arithmetischen Operatoren wie +, jq hat auch die meisten mathematischen Standardfunktionen
aus der C-Mathe-Bibliothek. C-Mathematikfunktionen, die ein einzelnes Eingabeargument annehmen (z. B. ohne ())
stehen als Null-Argument-jq-Funktionen zur Verfügung. C mathematische Funktionen, die zwei Eingaben benötigen
Argumente (z. pow ()) sind als jq-Funktionen mit zwei Argumenten verfügbar, die ignorieren ..

Die Verfügbarkeit von mathematischen Standardfunktionen hängt von der Verfügbarkeit der entsprechenden
mathematische Funktionen in Ihrem Betriebssystem und der C-Mathe-Bibliothek. Nicht verfügbare mathematische Funktionen
wird definiert, führt aber zu einem Fehler.

I / O

Zu diesem Zeitpunkt bietet jq nur minimale Unterstützung für I/O, hauptsächlich in Form von Kontrolle darüber, wann
Eingänge werden gelesen. Dafür stehen zwei eingebaute Funktionen zur Verfügung, Eingabe und Eingänge, das lesen
aus denselben Quellen (z. Standard, in der Befehlszeile benannte Dateien) als jq selbst. Diese
zwei Builtins und jqs eigene Leseaktionen können miteinander verschachtelt werden.

Ein eingebauter bietet minimale Ausgabemöglichkeiten, debuggen. (Erinnern Sie sich daran, dass ein jq-Programm
Ausgabewerte werden immer als JSON-Texte ausgegeben auf stdout.) Das debuggen eingebaut haben kann
anwendungsspezifisches Verhalten, z. B. für ausführbare Dateien, die die libjq-C-API verwenden, aber nicht
die ausführbare jq-Datei selbst.

Eingabe
Gibt einen neuen Eingang aus.

Eingänge
Gibt alle verbleibenden Eingänge nacheinander aus.

Dies ist vor allem für Reduzierungen über die Eingaben eines Programms nützlich.

debuggen
Bewirkt, dass eine Debug-Meldung basierend auf dem Eingabewert erzeugt wird. Die ausführbare jq-Datei umschließt
der Eingabewert mit ["DEBUGGEN:", ] und druckt das und einen Zeilenumbruch auf stderr,
kompakt. Dies kann sich in Zukunft ändern.

Eingabedateiname
Gibt den Namen der Datei zurück, deren Eingabe gerade gefiltert wird. Beachten Sie, dass dies
funktioniert nicht gut, es sei denn, jq läuft in einem UTF-8-Gebietsschema.

Eingabezeilennummer
Gibt die Zeilennummer der gerade gefilterten Eingabe zurück.

STREAMING

Mit der --Strom Option jq kann Eingabetexte auf Streaming-Art parsen, wodurch jq
Programme, um große JSON-Texte sofort und nicht nach dem Parsen zu verarbeiten
vervollständigt. Wenn Sie einen einzelnen JSON-Text mit einer Größe von 1 GB haben, können Sie ihn streamen
um es viel schneller zu verarbeiten.

Streaming ist jedoch nicht einfach zu handhaben, wie es das jq-Programm haben wird [ ,
] (und ein paar andere Formulare) als Eingaben.

Es werden mehrere Built-Ins bereitgestellt, um die Handhabung von Streams zu vereinfachen.

Die folgenden Beispiele verwenden die gestreamte Form von [0,[1]], Das ist
[[0],0],[[1,0],1],[[1,0]],[[1]].

Streaming-Formulare enthalten [ , ] (um einen beliebigen Skalarwert anzuzeigen, leeres Array,
oder leeres Objekt) und [ ] (um das Ende eines Arrays oder Objekts anzuzeigen). Zukunft
Versionen von jq laufen mit --Strom und -seq kann zusätzliche Formulare ausgeben, wie z ["Error
Botschaft"] wenn ein Eingabetext nicht geparst werden kann.

truncate_stream(stream_ausdruck)
Verbraucht eine Zahl als Eingabe und schneidet die entsprechende Anzahl von Pfadelementen ab
links neben den Ausgaben des angegebenen Streaming-Ausdrucks.

jq ´[1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]])]´
1
=> [[[0],2],[[0]]]

fromstream(stream_ausdruck)
Gibt Werte aus, die den Ausgaben des Stream-Ausdrucks entsprechen.

jq ´fromstream(1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]]))´
null
=> [2]

tostreamen
Das tostreamen builtin gibt die gestreamte Form seiner Eingabe aus.

jq´. als $dot|fromstream($dot|tostream)|.==$dot´
[0,[1,{"a":1},{"b":2}]]
=> wahr

ZUORDNUNG

Die Zuweisung funktioniert in jq etwas anders als in den meisten Programmiersprachen. jq nicht
zwischen Referenzen und Kopien von etwas unterscheiden - zwei Objekte oder Arrays sind
entweder gleich oder nicht gleich, ohne weitere Vorstellung von "dasselbe Objekt" oder "nicht"
das gleiche Objekt".

Wenn ein Objekt zwei Felder hat, die Arrays sind, .foo und .bar, und du hängst etwas an
.foo und dann .bar wird nicht größer. Auch wenn du gerade erst eingestellt hast .bar = .foo. Wenn du es gewohnt bist
zum Programmieren in Sprachen wie Python, Java, Ruby, Javascript usw. dann kannst du denken
davon, als ob jq eine vollständige tiefe Kopie jedes Objekts erstellt, bevor es die Zuweisung durchführt
(für die Leistung tut es das eigentlich nicht, aber das ist die allgemeine Idee).

Alle Zuweisungsoperatoren in jq haben Pfadausdrücke auf der linken Seite.

=
Der Filter .foo = 1 nimmt als Eingabe ein Objekt und erzeugt als Ausgabe ein Objekt mit dem
Feld "foo" auf 1 gesetzt. Es gibt keine Vorstellung davon, etwas in jq zu "modifizieren" oder zu "ändern".
alle jq-Werte sind unveränderlich. Zum Beispiel,

.foo = .bar | .foo.baz = 1

wird nicht den Nebeneffekt haben, dass .bar.baz auf 1 gesetzt wird, da das ähnlich aussehende
Programm in Javascript, Python, Ruby oder anderen Sprachen wäre. Im Gegensatz zu diesen Sprachen (aber
wie Haskell und einige andere funktionale Sprachen), gibt es keine Vorstellung von zwei Arrays oder
Objekte, die "das gleiche Array" oder "das gleiche Objekt" sind. Sie können gleich oder nicht gleich sein, aber
Wenn wir eines von ihnen ändern, wird sich das andere unter keinen Umständen hinter unserem Rücken ändern.

Dies bedeutet, dass es unmöglich ist, in jq zirkuläre Werte zu bilden (wie ein Array, dessen
erstes Element ist sich selbst). Dies ist durchaus beabsichtigt und stellt sicher, dass alles ein jq
Programm produzieren kann in JSON dargestellt werden.

Beachten Sie, dass sich die linke Seite von ´=´ auf einen Wert in . bezieht .. Somit $var.foo = 1 wird nicht funktionieren
wie erwartet ($var.foo ist kein gültiger oder nützlicher Pfadausdruck in .); verwenden $ var | .foo = 1
stattdessen.

Wenn die rechte Seite von ´=´ mehrere Werte ergibt, dann wird für jeden solchen Wert jq
setze die Pfade auf der linken Seite auf den Wert und dann wird das geänderte . ausgegeben ..
Zum Beispiel, (.a,.b)=Angebot(2) Ausgänge {"a":0,"b":0} und dann {"a":1,"b":1}. Das Update"
Zuweisungsformulare (siehe unten) tun dies nicht.

Beachten Sie auch das .a,.b=0 setzt nicht .a und .b, Aber (.a,.b)=0 stellt beides ein.

|=
Neben dem Zuweisungsoperator ´=´ liefert jq den "Aktualisierungs"-Operator ´|=´, der
nimmt einen Filter auf der rechten Seite und berechnet den neuen Wert für die Eigenschaft von .
zugewiesen wird, indem der alte Wert durch diesen Ausdruck ausgeführt wird. Zum Beispiel .foo |=
.+1 erstellt ein Objekt mit dem "foo"-Feld, das auf "foo" plus 1 des Eingangs gesetzt ist.

Dieses Beispiel soll den Unterschied zwischen ´=´ und ´|=´ zeigen:

Geben Sie den Programmen die Eingabe ´{"a": {"b": 10}, "b": 20}´ ein:

.a = .b .a |= .b

Ersteres setzt das "a"-Feld der Eingabe auf das "b"-Feld der Eingabe und erzeugt
die Ausgabe {"a": 20}. Letzteres setzt das "a"-Feld der Eingabe auf das "a"-Feld
Feld "b", das {"a": 10} erzeugt.

Die linke Seite kann ein beliebiger allgemeiner Pfadausdruck sein; sehen Weg().

Beachten Sie, dass sich die linke Seite von ´|=´ auf einen Wert in . bezieht .. Somit $var.foo |= . + 1 Gewohnheit
funktioniert wie erwartet ($var.foo ist kein gültiger oder nützlicher Pfadausdruck in .); verwenden $ var | .foo
|= . + 1 stattdessen.

Wenn die rechte Seite mehrere Werte ausgibt, wird nur der letzte verwendet.

jq ´(..|select(type=="boolean")) |= if . dann 1 sonst 0 end´
[wahr, falsch,[5,wahr,[wahr,[falsch]],falsch]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, /=, %=, // =
jq hat einige Operatoren der Form a op= b, die alle äquivalent zu sind a |= . op b. So,
+= 1 kann verwendet werden, um Werte zu erhöhen.

jq ´.foo += 1´
{"foo": 42}
=> {"foo": 43}

Complex Zuordnungen
Auf der linken Seite einer jq-Zuweisung sind viel mehr Dinge erlaubt als in den meisten Fällen
Sprachen. Wir haben auf der linken Seite bereits einfache Feldzugriffe gesehen, und es ist nein
überrascht, dass Array-Zugriffe genauso gut funktionieren:

.posts[0].title = "JQ-Handbuch"

Was überraschen mag ist, dass der Ausdruck auf der linken Seite ein Vielfaches erzeugen kann
Ergebnisse, die sich auf verschiedene Punkte im Eingabedokument beziehen:

.posts[].comments |= . + ["Das ist großartig"]

In diesem Beispiel wird die Zeichenfolge "das ist großartig" an das Array "Kommentare" jedes Beitrags in angehängt
die Eingabe (wobei die Eingabe ein Objekt mit einem Feld "Beiträge" ist, das ein Array von Beiträgen ist).

Wenn jq auf eine Zuweisung wie ´a = b´ stößt, zeichnet es den "Pfad" auf, der zur Auswahl von a . genommen wurde
Teil des Eingabedokuments während der Ausführung von a. Dieser Pfad wird dann verwendet, um herauszufinden, welcher Teil von
die Eingabe, die während der Ausführung der Zuweisung geändert werden soll. Jeder Filter kann auf dem . verwendet werden
linke Seite eines Gleichheitszeichens - welcher Pfad auch immer aus der Eingabe ausgewählt wird, wird dort sein, wo der
Auftrag ausgeführt wird.

Dies ist eine sehr leistungsfähige Operation. Angenommen, wir möchten einen Kommentar zu Blog-Posts hinzufügen, indem wir verwenden
die gleiche "Blog"-Eingabe oben. Diesmal wollen wir nur die Beiträge kommentieren, die von . geschrieben wurden
"stedolan". Wir können diese Beiträge mit der zuvor beschriebenen "Auswählen"-Funktion finden:

.posts[] | select(.author == "stedolan")

Die von dieser Operation bereitgestellten Pfade zeigen auf jeden der Beiträge, die "stedolan" geschrieben hat, und
wir können jeden von ihnen auf die gleiche Weise kommentieren wie zuvor:

(.posts[] | select(.author == "stedolan") | .comments) |=
. + ["schrecklich."]

MODULE

jq hat ein Bibliotheks-/Modulsystem. Module sind Dateien, deren Namen auf enden .jq.

Von einem Programm importierte Module werden in einem Standardsuchpfad gesucht (siehe unten). Die
importieren und das Direktiven ermöglichen es dem Importeur, diesen Pfad zu ändern.

Pfade im Suchpfad a unterliegen verschiedenen Ersetzungen.

Bei Pfaden, die mit "~/" beginnen, wird das Home-Verzeichnis des Benutzers durch "~" ersetzt.

Für Pfade, die mit "$ORIGIN/" beginnen, wird der Pfad der ausführbaren jq-Datei ersetzt
"$ORIGIN".

Für Pfade, die mit "./" beginnen oder Pfade, die "." sind, ist der Pfad der einschließenden Datei
Ersetzt durch ".". Bei Programmen der obersten Ebene, die auf der Befehlszeile angegeben werden, ist das aktuelle
Verzeichnis verwendet wird.

Importanweisungen können optional einen Suchpfad angeben, an den der Standardwert angehängt wird.

Der Standardsuchpfad ist der Suchpfad, der dem -L Befehlszeilenoption, sonst
["~/.jq", "$ORIGIN/../lib/jq", "$ORIGIN/../ lib"].

Null- und leere Zeichenfolgenpfadelemente beenden die Suchpfadverarbeitung.

Eine Abhängigkeit mit dem relativen Pfad "foo/bar" würde in "foo/bar.jq" gesucht und
"foo/bar/bar.jq" im angegebenen Suchpfad. Damit sollen Module platziert werden können
in einem Verzeichnis zusammen mit beispielsweise Versionskontrolldateien, README-Dateien usw.
sondern auch um Single-File-Module zu ermöglichen.

Aufeinanderfolgende Komponenten mit gleichem Namen sind nicht erlaubt, um Mehrdeutigkeiten zu vermeiden (z.
"foo/foo").

Zum Beispiel mit -L$HOME/.jq ein Modul foo kann gefunden werden in $HOME/.jq/foo.jq und
$HOME/.jq/foo/foo.jq.

Wenn "$HOME/.jq" eine Datei ist, wird sie in das Hauptprogramm eingelesen.

importieren RelativePathString as NAME/FUNKTION [ ];
Importiert ein Modul, das im angegebenen Pfad relativ zu einem Verzeichnis in einem Suchpfad gefunden wurde. Ein ".jq"
Das Suffix wird der relativen Pfadzeichenfolge hinzugefügt. Den Symbolen des Moduls ist vorangestellt
"NAME::".

Die optionalen Metadaten müssen ein konstanter jq-Ausdruck sein. Es sollte ein Objekt mit Schlüsseln sein
wie "Homepage" und so weiter. Zur Zeit verwendet jq nur den Schlüssel/Wert "Suche" des
Metadaten. Die Metadaten werden den Nutzern auch über das Modulmeta eingebaut.

Der Schlüssel "search" in den Metadaten sollte, falls vorhanden, einen String- oder Array-Wert (Array
von Saiten); Dies ist der Suchpfad, der dem Suchpfad der obersten Ebene vorangestellt werden soll.

das RelativePathString [ ];
Importiert ein Modul, das unter dem angegebenen Pfad relativ zu einem Verzeichnis in einem Suchpfad gefunden wurde, als ob es
wurden an Ort und Stelle aufgenommen. Der relativen Pfadzeichenfolge wird ein ".jq"-Suffix hinzugefügt. Die
Die Symbole des Moduls werden in den Namensraum des Aufrufers importiert, als ob der Inhalt des Moduls hätte
direkt aufgenommen worden.

Die optionalen Metadaten müssen ein konstanter jq-Ausdruck sein. Es sollte ein Objekt mit Schlüsseln sein
wie "Homepage" und so weiter. Zur Zeit verwendet jq nur den Schlüssel/Wert "Suche" des
Metadaten. Die Metadaten werden den Nutzern auch über das Modulmeta eingebaut.

importieren RelativePathString as $NAME [ ];
Importiert eine JSON-Datei, die im angegebenen Pfad relativ zu einem Verzeichnis in einem Suchpfad gefunden wird. EIN
Das Suffix ".json" wird der relativen Pfadzeichenfolge hinzugefügt. Die Daten der Datei werden
verfügbar als $NAME::NAME.

Die optionalen Metadaten müssen ein konstanter jq-Ausdruck sein. Es sollte ein Objekt mit Schlüsseln sein
wie "Homepage" und so weiter. Zur Zeit verwendet jq nur den Schlüssel/Wert "Suche" des
Metadaten. Die Metadaten werden den Nutzern auch über das Modulmeta eingebaut.

Der Schlüssel "search" in den Metadaten sollte, falls vorhanden, einen String- oder Array-Wert (Array
von Saiten); Dies ist der Suchpfad, der dem Suchpfad der obersten Ebene vorangestellt werden soll.

Modulen ;
Diese Direktive ist völlig optional. Es ist für den ordnungsgemäßen Betrieb nicht erforderlich. Es dient
nur zum Zweck der Bereitstellung von Metadaten, die mit dem . gelesen werden können Modulmeta eingebaut.

Die Metadaten müssen ein konstanter jq-Ausdruck sein. Es sollte ein Objekt mit Schlüsseln sein wie
"Startseite". jq verwendet diese Metadaten derzeit nicht, aber sie werden den Benutzern zur Verfügung gestellt
über das Modulmeta eingebaut.

Modulmeta
Nimmt einen Modulnamen als Eingabe und gibt die Metadaten des Moduls als Objekt aus, mit dem
Modulimporte (einschließlich Metadaten) als Array-Wert für den Schlüssel "deps".

Programme können damit die Metadaten eines Moduls abfragen, die sie dann verwenden können, um z
Suchen Sie beispielsweise nach fehlenden Abhängigkeiten, laden Sie sie herunter und installieren Sie sie.

Verwenden Sie jq online mit den onworks.net-Diensten