jq - Online in de cloud

PROGRAMMA:

NAAM

jq - Commandoregel JSON-processor

KORTE INHOUD

jq [opties​ filter [bestanden​

jq kan JSON op verschillende manieren transformeren, door te selecteren, itereren, reduceren en anderszins
het verminken van JSON-documenten. Bijvoorbeeld het uitvoeren van de opdracht jq ´kaart(.prijs) | toevoegen wil
neem een ​​array van JSON-objecten als invoer en retourneer de som van hun "prijs"-velden.

jq kan ook tekstinvoer accepteren, maar standaard is jq leest een stroom JSON-entiteiten
(inclusief cijfers en andere letterlijke waarden) uit stdin. Witruimte is alleen nodig om te scheiden
entiteiten zoals 1 en 2, en waar en onwaar. Een of meer bestanden kan worden gespecificeerd, waarin
geval jq zal in plaats daarvan de invoer van deze lezen.

De opties worden beschreven in de INVOEREN JQ sectie; het gaat vooral om input en output
opmaak. De filter is geschreven in de jq-taal en specificeert hoe de
invoerbestand of document.

FILTERS

Een jq-programma is een "filter": het neemt invoer en produceert uitvoer. Er zijn veel
ingebouwde filters voor het extraheren van een bepaald veld van een object, of het converteren van een getal naar
een string, of diverse andere standaardtaken.

Filters kunnen op verschillende manieren worden gecombineerd: u kunt de uitvoer van één filter naar binnen leiden
een ander filter, of verzamel de uitvoer van een filter in een array.

Sommige filters produceren meerdere resultaten, er is er bijvoorbeeld één die alle resultaten oplevert
elementen van de invoerarray. Door dat filter naar een tweede te leiden, wordt het tweede filter uitgevoerd
elk element van de array. Over het algemeen worden dingen gedaan met lussen en iteratie
in andere talen wordt dit eenvoudigweg gedaan door filters aan elkaar te lijmen in jq.

Het is belangrijk om te onthouden dat elk filter een invoer en een uitvoer heeft. Zelfs letterlijke
zoals "hallo" of 42 zijn filters - ze nemen invoer maar produceren altijd dezelfde letterlijke waarde als
uitgang. Bewerkingen die twee filters combineren, zoals optellen, voeden doorgaans dezelfde invoer
beide en combineer de resultaten. U kunt dus een middelingsfilter implementeren als toevoegen / lengte
- het invoeren van de invoerarray naar zowel de toevoegen filteren en de lengte filteren en vervolgens uitvoeren
de divisie.

Maar dat loopt op de zaken vooruit. :) Laten we beginnen met iets eenvoudiger:

INVOEREN JQ

jq-filters draaien op een stroom JSON-gegevens. De invoer voor jq wordt ontleed als een reeks van
door spaties gescheiden JSON-waarden die één voor één door het opgegeven filter worden doorgegeven
tijd. De uitvoer(en) van het filter worden standaard naar buiten geschreven, opnieuw als een reeks
door witruimte gescheiden JSON-gegevens.

Opmerking: het is belangrijk om rekening te houden met de regels voor het citeren van de shell. Als algemene regel geldt dat dit het beste is
citeer altijd (met enkele aanhalingstekens) het jq-programma, omdat er te veel tekens zijn
speciale betekenis voor jq zijn ook shell-metatekens. Bijvoorbeeld, jq "foe" zal mislukken
de meeste Unix-shells omdat dat hetzelfde zal zijn als jq foo, wat doorgaans zal mislukken
omdat foo is niet gedefinieerd. Wanneer u de Windows-opdrachtshell (cmd.exe) gebruikt, kunt u dit het beste doen
gebruik dubbele aanhalingstekens rond uw jq-programma wanneer dit op de opdrachtregel wordt opgegeven (in plaats van de -f
programmabestand optie), maar dan moeten dubbele aanhalingstekens in het jq-programma een backslash-escape gebruiken.

U kunt beïnvloeden hoe jq zijn invoer en uitvoer leest en schrijft met behulp van een opdrachtregel
opties:

· --versie:

Voer de jq-versie uit en sluit af met nul.

· --volg:

Gebruik de application/json-seq MIME-typeschema voor het scheiden van JSON-teksten in de invoer van jq
en uitgang. Dit betekent dat er vooraf een ASCII RS-teken (record separator) wordt afgedrukt
elke waarde bij uitvoer en een ASCII LF (line feed) wordt na elke uitvoer afgedrukt. Invoer
JSON-teksten die niet kunnen worden geparseerd, worden genegeerd (maar gewaarschuwd), waarbij ze allemaal worden weggegooid
daaropvolgende invoer tot de volgende RS. Dit parseert ook de uitvoer van jq zonder de
--volg optie.

· --stroom:

Parseer de invoer op streaming-wijze, waarbij arrays van pad- en leaf-waarden worden uitgevoerd
(scalaren en lege arrays of lege objecten). Bijvoorbeeld, "A" wordt [[],"A"] en
[[],"a",["b"]] wordt [[0],[]], [[1],"een"] en [[1,0],"b"].

Dit is handig voor het verwerken van zeer grote invoer. Gebruik dit in combinatie met
filteren en de verminderen en foreach syntaxis om grote invoer stapsgewijs te verminderen.

· --slurpen/-s:

In plaats van het filter uit te voeren voor elk JSON-object in de invoer, leest u de volledige invoer
stream naar een grote array en voer het filter slechts één keer uit.

· --ruwe invoer/-R:

Parseer de invoer niet als JSON. In plaats daarvan wordt elke tekstregel als een
snaar. Indien gecombineerd met --slurpen, dan wordt de volledige invoer doorgegeven aan het filter als a
enkele lange snaar.

· --null-invoer/-n:

Lees helemaal geen invoer! In plaats daarvan wordt het filter één keer uitgevoerd nul als de ingang.
Dit is handig wanneer u jq gebruikt als een eenvoudige rekenmachine of om JSON-gegevens uit te construeren
krassen.

· --compact-uitvoer / -c:

Standaard drukt jq mooie JSON-uitvoer af. Het gebruik van deze optie zal resulteren in meer
compacte uitvoer door elk JSON-object op één regel te plaatsen.

· --tabblad:

Gebruik een tab voor elk inspringniveau in plaats van twee spaties.

· --inspringen n:

Gebruik het opgegeven aantal spaties (niet meer dan 8) voor inspringen.

· --kleuruitvoer / -C en --monochroom-uitvoer / -M:

Standaard voert jq gekleurde JSON uit als er naar een terminal wordt geschreven. Je kunt het dwingen
kleur produceren, zelfs als u naar een pipe of bestand schrijft -Cen schakel kleur uit met -M.

· --ascii-uitvoer / -a:

jq voert niet-ASCII Unicode-codepunten gewoonlijk uit als UTF-8, zelfs als de invoer is opgegeven
ze als ontsnappingssequenties (zoals "\u03bc"). Met deze optie kunt u jq forceren
produceer pure ASCII-uitvoer waarbij elk niet-ASCII-teken wordt vervangen door het equivalent
ontsnappingsvolgorde.

· --niet gebufferd

Spoel de uitvoer door nadat elk JSON-object is afgedrukt (handig als u langzaam werkt
gegevensbron naar jq en de uitvoer van jq naar elders doorsturen).

· --sorteertoetsen / -S:

Voer de velden van elk object uit met de sleutels in gesorteerde volgorde.

· --ruwe uitvoer / -r:

Als het resultaat van het filter met deze optie een string is, wordt het direct geschreven
naar standaarduitvoer in plaats van te worden geformatteerd als een JSON-tekenreeks met aanhalingstekens. Dit kan
kan nuttig zijn om jq-filters te laten praten met niet-JSON-gebaseerde systemen.

· --join-uitvoer / -j:

Like -r maar jq zal geen nieuwe regel afdrukken na elke uitvoer.

· -f bestandsnaam / --van bestand bestandsnaam:

Lees het filter uit het bestand in plaats van vanaf een opdrachtregel, zoals de optie -f van awk. Jij
U kunt ook ´#´ gebruiken om commentaar te geven.

· -Ldirectory / -L directory:

Voorafgaand aan directory naar de zoeklijst voor modules. Als deze optie wordt gebruikt, nee
ingebouwde zoeklijst wordt gebruikt. Zie het gedeelte over modules hieronder.

· -e / --exit-status:

Stelt de afsluitstatus van jq in op 0 als de laatste uitvoerwaarden geen van beide waren vals noch nul,
1 als de laatste uitvoerwaarde een van beide was vals or nul, of 4 als er nooit een geldig resultaat is geweest
geproduceerd. Normaal gesproken wordt jq afgesloten met 2 als er een gebruiksprobleem of systeemfout is geweest, 3
als er een compileerfout in het jq-programma is opgetreden, of 0 als het jq-programma is uitgevoerd.

· --arg naam waarde:

Deze optie geeft een waarde door aan het jq-programma als een vooraf gedefinieerde variabele. Als u jq
Met --arg foo barsdan $ foo is beschikbaar in het programma en heeft de waarde "bar".
Merk op dat waarde wordt behandeld als een string, dus --arg foo 123 zal binden $ foo naar "123".

· --argjson naam JSON-tekst:

Deze optie geeft een JSON-gecodeerde waarde door aan het jq-programma als een vooraf gedefinieerde variabele. Als
waarmee je jq uitvoert --argjson foo 123dan $ foo is beschikbaar in het programma en heeft de
waarde 123.

· --slurpbestand variabelenaam bestandsnaam:

Deze optie leest alle JSON-teksten in het genoemde bestand en bindt een array van de
geparseerde JSON-waarden naar de gegeven globale variabele. Als je jq uitvoert met --argbestand foo bars,
harte $ foo is beschikbaar in het programma en heeft een array waarvan de elementen overeenkomen
de teksten in het bestand met de naam bars.

· --argbestand variabelenaam bestandsnaam:

Gebruik niet. Gebruik --slurpbestand gebruiken.

(Deze optie is als --slurpbestand, maar als het bestand maar één tekst bevat, dan is dat zo
gebruikt, anders wordt een reeks teksten gebruikt zoals in --slurpbestand.)

· --run-tests [bestandsnaam]:

Voert de tests uit in het opgegeven bestand of in de standaardinvoer. Dit moet de laatste optie zijn die wordt gegeven
en respecteert niet alle voorgaande opties. De invoer bestaat uit commentaarregels, leeg
regels, en programmaregels gevolgd door één invoerregel, zoveel uitvoerregels als er zijn
verwacht (één per uitvoer) en een lege regel die eindigt. Compilatiefouttests
begin met een regel die alleen "%%FAIL" bevat, en vervolgens een regel die het programma to bevat
compileren en vervolgens een regel met een foutmelding om te vergelijken met de werkelijke.

Wees gewaarschuwd dat deze optie achterwaarts incompatibel kan veranderen.

BASIC FILTERS

.
Het absoluut eenvoudigste (en minst interessante) filter is .. Dit is een filter dat zijn
input en produceert deze onveranderd als output.

Omdat jq standaard alle uitvoer mooi afdrukt, kan dit triviale programma een handige manier zijn
JSON-uitvoer formatteren van bijvoorbeeld krullen.

jq ´.´
"Hallo Wereld!"
=> "Hallo wereld!"

.foe, .foo.bar
De makkelijkste nuttig filteren is .foo. Wanneer een JSON-object (ook bekend als woordenboek of hash) wordt gegeven als
invoer, het produceert de waarde op de sleutel "foo", of null als er geen aanwezig is.

Als de sleutel speciale tekens bevat, moet u deze omringen met dubbele aanhalingstekens, zoals
deze: "foe$".

Een filter van het formulier .foo.bar is gelijk aan .foo|.balk.

jq ´.foo´
{"foo": 42, "bar": "minder interessante gegevens"}
=> 42

jq ´.foo´
{"notfoo": waar, "ooknotfoo": false}
=> nul

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

.foo?
Net als .foo, maar geeft zelfs geen foutmelding wanneer . is geen array of object.

jq ´.foo?´
{"foo": 42, "bar": "minder interessante gegevens"}
=> 42

jq ´.foo?´
{"notfoo": waar, "ooknotfoo": false}
=> nul

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

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

.[ ], .[2], .[10:15]
U kunt ook velden van een object opzoeken met behulp van syntaxis zoals .["foe"] (.foo hierboven is een
verkorte versie hiervan). Deze werkt ook voor arrays, als de sleutel een geheel getal is.
Arrays zijn op nul gebaseerd (zoals javascript), dus . [2] retourneert het derde element van de array.

De .[10:15] syntaxis kan worden gebruikt om een ​​subarray van een array of substring van een string terug te geven.
De array is geretourneerd door .[10:15] heeft een lengte van 5 en bevat de elementen uit index 10
(inclusief) tot index 15 (exclusief). Beide indexen kunnen negatief zijn (in dat geval telt het mee).
achterwaarts vanaf het einde van de array), of weggelaten (in welk geval het verwijst naar het begin of
einde van de reeks).

De . [2] syntaxis kan worden gebruikt om het element op de gegeven index terug te geven. Negatieve indices wel
toegestaan, waarbij -1 verwijst naar het laatste element, -2 verwijst naar het voorlaatste element,
enzovoort.

De .foo syntaxis werkt alleen voor eenvoudige sleutels, dat wil zeggen sleutels die allemaal uit alfanumerieke tekens bestaan.
.[ ] werkt met toetsen die speciale tekens bevatten, zoals dubbele punten en punten. Voor
voorbeeld .["foo::bar"] en .["foo.bar"] werk terwijl .foo::balk en .foo.bar zou niet.

De ? "operator" kan ook worden gebruikt met de slice-operator, zoals in .[10:15]?, die wordt uitgevoerd
waarden waarbij de invoer segmenteerbaar is.

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

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

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

.[]
Als u gebruik maken van de .[inhoudsopgave] syntaxis, maar laat de index geheel weg, deze zal terugkeren allen van de
elementen van een array. Rennen .[] met de invoer [1,2,3] zal de getallen als drie opleveren
afzonderlijke resultaten, in plaats van als een enkele array.

U kunt dit ook op een object gebruiken en het retourneert alle waarden van het object.

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

jq ´.[]´
[]
=>

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

.[]?
Like .[], maar er worden geen fouten uitgevoerd als . is geen array of object.

,
Als twee filters worden gescheiden door een komma, wordt de invoer in beide en daar ingevoerd
zullen meerdere uitgangen zijn: eerst alle uitgangen geproduceerd door de linkerexpressie, en
vervolgens alle uitvoer geproduceerd door rechts. Filteren bijvoorbeeld .foe, .Cafe, produceert
zowel de "foo"-velden als de "bar"-velden als afzonderlijke uitgangen.

jq ´.foo, .bar´
{"foo": 42, "bar": "iets anders", "baz": true}
=> 42, "iets anders"

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

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

|
De | operator combineert twee filters door de uitvoer(en) van het filter aan de linkerkant in te voeren
de ingang van degene aan de rechterkant. Het is vrijwel hetzelfde als de pijp van de Unix-shell, als
dat ben je gewend.

Als degene aan de linkerkant meerdere resultaten oplevert, wordt degene aan de rechterkant uitgevoerd
elk van deze resultaten. De uitdrukking dus .[] | .foo haalt het "foo"-veld van elk op
element van de invoerarray.

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

SOORTEN EN WAARDEN

jq ondersteunt dezelfde set datatypes als JSON: getallen, strings, booleans, arrays,
objecten (die in JSON-taal hashes zijn met alleen tekenreekssleutels) en "null".

Booleans, null, strings en getallen worden op dezelfde manier geschreven als in javascript. Net als
al het andere in jq, deze eenvoudige waarden nemen een invoer en produceren een uitvoer - 42 is een
geldige jq-expressie die invoer accepteert, negeert en in plaats daarvan 42 retourneert.

reeks bouw - []
Net als bij JSON, [] wordt gebruikt om arrays te construeren, zoals in [1,2,3]. De elementen van de arrays kunnen
een willekeurige jq-expressie zijn. Alle resultaten die door alle uitdrukkingen worden geproduceerd, worden verzameld
in één grote array. U kunt het gebruiken om een ​​array samen te stellen uit een bekend aantal waarden
(Zo in [.foo, .bar, .baz]) of om alle resultaten van een filter te "verzamelen" in een array (zoals
in [.items[].naam])

Zodra u de operator "," begrijpt, kunt u de array-syntaxis van jq op een andere manier bekijken
licht: de uitdrukking [1,2,3] gebruikt geen ingebouwde syntaxis voor door komma's gescheiden arrays,
maar past in plaats daarvan de [] operator (resultaten verzamelen) naar de uitdrukking 1,2,3 (welke
levert drie verschillende resultaten op).

Als je een filter hebt X dat levert vier resultaten op, en dan de uitdrukking [X] zal een produceren
enkel resultaat, een array van vier elementen.

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

Objecten - {}
Net als JSON, {} is voor het construeren van objecten (ook wel woordenboeken of hashes genoemd), zoals in: {"A": 42,
"B": 17}.

Als de toetsen "verstandig" zijn (alle alfabetische tekens), kunnen de aanhalingstekens worden weggelaten.
De waarde kan elke expressie zijn (hoewel u deze wellicht tussen haakjes moet plaatsen als het een expressie is).
ingewikkelde), die wordt toegepast op de invoer van de expressie {} (onthoud dat alle filters
hebben een in- en een uitgang).

{foo: .bar}

zal het JSON-object produceren {"foe": 42} als het JSON-object wordt gegeven {"balk":42, "baz":43}.
Hiermee kunt u bepaalde velden van een object selecteren: als de invoer een object is
"gebruiker", "titel", "id" en "inhoud" velden en u wilt alleen "gebruiker" en "titel", dat kan
schrijven

{gebruiker: .user, titel: .title}

Omdat dat zo gebruikelijk is, is er een sneltoetssyntaxis: {gebruiker, titel}.

Als een van de uitdrukkingen meerdere resultaten oplevert, zullen er meerdere woordenboeken zijn
geproduceerd. Als de invoer

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

dan de uitdrukking

{gebruiker, titel: .titles[]}

zal twee resultaten opleveren:

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

Als u haakjes rond de sleutel plaatst, betekent dit dat deze als een uitdrukking wordt geëvalueerd. Met de
dezelfde invoer als hierboven,

{(.gebruiker): .titels}

produceert

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

jq ´{gebruiker, titel: .titles[]}´
{"user"stedolan","titles":["JQ Primer", "Meer JQ"]}
=> {"user"stedolan", "title": "JQ Primer"}, {"user"stedolan", "title": "Meer JQ"}

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

GEBOUWD OPERATOREN EN FUNCTIES

Een jq-operator (bijvoorbeeld +) verschillende dingen doen, afhankelijk van het type van hun
argumenten (matrices, getallen, enz.). JQ voert echter nooit impliciete typeconversies uit. Als
je probeert een string aan een object toe te voegen, je krijgt een foutmelding en geen resultaat.

Toevoeging - +
De operator + neemt twee filters, past ze beide toe op dezelfde invoer en voegt de
resultaten samen. Wat 'toevoegen' betekent, hangt af van de betrokken typen:

· Aantallen worden toegevoegd via normale rekenkunde.

· arrays worden toegevoegd door te worden samengevoegd tot een grotere array.

· Strings worden toegevoegd door ze samen te voegen tot een grotere reeks.

· Objecten worden toegevoegd door samen te voegen, dat wil zeggen door alle sleutel-waardeparen van beide in te voegen
objecten tot één gecombineerd object. Als beide objecten een waarde voor hetzelfde bevatten
sleutel, het object aan de rechterkant van de + wint. (Gebruik voor recursieve samenvoeging de * exploitant.)

nul kan aan elke waarde worden toegevoegd en retourneert de andere waarde ongewijzigd.

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

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

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

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

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

Aftrekking - -
Naast het normale rekenkundige aftrekken van getallen, kan de - operator kan op arrays worden gebruikt
om alle voorkomende elementen van de tweede array uit de eerste array te verwijderen.

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

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

Vermenigvuldiging, afdeling, formulier - *, /, en %
Deze infix-operatoren gedragen zich zoals verwacht wanneer ze twee getallen krijgen. Delen door nul verhoogt
een foutmelding. x % y berekent x modulo y.

Het vermenigvuldigen van een string met een getal levert de aaneenschakeling van die string zoveel op
tijden. "x" * 0 produceert nul.

Als je een string door een andere deelt, wordt de eerste gesplitst en wordt de tweede als scheidingsteken gebruikt.

Door twee objecten te vermenigvuldigen, worden ze recursief samengevoegd: dit werkt als optellen, maar dan beide
objecten bevatten een waarde voor dezelfde sleutel, en de waarden zijn objecten, de twee zijn samengevoegd
met dezelfde 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}}´
nul
=> {"k": {"a": 0, "b": 2, "c": 3}}

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

lengte
De ingebouwde functie lengte krijgt de lengte van verschillende soorten waarden:

· De lengte van een snaar is het aantal Unicode-codepunten dat het bevat (wat zal zijn
hetzelfde als de JSON-gecodeerde lengte in bytes als het puur ASCII is).

· De lengte van een reeks is het aantal elementen.

· De lengte van een object is het aantal sleutelwaardeparen.

· De lengte van nul is nul.

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

sleutels, sleutels_ongesorteerd
De ingebouwde functie toetsenWanneer een object wordt gegeven, retourneert het zijn sleutels in een array.

De sleutels worden "alfabetisch" gesorteerd, op Unicode-codepuntvolgorde. Dit is geen bevel
dat is vooral logisch in een bepaalde taal, maar je kunt erop rekenen dat dit het geval is
hetzelfde voor twee objecten met dezelfde set sleutels, ongeacht de landinstelling.

. toetsen een array krijgt, retourneert het de geldige indices voor die array: de gehele getallen
van 0 tot lengte-1.

De sleutels_ongesorteerd functie is net als toetsen, maar als de invoer een object is, dan zijn de toetsen
worden niet gesorteerd, maar in plaats daarvan staan ​​de sleutels grofweg in de invoegvolgorde.

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

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

heeft (sleutel)
De ingebouwde functie heeft geeft terug of het invoerobject de gegeven sleutel of de invoer heeft
array heeft een element op de gegeven index.

heeft($sleutel) heeft hetzelfde effect als het controleren of $ sleutel is een lid van de geretourneerde array
by toetsenHoewel heeft zal sneller zijn.

jq ´kaart(has("foo"))´
[{"foe": 42}, {}]
=> [waar, onwaar]

jq ´kaart(heeft(2))´
[[0,1], ["a", "b", "c"]]
=> [onwaar, waar]

in
De ingebouwde functie in geeft terug dat de invoersleutel zich in het gegeven object of de invoerindex bevindt
komt overeen met een element in de gegeven array. Het is in wezen een omgekeerde versie van
heeft.

jq ´.[] | in({"foo": 42})´
["foe", "bar"]
=> waar, onwaar

jq ´kaart(in([0,1]))´
[2, 0]
=> [onwaar, waar]

pad(pad_expressie)
Voert arrayrepresentaties uit van de gegeven padexpressie in .. De uitgangen zijn arrays van
strings (sleutels in objecten0 en/of getallen (array-indices.

Padexpressies zijn jq-expressies zoals .a, maar ook .[]. Er zijn twee soorten paden
uitdrukkingen: uitdrukkingen die exact overeenkomen, en uitdrukkingen die dat niet kunnen. Bijvoorbeeld, .abc is een
exacte matchpad-expressie, while .a[].b is niet.

pad(exacte_pad_expressie) zal de array-representatie van de padexpressie produceren
ook al bestaat het niet in ., als . is nul of een array of een object.

pad(patroon) zal array-representaties produceren van de overeenkomende paden patroon indien de
er bestaan ​​paden in ..

Houd er rekening mee dat de padexpressies niet verschillen van normale expressies. De uitdrukking
pad(..|select(type=="boolean")) voert alle paden naar booleaanse waarden uit ., en alleen
die paden.

jq ´pad(.a[0].b)´
nul
=> ["a",0,"b"]

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

del(pad_expressie)
De ingebouwde functie del verwijdert een sleutel en de bijbehorende waarde van een object.

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

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

naar_inzendingen, van_inzendingen, met_vermeldingen
Deze functies converteren tussen een object en een array van sleutelwaardeparen. Als naar_vermeldingen
wordt een object doorgegeven, en vervolgens voor elk k: v invoer in de invoer, bevat de uitvoerarray
{"sleutel": k, "waarde": v}.

van_vermeldingen doet de tegenovergestelde conversie, en with_entries(foo) is een afkorting voor
naar_vermeldingen | kaart(foo) | van_vermeldingen, handig voor het uitvoeren van een bewerking op alle toetsen en
waarden van een object. van_vermeldingen accepteert sleutel, sleutel, naam, waarde en waarde als sleutels.

jq ´naar_entry´
{"a": 1, "b": 2}
=> [{"key":a", "waarde":1}, {"key":b", "waarde":2}]

jq ´uit_vermeldingen´
[{"key":a", "waarde":1}, {"key":b", "waarde":2}]
=> {"a": 1, "b": 2}

jq ´with_entries(.key |= "KEY_" + .)´
{"a": 1, "b": 2}
=> {"KEY_a": 1, "KEY_b": 2}

select(booleaanse_expressie)
De functie selecteer(foo) produceert zijn invoer onveranderd als foo retourneert waar voor die invoer,
en produceert verder geen output.

Het is handig voor het filteren van lijsten: [1,2,3] | kaart(selecteer(. >= 2)) zal je geven [2,3].

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

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

reeksen, voorwerpen, iterabelen, booleans, getallen, normalen, eindig, snaren, nullen, in maateenheden,
scalairen
Deze ingebouwde functies selecteren alleen invoer die arrays, objecten, iterables (arrays of
objecten), booleans, getallen, normale getallen, eindige getallen, strings, null, niet-null
waarden en niet-iterabelen, respectievelijk.

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

leeg
leeg levert geen resultaten op. Helemaal niet. Zelfs niet nul.

Het is af en toe nuttig. Je weet of je het nodig hebt :)

jq ´1, leeg, 2´
nul
=> 1, 2

jq ´[1,2,leeg,3]´
nul
=> [1,2,3]

fout(bericht)
Produceert een fout, net als .a toegepast op andere waarden dan null en objecten wel, maar
met het gegeven bericht als de foutwaarde.

$__loc__
Produceert een object met een "file"-sleutel en een "line"-sleutel, met de bestandsnaam en het regelnummer
WAAR $__loc__ voorkomt, als waarden.

jq ´try error("\($__loc__)") catch .´
nul
=> "{\"bestand\":\" \",\"lijn 1}"

kaart(x), map_values(x)
Voor elk filter x, kaart(x) zal dat filter uitvoeren voor elk element van de invoerarray, en
produceer de uitgangen een nieuwe array. kaart(.+1) zal elk element van een array verhogen
getallen.

Evenzo map_values(x) zal dat filter voor elk element uitvoeren, maar het zal een
object wanneer een object wordt gepasseerd.

kaart(x) is gelijk aan [.[] | x]. In feite is dit hoe het wordt gedefinieerd. Op dezelfde manier,
map_values(x) wordt gedefinieerd als .[] |= x.

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

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

paden, paden(node_filter), blad_paden
paden voert de paden uit naar alle elementen in zijn invoer (behalve dat het niet de
lege lijst, die . zelf).

paden(f) voert de paden uit naar alle waarden waarvoor f is waar. Dat is, paden(nummers)
voert de paden uit naar alle numerieke waarden.

blad_paden is een alias van paden (scalairen); blad_paden is deprecated en wordt binnen verwijderd
de volgende grote uitgave.

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

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

toevoegen
Het filter toevoegen neemt als invoer een array en produceert als uitvoer de elementen van de array
opgeteld. Dit kan opgeteld, aaneengeschakeld of samengevoegd betekenen, afhankelijk van het type
de elementen van de invoerarray - de regels zijn dezelfde als die voor de + operator
(hierboven omschreven).

Als de invoer een lege array is, toevoegen Retourneren nul.

jq ´toevoegen´
["abc"]
=> "abc"

jq ´toevoegen´
[1, 2, 3]
=> 6

jq ´toevoegen´
[]
=> nul

ieder, elke(voorwaarde), elke(generator; staat)
Het filter elke neemt als invoer een array van Booleaanse waarden en produceert waar als uitvoer if
elk van de elementen van de array is waar.

Als de invoer een lege array is, elke Retourneren vals.

De elke(voorwaarde) form past de gegeven voorwaarde toe op de elementen van de invoerarray.

De elke(generator; staat) formulier past de gegeven voorwaarde toe op alle uitgangen van de
gegeven generator.

jq 'ieder'
[waar onwaar]
=> waar

jq 'ieder'
[vals, vals]
=> onwaar

jq 'ieder'
[]
=> onwaar

alle, alles(voorwaarde), alles(generator; staat)
Het filter allen neemt als invoer een array van Booleaanse waarden en produceert waar als uitvoer if
alle elementen van de array zijn dat waar.

De alles(staat) form past de gegeven voorwaarde toe op de elementen van de invoerarray.

De alles(generator; staat) formulier past de gegeven voorwaarde toe op alle uitgangen van de
gegeven generator.

Als de invoer een lege array is, allen Retourneren waar.

jq 'allemaal'
[waar onwaar]
=> onwaar

jq 'allemaal'
[waar waar]
=> waar

jq 'allemaal'
[]
=> waar

[Vereist 1.5] plat maken, afvlakken (diepte)
Het filter vlakken neemt als invoer een array van geneste arrays en produceert daarin een platte array
waarin alle arrays binnen de originele array recursief zijn vervangen door hun waarden.
U kunt er een argument aan doorgeven om op te geven hoeveel niveaus van nesting u wilt afvlakken.

vlakken(2) is als vlakken, maar gaat slechts tot twee niveaus diep.

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

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

jq ´afvlakken´
[[]]
=> []

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

bereik (tot), bereik(van;tot) bereik(van;tot;door)
De reeks functie produceert een reeks getallen. bereik(4;10) produceert 6 nummers, van 4
(inclusief) tot 10 (exclusief). De nummers worden als afzonderlijke uitgangen geproduceerd. Gebruik
[bereik(4;10)] om een ​​bereik als array te krijgen.

De één-argumentvorm genereert getallen van 0 tot het opgegeven getal, met een toename van
1.

Het formulier met twee argumenten genereert getallen uit oppompen van naar tot met een verhoging van 1.

De drie argumentvorm genereert getallen oppompen van naar tot met een verhoging van by.

jq ´bereik(2;4)´
nul
=> 2, 3

jq ´[bereik(2;4)]´
nul
=> [2,3]

jq ´[reeks(4)]'
nul
=> [0,1,2,3]

jq ´[bereik(0;10;3)]´
nul
=> [0,3,6,9]

jq ´[bereik(0;10;-1)]´
nul
=> []

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

etage
De etage functie retourneert de bodem van zijn numerieke invoer.

jq ´vloer´
3.14159
=> 3

vierkante meter
De vierkante meter functie retourneert de vierkantswortel van zijn numerieke invoer.

jq ´sqrt´
9
=> 3

naar nummer
De naar nummer functie ontleedt zijn invoer als een getal. Het zal correct geformatteerd converteren
strings naar hun numerieke equivalent, laat getallen met rust en geef een fout op alle andere
invoer.

jq ´.[] | naar nummer'
[1, "1"]
=> 1, 1

touwtrekken
De touwtrekken functie drukt zijn invoer af als een string. Snaren blijven ongewijzigd, en zo
andere waarden zijn JSON-gecodeerd.

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

type dan:
De type dan: functie retourneert het type van zijn argument als een string, die er één is van null,
boolean, getal, string, array of object.

jq ´kaart(type)´
[0, false, [], {}, null, "hallo"]
=> ["getal", "boolean", "array", "object", "null", "string"]

eindeloos, Nee, is oneindig, isan, is eindig, is normaal
Sommige rekenkundige bewerkingen kunnen oneindigheden en "geen getallen" (NaN) waarden opleveren. De
is oneindig ingebouwde rendementen waar als de invoer oneindig is. De isan ingebouwde rendementen waar
als de invoer een NaN is. De oneindig ingebouwde retourneert een positieve oneindige waarde. De nan
ingebouwd retourneert een NaN. De is normaal ingebouwde retourneert waar als de invoer een normaal getal is.

Merk op dat deling door nul een fout oplevert.

Momenteel doen de meeste rekenkundige bewerkingen die op oneindigheden, NaN's en subnormalen werken dat niet
fouten opleveren.

jq ´.[] | (oneindig * .) < 0´
[-elf]
=> waar, onwaar

jq ´oneindig, nan | type
nul
=> "nummer", "nummer"

soort, sort_by(pad_expressie)
De sorteren functies sorteert de invoer, die een array moet zijn. Waarden worden gesorteerd in de
volgorde:

· nul

· vals

· waar

· cijfers

· tekenreeksen, in alfabetische volgorde (op Unicode-codepuntwaarde)

· arrays, in lexicale volgorde

· voorwerpen

De volgorde van objecten is een beetje ingewikkeld: eerst worden ze vergeleken door hun objecten te vergelijken
sets sleutels (als arrays in gesorteerde volgorde), en als hun sleutels gelijk zijn, zijn de waarden dat ook
sleutel voor sleutel vergeleken.

sorteren kan worden gebruikt om te sorteren op een bepaald veld van een object, of door een jq-filter toe te passen.

sort_by(foo) vergelijkt twee elementen door het resultaat ervan te vergelijken foo op elk element.

jq ´sorteren´
[8,3,nul,6]
=> [nul,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(pad_expressie)
groep_door(.foo) neemt als invoer een array, groepeert de elementen die hetzelfde hebben .foo veld-
in afzonderlijke arrays, en produceert al deze arrays als elementen van een grotere array,
gesorteerd op de waarde van de .foo veld.

Elke jq-expressie, niet alleen een veldtoegang, kan worden gebruikt in plaats van .foo. Het sorteren
De volgorde is hetzelfde als beschreven in de sorteren functie hierboven.

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(pad_exp), max_by(pad_exp)
Zoek het minimum- of maximumelement van de invoerarray.

De min_by(pad_exp) en max_by(pad_exp) Met functies kunt u een bepaald item opgeven
veld of eigenschap om te onderzoeken, bijv min_by(.foo) vindt het object met de kleinste foo
veld.

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

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

uniek, unique_by(pad_exp)
De unieke functie neemt als invoer een array en produceert een array van dezelfde elementen, in
gesorteerde volgorde, waarbij duplicaten zijn verwijderd.

De unique_by(pad_exp) functie behoudt slechts één element voor elke waarde verkregen door
het argument toepassen. Zie het als het maken van een array door uit elk element één element te halen
groep geproduceerd door groep.

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

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

jq ´uniek_door(lengte)´
["dik", "spek", "kitten", "cicade", "asperges"]
=> ["spek", "dik", "asperges"]

omkeren
Deze functie keert een array om.

jq ‘omgekeerd’
[1,2,3,4]
=> [4,3,2,1]

bevat(element)
Het filter bevat(b) zal waar opleveren als b volledig in de invoer zit. A
string B is opgenomen in een string A als B een substring is van A. Een array B is opgenomen in
een array A als alle elementen in B in een element in A voorkomen. Een object B is dat ook
opgenomen in object A als alle waarden in B zijn opgenomen in de waarde in A met de
dezelfde sleutel. Er wordt aangenomen dat alle andere typen in elkaar aanwezig zijn als ze gelijk zijn.

jq ´bevat("bar")´
"foobar"
=> waar

jq ´bevat(["baz", "bar"])´
["foobar", "foobaz", "blarp"]
=> waar

jq ´bevat(["bazzzz", "bar"])´
["foobar", "foobaz", "blarp"]
=> onwaar

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

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

index(en)
Voert een array uit met de indices in . WAAR s komt voor. De invoer kan een array zijn, in
welk geval als s een array is, zullen de indices die worden uitgevoerd de indexen zijn waarin alle elementen voorkomen .
overeenkomen met die van s.

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

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

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

index(en), index(en)
Voert de index uit van de eerste (index) of laatste (index) het voorkomen van s bij de invoer.

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

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

binnen
Het filter binnen(b) zal true opleveren als de invoer volledig binnen b ligt. Het
is in wezen een omgekeerde versie van bevat.

jq ´binnen("foobar")´
"bar"
=> waar

jq ´binnen(["foobar", "foobaz", "blarp"])´
["baz", "bar"]
=> waar

jq ´binnen(["foobar", "foobaz", "blarp"])´
["bazzzz", "bar"]
=> onwaar

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

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

begint met(str)
Uitgangen waar als . begint met het gegeven stringargument.

jq ´[.[]|startswith("foo")]´
["fo", "foe", "barfoe", "foobar", "barfoob"]
=> [onwaar, waar, onwaar, waar, onwaar]

eindigt met(str)
Uitgangen waar als . eindigt met het opgegeven stringargument.

jq ´[.[]|endswith("foo")]´
["foebar", "barfoe"]
=> [onwaar, waar]

combinaties, combinaties(n)
Voert alle combinaties van de elementen van de arrays in de invoerarray uit. Indien gegeven een
argument n, voert het alle combinaties uit van n herhalingen van de invoerarray.

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

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

ltrimstr(str)
Voert de invoer uit met de opgegeven voorvoegselreeks verwijderd, als deze ermee begint.

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

rtrimstr(str)
Voert de invoer uit met de opgegeven achtervoegselreeks verwijderd, als deze ermee eindigt.

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

exploderen
Converteert een invoerreeks naar een array van de codepuntnummers van de reeks.

jq ‘exploderen’
"foobar"
=> [102,111,111,98,97,114]

imploderen
Het omgekeerde van exploderen.

jq ‘imploderen’
[65, 66, 67]
=> "ABC"

spleet
Splitst een invoertekenreeks op het scheidingstekenargument.

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

toetreden(str)
Voegt de reeks elementen samen die als invoer zijn opgegeven, waarbij het argument als scheidingsteken wordt gebruikt. Het is de
inverse van spleet: dat wil zeggen, rennen split("foe") | sluit je aan("foe") over elke invoerreeks
retourneert de invoertekenreeks.

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

ascii_downcase, ascii_upcase
Zend een kopie uit van de invoerreeks waarin de alfabetische tekens (az en AZ) zijn geconverteerd
het opgegeven geval.

terwijl(cond; bijwerken)
De terwijl(cond; bijwerken) Met deze functie kunt u herhaaldelijk een update toepassen . tot cond
is fout.

Merk op dat terwijl(cond; bijwerken) wordt intern gedefinieerd als een recursieve jq-functie. Recursief
binnen bellen en zal geen extra geheugen verbruiken als -update levert er hoogstens één op
uitgang voor elke ingang. Zie geavanceerde onderwerpen hieronder.

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

tot(cond; De volgende)
De tot(cond; De volgende) Met de functie kunt u de uitdrukking herhaaldelijk toepassen volgende,
in eerste instantie om . vervolgens naar zijn eigen uitvoer, totdat cond is waar. Hier kan bijvoorbeeld gebruik van worden gemaakt
om een ​​factoriële functie te implementeren (zie hieronder).

Merk op dat tot(cond; De volgende) wordt intern gedefinieerd als een recursieve jq-functie. Recursief
binnen bellen tot() zal geen extra geheugen verbruiken als volgende levert er hoogstens één op
uitgang voor elke ingang. Zie geavanceerde onderwerpen hieronder.

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

recursief(f), recidivering, recursief(f; voorwaarde), recurse_down
De recursief (f) Met deze functie kunt u een recursieve structuur doorzoeken en extraheren
interessante gegevens van alle niveaus. Stel dat uw invoer een bestandssysteem vertegenwoordigt:

{"naam": "/", "kinderen": [
{"naam": "/ bin", "kinderen": [
{"naam": "/bin/ls", "kinderen": []},
{"naam": "/ Bin / sh", "kinderen": []}]},
{"naam": "/ Home", "kinderen": [
{"naam": "/home/stephen", "kinderen": [
{"naam": "/home/stephen/jq", "kinderen": []}]}]}]}

Stel nu dat u alle aanwezige bestandsnamen wilt extraheren. Je moet ophalen . Naam,
.kinderen[].naam, .kinderen[].kinderen[].naam, enzovoort. Je kunt dit doen met:

recurse(.kinderen[]) | .naam

Als je zonder ruzie wordt gebeld, herhaling is gelijk aan recursief(.[]?).

recursief (f) is identiek aan recursief(f; . != nul) en kan zonder zorgen worden gebruikt
recursie diepte.

recursief(f; staat) is een generator die begint met het uitzenden van . en zendt vervolgens op zijn beurt uit
.|f, .|f|f, .|f|f|f, ... zolang de berekende waarde aan de voorwaarde voldoet. Voor
Om bijvoorbeeld alle gehele getallen te genereren, althans in principe, zou men kunnen schrijven recursief(.+1;
WAAR).

Om legacy-redenen, recurse_down bestaat als een alias voor bellen herhaling zonder argumenten.
Er wordt rekening gehouden met deze alias deprecated en zal worden verwijderd in de volgende grote release.

De recursieve roept binnen herhaling zal geen extra geheugen verbruiken f produceert bij
bijna één enkele uitgang voor elke ingang.

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

jq ‘recursie’
{"a":0,"b":[1]}
=> {"a":0,"b":[1]}, 0, [1], 1

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

..
Afkorting voor herhaling zonder argumenten. Dit is bedoeld om op de XPath te lijken //
exploitant. Let daar op ..En werkt niet; gebruik ..|een in plaats van. In onderstaand voorbeeld gebruiken wij
..|.een? om alle waarden van objectsleutels "a" te vinden in elk object dat "hieronder" wordt gevonden ..

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

env
Voert een object uit dat de omgeving van jq vertegenwoordigt.

jq ´env.PAGER´
nul
=> "minder"

transponeren
Transponeer een mogelijk gekartelde matrix (een array van arrays). Rijen worden opgevuld met nullen, zodat de
resultaat is altijd rechthoekig.

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

bzoeken(x)
bsearch(x) voert een binaire zoekopdracht uit naar x in de invoerarray. Als de invoer is gesorteerd en
bevat x, dan zal bsearch(x) zijn index in de array teruggeven; anders, als de array dat is
gesorteerd, zal het retourneren (-1 - ix) waarbij ix een invoegpunt is, zodat de array dat zou doen
nog steeds gesorteerd worden na het invoegen van x bij ix. Als de array niet gesorteerd is, zal bsearch(x)
zal een geheel getal retourneren dat waarschijnlijk niet van belang is.

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

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

jq´bzoek(4) als $ix | als $ix < 0 dan .[-(1+$ix)] = 4 else . einde
[1,2,3]
=> [1,2,3,4]

Draad interpolatie - \(foe)
Binnen een string kunt u een expressie tussen haakjes plaatsen na een backslash. Wat het ook is
expressie-retouren worden in de string geïnterpoleerd.

jq ´"De invoer was \(.), wat één minder is dan \(.+1)"´
42
=> "De invoer was 42, wat één minder is dan 43"

Converteren naar Van JSON
De tojson en vanjson ingebouwde dumpwaarden als JSON-teksten of parseer JSON-teksten in
waarden, respectievelijk. De ingebouwde tojson verschilt van tostring doordat tostring retourneert
strings ongewijzigd, terwijl tojson strings codeert als JSON-strings.

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

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

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

Formaat strings en ontsnappen
De @foe syntaxis wordt gebruikt om tekenreeksen op te maken en te escapen, wat handig is voor het bouwen van URL’s,
documenten in een taal zoals HTML of XML, enzovoort. @foe kan als filter gebruikt worden
zijn eigen, de mogelijke ontsnappingen zijn:

@tekst:

oproepen touwtrekken, zie die functie voor details.

@json:

Serialiseert de invoer als JSON.

@html:

Past HTML/XML-escaping toe door de tekens in kaart te brengen <>&´" aan hun entiteit
equivalenten <, >, &, ', ".

@uri:

Past procentcodering toe, door alle gereserveerde URI-tekens toe te wijzen aan a %XX volgorde.

@csv:

De invoer moet een array zijn en wordt weergegeven als CSV met dubbele aanhalingstekens voor
tekenreeksen en aanhalingstekens die door herhaling zijn ontsnapt.

@tsv:

De invoer moet een array zijn en wordt weergegeven als TSV (door tabs gescheiden waarden). Elk
invoerarray wordt als één regel afgedrukt. Velden worden gescheiden door één tabblad
(ascii 0x09). Invoertekens line-feed (ascii 0x0a), Carriage Return (ascii
0x0d), tabblad (ascii 0x09) en backslash (ascii 0x5c) wordt uitgevoerd als escape
sequenties \n, \r, \t, \\ respectievelijk.

@sh:

De invoer is voorzien van escape-codes, geschikt voor gebruik op een opdrachtregel voor een POSIX-shell. Als de
invoer is een array, de uitvoer is een reeks door spaties gescheiden tekenreeksen.

@basis64:

De invoer wordt geconverteerd naar base64 zoals gespecificeerd door RFC 4648.

Deze syntaxis kan op een handige manier worden gecombineerd met stringinterpolatie. Je kunt een volgen
@foe token met een letterlijke tekenreeks. De inhoud van de letterlijke tekenreeks zal niet ontsnapt zijn.
Alle interpolaties die binnen die letterlijke tekenreeks worden gemaakt, worden echter geëscaped. Bijvoorbeeld,

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

zal de volgende uitvoer voor de invoer produceren {"search": wat is jq?"}:

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

Houd er rekening mee dat de schuine strepen, het vraagteken, enz. in de URL geen escapetekens bevatten, omdat ze er deel van uitmaakten
van de tekenreeks letterlijk.

jq ´@html´
"Dit werkt als x < y"
=> "Dit werkt als x < y"

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

Data
jq biedt een aantal basisfunctionaliteiten voor datumverwerking, met enkele hoog- en laagniveaus
inbouw. In alle gevallen hebben deze ingebouwde functies uitsluitend betrekking op de tijd in UTC.

De vanafdatumiso8601 ingebouwde parseert datetimes in het ISO 8601-formaat tot een aantal seconden
sinds het Unix-tijdperk (1970-01-01T00:00:00Z). De vandaagiso8601 ingebouwd doet het omgekeerde.

De van datum ingebouwde parseert datetime-tekenreeksen. Momenteel van datum ondersteunt alleen ISO 8601
datetime strings, maar in de toekomst zal het proberen datetime strings in meer te parseren
formaten.

De daten ingebouwde is een alias voor vandaagiso8601.

De nu ingebouwde geeft de huidige tijd weer, in seconden sinds het Unix-tijdperk.

Er zijn ook jq-interfaces op laag niveau voor de tijdfuncties van de C-bibliotheek beschikbaar: strptijd,
tijd, mktijd en gmtijd. Raadpleeg de documentatie van uw hostbesturingssysteem voor de
formaattekenreeksen gebruikt door strptijd en tijd. Let op: deze zijn niet noodzakelijkerwijs stabiel
interfaces in jq, vooral wat betreft hun lokalisatiefunctionaliteit.

De gmtijd ingebouwde verbruikt een aantal seconden sinds het Unix-tijdperk en geeft een "broken
down time" representatie van tijd als een reeks getallen die (in deze volgorde): de
jaar, de maand (op nul gebaseerd), de dag van de maand, het uur van de dag, de minuut van de
uur, de seconde van de minuut, de dag van de week en de dag van het jaar - allemaal
op één basis, tenzij anders vermeld.

De mktijd ingebouwde verbruikt "uitgesplitste tijd" representaties van tijduitvoer door gmtijd
en strptijd.

De strptijd(fmt) ingebouwde parseert invoertekenreeksen die overeenkomen met de fmt argument. De uitvoer is binnen
de representatie van de "uitgesplitste tijd" die wordt verbruikt door gmtijd en uitvoer door mktijd.

De strftijd(fmt) ingebouwde formaten een keer met het opgegeven formaat.

De formaattekenreeksen voor strptijd en tijd worden beschreven in een typische C-bibliotheek
documentatie. De notatiereeks voor ISO 8601 datetime is "%Y-%m-%dT%H:%M:%SZ".

jq ondersteunt mogelijk niet alle of een deel van deze datumfunctionaliteit op sommige systemen.

jq ´vandatum´
"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

VOORWAARDEN EN VERGELIJKINGEN

==, !=
De uitdrukking ´a == b´ zal ´waar´ opleveren als het resultaat van a en b gelijk is (dat wil zeggen:
als ze equivalente JSON-documenten vertegenwoordigen) en anders 'false'. In het bijzonder snaren
worden nooit als gelijk aan getallen beschouwd. Als je van Javascript komt, is jq's == zoiets
Javascript´s === - waarden alleen als gelijk beschouwen als ze hetzelfde type hebben
dezelfde waarde.

!= is "niet gelijk", en ´a != b´ retourneert de tegenovergestelde waarde van ´a == b´

jq ´.[] == 1´
[1, 1.0, "1", "banaan"]
=> waar, waar, onwaar, onwaar

als dan anders
if A harte B anders C einde zal hetzelfde doen als B if A produceert een andere waarde dan false or
null, maar gedraagt ​​zich hetzelfde als C anders.

Controleren op false of null is een eenvoudiger begrip van 'waarheid' dan in Javascript
of Python, maar het betekent dat je soms explicieter moet zijn over de voorwaarde
je wilt: je kunt niet testen of bijvoorbeeld een string leeg is met if . Naam harte A anders B einde,
je hebt iets meer nodig zoals if (.naam | lengte) > 0 harte A anders B einde gebruiken.

Als voorwaarde A meerdere resultaten oplevert, wordt deze als "waar" beschouwd als een van deze resultaten aanwezig is
resultaten zijn niet onwaar of nul. Als het nulresultaten oplevert, wordt het als onwaar beschouwd.

Er kunnen meer cases worden toegevoegd aan een if-gebruik elif A harte B syntaxis.

jq ´als . == 0 dan

"nul" elif. == 1 dan "één" anders "veel" end´ 2 => "veel"

>, >=, <=, <
De vergelijkingsoperatoren >, >=, <=, < geven of hun linkerargument groter is dan:
groter dan of gelijk aan, kleiner dan of gelijk aan of kleiner dan hun juiste argument
(respectievelijk).

De volgorde is hetzelfde als beschreven voor sorteren, bovenstaande.

jq ´. < 5´
2
=> waar

en/of/niet
jq ondersteunt de normale Booleaanse operatoren en/of/niet. Ze hebben dezelfde waarheidsnorm
alsof uitdrukkingen - false en null als "valse waarden" worden beschouwd, en al het andere is a
"echte waarde".

Als een operand van een van deze operatoren meerdere resultaten oplevert, zal de operator zelf
zal voor elke invoer een resultaat opleveren.

niet is in feite een ingebouwde functie in plaats van een operator, dus wordt het als een filter aangeroepen
welke dingen kunnen worden doorgesluisd in plaats van met een speciale syntaxis, zoals in .foo en .Cafe | niet.

Deze drie produceren alleen de waarden "waar" en "onwaar", en zijn dus alleen bruikbaar voor echt
Booleaanse bewerkingen, in plaats van het gebruikelijke Perl/Python/Ruby-idioom van
"value_that_may_be_null of standaard". Als u deze vorm van 'of' wilt gebruiken, kiest u tussen
twee waarden in plaats van een voorwaarde te evalueren, zie de operator "//" hieronder.

jq ´42 en "een string"´
nul
=> waar

jq ´(waar, onwaar) of onwaar´
nul
=> waar, onwaar

jq ´(waar, waar) en (waar, onwaar)´
nul
=> waar, onwaar, waar, onwaar

jq ´[waar, onwaar | niet
nul
=> [onwaar, waar]

Alternatief operator - //
Een filter van het formulier a // b levert dezelfde resultaten op als a, als a levert andere resultaten op
neem contact vals en nul. Anders, a // b levert dezelfde resultaten op als b.

Dit is handig voor het opgeven van standaardinstellingen: .foo // 1 zal evalueren naar 1 als er geen is .foo
element in de invoer. Het is vergelijkbaar met hoe or wordt soms gebruikt in Python (jq´s or operator
is gereserveerd voor strikt Booleaanse bewerkingen).

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

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

proberen te vangen
Fouten kunnen worden opgevangen door gebruik te maken van proberen EXP vangst EXP. De eerste expressie wordt uitgevoerd, en if
het mislukt, waarna de tweede wordt uitgevoerd met de foutmelding. De uitvoer van de handler, if
any, wordt uitgevoerd alsof het de uitvoer is van de uitdrukking die moet worden geprobeerd.

De proberen EXP vorm gebruikt leeg als uitzonderingshandler.

jq ´probeer .a catch ". is geen object"´
waar
=> ". is geen object"

jq ´[.[]|probeer .a]´
[{}, waar, {"a":1}]
=> [nul, 1]

jq ´try error("een uitzondering") catch .´
waar
=> "een uitzondering"

Breaking uit of onder controle te houden structuren
Een handig gebruik van try/catch is om uit de hand gelopen structuren te doorbreken, zoals verminderen, foreach,
en, Enzovoort.

Bijvoorbeeld:

# Herhaal een uitdrukking totdat deze "break" opwerpt als een
# fout, stop dan met herhalen zonder de fout opnieuw te verhogen.
# Maar als de gevonden fout niet "break" is, verhoog hem dan opnieuw.
probeer repeat(exp) catch .=="break" en leeg else error;

jq heeft een syntaxis voor benoemde lexicale labels om te "breken" of "te gaan (terug) naar":

label $uit | ... uitbreken ...

De breken $labelnaam expressie zal ervoor zorgen dat het programma zich gedraagt ​​alsof het dichtstbijzijnde
(naar links) label $labelnaam geproduceerd leeg.

De relatie tussen de breken en overeenkomstig label is lexicaal: het label moet dat zijn
"zichtbaar" vanaf de pauze.

Om uit een te breken verminderen, bijvoorbeeld:

label $uit | reduce .[] als $item (null; if .==false, break $out else ... end)

Het volgende jq-programma produceert een syntaxisfout:

$ uitbreken

omdat er geen etiket is $uit is zichtbaar.

? operator
De ? operator, gebruikt als EXP?, is een afkorting voor proberen EXP.

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

REGULAR UITDRUKKINGEN (PCRE)

jq gebruikt de reguliere expressiebibliotheek van Oniguruma, net als php, ruby, TextMate, Sublime Text,
enz., dus de beschrijving hier zal zich concentreren op jq-specificaties.

De jq regex-filters zijn zo gedefinieerd dat ze kunnen worden gebruikt met een van deze patronen:

STREEK | FILTER( REGEX )
STREEK | FILTER( REGEX; VLAGGEN )
STREEK | FILTER( [REGEX] )
STREEK | FILTER( [REGEX, VLAGGEN] )

waarbij: * STRING, REGEX en FLAGS jq-strings zijn en onderworpen zijn aan jq-stringinterpolatie; *
REGEX moet, na stringinterpolatie, een geldige PCRE-regex zijn; * FILTER is er een van proef,
matchof vangen, zoals hieronder beschreven.

FLAGS is een tekenreeks die bestaat uit een of meer van de ondersteunde vlaggen:

· g - Globaal zoeken (vind alle overeenkomsten, niet alleen de eerste)

· i - Hoofdletterongevoelig zoeken

· m - Multi-lijnmodus ('.' komt overeen met nieuwe regels)

· n - Negeer lege overeenkomsten

· p - Zowel de s- als de m-modus zijn ingeschakeld

· s - Enkele lijnmodus (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - Vind de langst mogelijke overeenkomsten

· x - Uitgebreid regex-formaat (negeer witruimte en opmerkingen)

Om de witruimte in een x-patroon te matchen, gebruikt u een escape zoals \s, bijvoorbeeld

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

Merk op dat bepaalde vlaggen ook binnen REGEX kunnen worden gespecificeerd, bijvoorbeeld

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

evalueert tot: waar, waar, onwaar, onwaar.

[Vereist 1.5] testen(val), testen(regex; vlaggen)
Like match, maar retourneert alleen geen matchobjecten waar or vals voor het wel of niet
regex komt overeen met de invoer.

jq ´test("foo")´
"foe"
=> waar

jq ´.[] | test("abc # spaties worden genegeerd"; "ix")´
["xabcd", "ABC"]
=> waar, waar

[Vereist 1.5] overeenkomen(waarde), overeenkomen(regex; vlaggen)
match voert een object uit voor elke gevonden overeenkomst. Wedstrijden hebben de volgende velden:

· compenseren - offset in UTF-8-codepunten vanaf het begin van de invoer

· lengte - lengte in UTF-8 codepunten van de wedstrijd

· snaar - de string waarmee het overeenkwam

· captures - een reeks objecten die vastgelegde groepen vertegenwoordigen.

Het vastleggen van groepsobjecten heeft de volgende velden:

· compenseren - offset in UTF-8-codepunten vanaf het begin van de invoer

· lengte - lengte in UTF-8-codepunten van deze opnamegroep

· snaar - de string die is vastgelegd

· naam - de naam van de vastleggende groep (of nul als het geen naam had)

Het vastleggen van groepen die nergens aan voldoen, levert een offset van -1 op

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

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

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

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

jq ´[ match("."; "g")] | lengte
"abc"
=> 3

[Vereist 1.5] vangen(val), vastleggen(regex; vlaggen)
Verzamelt de benoemde captures in een JSON-object, met de naam van elke capture als sleutel,
en de overeenkomende tekenreeks als de overeenkomstige waarde.

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

[Vereist 1.5] scannen(regex), scannen(regex; vlaggen)
Zend een stroom uit van de niet-overlappende subtekenreeksen van de invoer die overeenkomen met de regex in
overeenstemming met de vlaggen, indien die zijn gespecificeerd. Als er geen match is, is de stream dat wel
leeg. Gebruik het idioom om alle overeenkomsten voor elke invoerreeks vast te leggen [ uitdrukken ], bijv [
scannen(regex) ].

splitsen(regex; vlaggen)
Voor achterwaartse compatibiliteit, spleet splitst op een string, niet op een regex.

[Vereist 1.5] splitsingen (regex), splitsingen(regex; vlaggen)
Deze geven dezelfde resultaten als hun spleet tegenhangers, maar als een stroom in plaats van een
matrix.

[Vereist 1.5] sub(regex; touwtrekken) sub(regex; snaar; vlaggen)
Zend de tekenreeks uit die is verkregen door de eerste overeenkomst van regex in de invoertekenreeks te vervangen door
touwtrekken, na interpolatie. touwtrekken moet een jq-tekenreeks zijn en mag verwijzingen bevatten
naar benoemde opnames. De benoemde opnames worden in feite gepresenteerd als een JSON-object (zoals
gebouwd door vangen) Om touwtrekken, dus een verwijzing naar een vastgelegde variabele met de naam "x" zou dat wel doen
de vorm aannemen: "(.x)".

[Vereist 1.5] gsub(regex; snaar), gsub(regex; snaar; vlaggen)
gsub is als beneden maar alle niet-overlappende exemplaren van de regex worden vervangen door de
tekenreeks, na interpolatie.

ADVANCED KENMERKEN

Variabelen zijn in de meeste programmeertalen een absolute noodzaak, maar ze zijn gedegradeerd
naar een "geavanceerde functie" in jq.

In de meeste talen zijn variabelen het enige middel om gegevens door te geven. Als je berekent a
waarde, en u wilt deze meerdere keren gebruiken, dan moet u deze in een variabele opslaan. Naar
een waarde doorgeven aan een ander deel van het programma, daarvoor heb je dat deel van het programma nodig
definieer een variabele (als een functieparameter, objectlid of wat dan ook) waarin u deze wilt plaatsen
de data.

Het is ook mogelijk om functies in jq te definiëren, hoewel dit een kenmerk is waarvan de grootste
gebruik is het definiëren van de standaardbibliotheek van jq (veel jq-functies zoals kaart en vinden zijn in feite
geschreven in jq).

jq heeft reductie-operatoren, die erg krachtig maar een beetje lastig zijn. Nogmaals, dit zijn
meestal intern gebruikt, om enkele nuttige stukjes van de standaardbibliotheek van jq te definiëren.

Het is in eerste instantie misschien niet voor de hand liggend, maar jq draait helemaal om generatoren (ja, zoals vaak te vinden in
andere talen). Er zijn enkele hulpprogramma's beschikbaar om te helpen bij het omgaan met generatoren.

Enige minimale I/O-ondersteuning (naast het lezen van JSON van standaardinvoer en het schrijven van JSON naar
standaarduitvoer) beschikbaar is.

Tenslotte is er een module/bibliotheeksysteem.

Variabelen
In jq hebben alle filters een ingang en een uitgang, dus handmatig loodgieten is niet nodig
een waarde doorgeven van het ene deel van een programma naar het volgende. Veel uitdrukkingen bijvoorbeeld a + b,
geven hun invoer door aan twee verschillende subexpressies (hier a en b zijn beide hetzelfde doorgegeven
input), dus variabelen zijn meestal niet nodig om een ​​waarde twee keer te gebruiken.

Voor het berekenen van de gemiddelde waarde van een reeks getallen zijn er bijvoorbeeld een paar nodig
variabelen in de meeste talen - minstens één om de array vast te houden, misschien één voor elk element
of voor een lusteller. In jq is het eenvoudig toevoegen / lengte - de toevoegen uitdrukking wordt gegeven
array en produceert de som ervan, en de lengte expressie krijgt de array en produceert de array
lengte.

Er is dus over het algemeen een schonere manier om de meeste problemen in jq op te lossen dan het definiëren van variabelen.
Toch maken ze soms dingen gemakkelijker, dus met jq kun je variabelen definiëren met behulp van
uitdrukking as $variabele. Alle namen van variabelen beginnen met $. Hier is een iets lelijkere versie
van het array-gemiddelde voorbeeld:

lengte als $array_length | toevoegen / $array_length

We hebben een ingewikkelder probleem nodig om een ​​situatie te vinden waarin variabelen daadwerkelijk worden gebruikt
maakt ons leven gemakkelijker.

Stel dat we een reeks blogposts hebben, met de velden 'auteur' en 'titel', en nog een
object dat wordt gebruikt om gebruikersnamen van auteurs aan echte namen toe te wijzen. Onze inbreng ziet er als volgt uit:

{"posts": [{"title": "Eerste psot", "author": "anon"},
{"title": "Een goed geschreven artikel", "author": "person1"}],
"realnames": {"anon": "Anonieme lafaard",
"person1": "Persoon McPherson"}}

We willen de berichten produceren waarbij het auteurveld een echte naam bevat, zoals in:

{"title": "Eerste psot", "author": "Anonieme lafaard"}
{"title": "Een goed geschreven artikel", "author": "Persoon McPherson"}

We gebruiken een variabele, $names, om het object realnames op te slaan, zodat we er later naar kunnen verwijzen
bij het opzoeken van gebruikersnamen van auteurs:

.echtenamen als $names | .berichten[] | {titel, auteur: $names[.author]}

De uitdrukking exp as $x | ... betekent: voor elke waarde van expressie exp, voer de rest uit
de pijplijn met de volledige oorspronkelijke invoer, en met $x op die waarde ingesteld. Dus as
functioneert als een soort foreach-lus.

Zoals {foe} is een handige manier van schrijven {foe: .foo}, dus {$foo} is een handige manier van schrijven
{foo:$foo}.

Er kunnen meerdere variabelen worden gedeclareerd met behulp van een enkele as expressie door een patroon aan te bieden
die overeenkomt met de structuur van de invoer (dit staat bekend als "destructurering"):

. als {echte namen: $names, berichten: [$first, $second]} | ...

De variabeledeclaraties in arraypatronen (bijv. . as [$eerst, $seconde]) binden aan de
elementen van de array vanaf het element met index nul naar boven, in volgorde. Wanneer er geen
waarde bij de index voor een arraypatroonelement, nul is gebonden aan die variabele.

Variabelen vallen onder de rest van de expressie die ze definieert, dus

.echtenamen als $names | (.posts[] | {titel, auteur: $names[.author]})

zal werken, maar

(.echtenamen als $names | .posts[]) | {titel, auteur: $names[.author]}

zal niet.

Voor programmeertaaltheoretici is het juister om te zeggen dat jq-variabelen dat wel zijn
lexicaal-scoped bindingen. In het bijzonder is er geen manier om de waarde van een binding te veranderen;
je kunt alleen een nieuwe binding opzetten met dezelfde naam, maar die waar niet zichtbaar is
de oude was.

jq ´.bar als $x | .foo | . + $x´
{"foe":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}

Het definiëren Functies
U kunt een filter een naam geven met de syntaxis "def":

def verhoging: . + 1;

Vanaf toen, aanwas is bruikbaar als filter, net als een ingebouwde functie (in feite is dit
is hoe sommige van de ingebouwde functies worden gedefinieerd). Een functie kan argumenten aannemen:

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

Argumenten worden doorgegeven als filters, niet als waarden. Er kan naar hetzelfde argument worden verwezen
meerdere keren met verschillende ingangen (hier f wordt uitgevoerd voor elk element van de invoerarray).
Argumenten voor een functie werken meer als callbacks dan als waardeargumenten. Dit is
belangrijk om te begrijpen. Overwegen:

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

Het resultaat is 20 omdat f is .*2, en tijdens de eerste aanroep van f . zal 5 zijn,
en de tweede keer is het 10 (5 * 2), dus het resultaat is 20. Functieargumenten
zijn filters, en filters verwachten invoer wanneer ze worden aangeroepen.

Als u het waarde-argumentgedrag wilt voor het definiëren van eenvoudige functies, kunt u gewoon a gebruiken
variabele:

def optelwaarde(f): f als $f | kaart(. + $f);

Of gebruik de verkorte versie:

def optelwaarde($f): ...;

Met beide definities toegevoegde waarde(.foo) zal de huidige invoer toevoegen .foo veld voor elk
element van de array.

Meerdere definities met dezelfde functienaam zijn toegestaan. Elke herdefinitie vervangt
de vorige voor hetzelfde aantal functieargumenten, maar alleen voor verwijzingen uit
functies (of hoofdprogramma) na de herdefinitie.

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

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

Verminderen
De verminderen Met de syntaxis in jq kunt u alle resultaten van een expressie combineren met
door ze samen te voegen tot één antwoord. Als voorbeeld slaan we over [3,2,1] deze
uitdrukking:

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

Voor elk resultaat dat .[] produceert, . + $artikel wordt uitgevoerd om een ​​lopend totaal op te bouwen,
beginnend bij 0. In dit voorbeeld is .[] levert de resultaten 3, 2 en 1 op, dus het effect is
vergelijkbaar met het uitvoeren van zoiets als dit:

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

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

limiet(n; exp)
De begrenzing functie extraheert tot n uitgangen van exp.

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

eerste(expr), laatste(expr), nde(n; expr)
De eerste(expr) en laatste(expr) functies halen de eerste en laatste waarden eruit uitdrukken,
respectievelijk.

De nde(n; expr) functie extraheert de n-de waarde die wordt uitgevoerd door uitdrukken. Dit kan worden gedefinieerd als
def nde(n; uitd): laatste(limiet(n + 1; uitdr));. Merk op dat nde(n; expr) ondersteunt niet
negatieve waarden van n.

jq ´[eerste(bereik(.)), laatste(bereik(.)), nth(./2; bereik(.))]´
10
=> [0,9,5]

eerste, laatste, nde(n)
De eerste en laatste functies extraheren de eerste en laatste waarden uit elke array op ..

De nde(n) functie extraheert de n-de waarde van elke array op ..

jq ´[bereik(.)]|[eerste, laatste, zoveelste(5)]'
10
=> [0,9,5]

foreach
De foreach syntaxis is vergelijkbaar met verminderen, maar bedoeld om de bouw mogelijk te maken van begrenzing
en reductiemiddelen die tussenresultaten opleveren (zie voorbeeld).

Het formulier is foreach EXP as $var (IN HET; UPDATE; EXTRACT). Zoals verminderen, INIT wordt geëvalueerd
één keer om een ​​statuswaarde te produceren, daarna elke uitvoer van EXP is gebonden aan $var, UPDATE is
geëvalueerd voor elke output van EXP met de huidige staat en met $var zichtbaar. Elke waarde
uitgevoerd door UPDATE vervangt de vorige toestand. Eindelijk, EXTRACT wordt voor elke nieuwe beoordeeld
staat om een ​​uitvoer van te extraheren foreach.

Dit is meestal alleen nuttig voor de constructie verminderen- En begrenzing-achtige functies. Maar het is
veel algemener, omdat gedeeltelijke reducties mogelijk zijn (zie het onderstaande voorbeeld).

jq ´[foreach .[] as $item ([[],[]]; if $item == null then [[],.[0]] else [(.[0] + [$item]),[ ]] einde; als $item == null dan .[1] anders leeg einde)]´
[1,2,3,4,nul,"a", "b",nul]
=> [[1,2,3,4],["a", "b"]]

Recursie
Zoals hierboven beschreven, herhaling gebruikt recursie, en elke jq-functie kan recursief zijn. De
en ingebouwde is ook geïmplementeerd in termen van recursie.

Tail-oproepen worden geoptimaliseerd wanneer de expressie links van de recursieve oproepuitvoer wordt weergegeven
zijn laatste waarde. In de praktijk betekent dit dat de uitdrukking aan de linkerkant recursief is
oproep mag niet meer dan één uitvoer voor elke invoer opleveren.

Bijvoorbeeld:

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

def while(cond; update):
def _while:
if cond then ., (update | _while) else leeg einde;
_terwijl;

herhaal zeker (exp):
def _herhalen:
exp, _herhalen;
_herhalen;

Generatoren en iteratoren
Sommige jq-operatoren en -functies zijn eigenlijk generatoren in de zin dat ze nul,
één of meer waarden voor elke invoer, precies zoals je zou verwachten bij andere programmering
talen met generatoren. Bijvoorbeeld, .[] genereert alle waarden in zijn invoer
(dit moet een array of een object zijn), bereik(0; 10) genereert de gehele getallen tussen 0 en
10, enzovoort.

Zelfs de komma-operator is een generator, die eerst de waarden genereert die door de
expressie links van de komma, waarna voor elk daarvan de waarden worden gegenereerd door de
uitdrukking rechts van de komma.

De leeg ingebouwd is de generator die nul output produceert. De leeg ingebouwde
gaat terug naar de voorgaande generatorexpressie.

Alle jq-functies kunnen generatoren zijn, gewoon door ingebouwde generatoren te gebruiken. Het is ook mogelijk
om nieuwe generatoren te definiëren met alleen recursie en de komma-operator. Als het recursief is
call(s) is(zijn) "in staartpositie", dan zal de generator efficiënt zijn. In het voorbeeld
onder de recursieve oproep door _bereik zichzelf bevindt zich in de staartpositie. Het voorbeeld laat zien
drie geavanceerde onderwerpen: staartrecursie, generatorconstructie en subfuncties.

jq ´def range(init; upto; by): def _range: if (by > 0 en . < upto) of (by < 0 en . > upto) then ., ((.+by)|_range) else . einde; if by == 0 then init else init|_range end | select((door > 0 en . < tot) of (door < 0 en . > tot)); bereik(0; 10; 3)´
nul
=> 0, 3, 6, 9

jq ´def while(cond; update): def _while: if cond then ., (update | _while) else leeg einde; _terwijl; [terwijl(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

WISKUNDE

jq biedt momenteel alleen ondersteuning voor drijvende-kommagetallen met dubbele precisie (754-bit) van IEEE64.

Naast eenvoudige rekenkundige operatoren zoals +, jq heeft ook de meeste standaard wiskundige functies
uit de C-wiskundebibliotheek. C wiskundige functies waaraan één enkel invoerargument moet voldoen (bijv. zonde())
zijn beschikbaar als jq-functies met nulargumenten. C wiskundige functies waarvoor twee invoer nodig is
argumenten (bijv. pow ()) zijn beschikbaar als jq-functies met twee argumenten die negeren ..

De beschikbaarheid van standaard wiskundige functies is afhankelijk van de beschikbaarheid van de overeenkomstige
wiskundige functies in uw besturingssysteem en C-wiskundebibliotheek. Niet beschikbare wiskundige functies
zal worden gedefinieerd, maar zal een fout opleveren.

I / O

Op dit moment heeft jq minimale ondersteuning voor I/O, meestal in de vorm van controle over wanneer
ingangen worden gelezen. Hiervoor zijn twee ingebouwde functies voorzien, invoer en ingangen, dat gelezen
uit dezelfde bronnen (bijv. stdin, bestanden genoemd op de opdrachtregel) als jq zelf. Deze
twee ingebouwde functies en jq's eigen leesacties kunnen met elkaar worden verweven.

Eén ingebouwde biedt minimale uitvoermogelijkheden, debug. (Bedenk dat een jq-programma
uitvoerwaarden worden altijd uitgevoerd als JSON-teksten stdout.) De debug ingebouwd kan hebben
applicatiespecifiek gedrag, zoals voor uitvoerbare bestanden die de libjq C API gebruiken maar dat niet zijn
het jq-uitvoerbare bestand zelf.

invoer
Voert één nieuwe invoer uit.

ingangen
Voert alle resterende ingangen één voor één uit.

Dit is vooral nuttig voor reducties op de input van een programma.

debug
Veroorzaakt een foutopsporingsbericht op basis van de te produceren invoerwaarde. Het uitvoerbare jq-bestand wordt verpakt
de invoerwaarde met ["DEBUGGEN:", ] en drukt dat en een nieuwe regel af op stderr,
compact. Dit kan in de toekomst veranderen.

invoer_bestandsnaam
Retourneert de naam van het bestand waarvan de invoer momenteel wordt gefilterd. Merk op dat dit zal gebeuren
werkt niet goed tenzij jq in een UTF-8-landinstelling draait.

input_line_nummer
Geeft het regelnummer terug van de invoer die momenteel wordt gefilterd.

STREAMING

Met de --stroom optie jq kan invoerteksten op streaming-wijze parseren, waardoor jq
programma's om grote JSON-teksten onmiddellijk te verwerken in plaats van na het parseren
voltooit. Als u een enkele JSON-tekst van 1 GB groot heeft, kunt u deze streamen
om het veel sneller te verwerken.

Streaming is echter niet eenvoudig om mee om te gaan, zoals het jq-programma zal hebben [ ,
] (en een paar andere vormen) als invoer.

Er zijn verschillende ingebouwde functies om het verwerken van streams eenvoudiger te maken.

In de onderstaande voorbeelden wordt de gestreamde vorm van gebruikt [0,[1]]Dit is
[[0],0],[[1,0],1],[[1,0]],[[1]].

Streamingformulieren omvatten [ , ] (om een ​​scalaire waarde aan te geven, een lege array,
of leeg object), en [ ] (om het einde van een array of object aan te geven). Toekomst
versies van jq draaien met --stroom en -volg kan aanvullende formulieren uitvoeren, zoals ["fout
bericht"] wanneer een invoertekst niet kan worden geparseerd.

truncate_stream(stream_expressie)
Verbruikt een getal als invoer en kapt het overeenkomstige aantal padelementen af
links van de uitgangen van de gegeven streaming-expressie.

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

fromstream(stream_expressie)
Voert waarden uit die overeenkomen met de uitvoer van de stroomexpressie.

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

streamen
De streamen ingebouwde voert de gestreamde vorm van zijn invoer uit.

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

OPDRACHT

Toewijzing werkt in jq iets anders dan in de meeste programmeertalen. jq niet
onderscheid maken tussen verwijzingen naar en kopieën van iets - twee objecten of arrays zijn dat
gelijk of niet gelijk, zonder enig verder idee van 'hetzelfde object' of 'niet'
hetzelfde voorwerp".

Als een object twee velden heeft die arrays zijn, .foo en .Cafe, en je voegt er iets aan toe
.foodan .Cafe zal niet groter worden. Zelfs als je net bent ingesteld .Cafe = .foo. Als je gewend bent
tot programmeren in talen als Python, Java, Ruby, Javascript etc. dan kun je denken
ervan alsof jq een volledige, diepe kopie van elk object maakt voordat het de opdracht uitvoert
(voor prestaties doet het dat eigenlijk niet, maar dat is het algemene idee).

Alle toewijzingsoperatoren in jq hebben padexpressies aan de linkerkant.

=
Het filter .foo = 1 zal als invoer een object nemen en als uitvoer een object produceren met de
"foo"-veld ingesteld op 1. Er is geen notie van iets "aanpassen" of "veranderen" in jq -
alle jq-waarden zijn onveranderlijk. Bijvoorbeeld,

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

zal niet het neveneffect hebben van het instellen van .bar.baz op 1, zoals het er hetzelfde uitziet
programma in Javascript, Python, Ruby of andere talen zou dat doen. In tegenstelling tot deze talen (maar
zoals Haskell en enkele andere functionele talen), bestaat er geen notie van twee arrays of
objecten die "dezelfde array" of "hetzelfde object" zijn. Ze kunnen gelijk zijn, of niet gelijk, maar
als we de ene veranderen, zal de andere onder geen enkele omstandigheid achter onze rug om veranderen.

Dit betekent dat het onmogelijk is om cirkelvormige waarden in jq te bouwen (zoals een array waarvan
eerste element is zichzelf). Dit is heel opzettelijk en zorgt ervoor dat alles wat een jq
programma kan produceren, kan worden weergegeven in JSON.

Merk op dat de linkerkant van ´=´ verwijst naar een waarde in .. Dus $var.foo = 1 zal niet werken
zoals verwacht ($var.foo is geen geldige of bruikbare padexpressie in .); gebruik $var | .foo = 1
gebruiken.

Als de rechterkant van ´=´ meerdere waarden oplevert, dan zal jq dat voor elke dergelijke waarde ook doen
stel de paden aan de linkerkant in op de waarde en dan wordt de gewijzigde uitvoer uitgevoerd ..
Bijvoorbeeld (.a,.b)=reeks(2) uitgangen {"a":0,"b":0}dan {"a":1,"b":1}. De update"
opdrachtformulieren (zie hieronder) doen dit niet.

Merk dat ook op .a,.b=0 zet niet in .a en .b, Maar (.a,.b)=0 zet beide.

|=
Naast de toewijzingsoperator ´=´ biedt jq ook de "update"-operator ´|=´, die
neemt een filter aan de rechterkant en berekent de nieuwe waarde voor de eigenschap van .
waaraan wordt toegewezen door de oude waarde door deze expressie te laten lopen. Bijvoorbeeld .foo |=
.+1 zal een object bouwen waarbij het veld "foo" is ingesteld op "foo" plus 1 van de invoer.

Dit voorbeeld zou het verschil tussen ´=´ en ´|=´ moeten laten zien:

Geef invoer ´{"a": {"b": 10}, "b": 20}´ aan de programma's:

.a = .b .a |= .b

De eerste zal het "a"-veld van de invoer instellen op het "b"-veld van de invoer, en produceren
de uitvoer {"a": 20}. Deze laatste zal het "a"-veld van de invoer instellen op de "a"-velden
"b"-veld, wat {"a": 10} oplevert.

De linkerkant kan elke algemene paduitdrukking zijn; zien pad().

Merk op dat de linkerkant van ´|=´ verwijst naar een waarde in .. Dus $var.foo |= . + 1 zal niet
werkt zoals verwacht ($var.foo is geen geldige of bruikbare padexpressie in .); gebruik $var | .foo
|= . + 1 gebruiken.

Als de rechterkant meerdere waarden uitvoert, wordt alleen de laatste gebruikt.

jq ´(..|select(type=="boolean")) |= if . dan 1 anders 0 end´
[waar,onwaar,[5,waar,[waar,[onwaar]],onwaar]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, /=, %=, // =
jq heeft een paar operatoren van het formulier a op= b, die allemaal gelijkwaardig zijn aan a |= . op b. Zo,
+= 1 kan worden gebruikt om waarden te verhogen.

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

Complex opdrachten
Aan de linkerkant van een jq-opdracht zijn veel meer dingen toegestaan ​​dan in de meeste gevallen
talen. We hebben al eenvoudige veldtoegangen aan de linkerkant gezien, en dat is nee
verrassing dat array-toegangen net zo goed werken:

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

Wat misschien als een verrassing komt, is dat de uitdrukking aan de linkerkant meerdere kan opleveren
resultaten, verwijzend naar verschillende punten in het invoerdocument:

.posts[].commentaar |= . + ["dit is geweldig"]

In dat voorbeeld wordt de tekenreeks 'dit is geweldig' toegevoegd aan de array 'opmerkingen' van elk bericht in
de invoer (waarbij de invoer een object is met een veld "posts", wat een array van berichten is).

Wanneer jq een toewijzing als ´a = b´ tegenkomt, registreert het het "pad" dat is gevolgd om a te selecteren
onderdeel van het invoerdocument tijdens het uitvoeren van a. Dit pad wordt vervolgens gebruikt om te vinden welk deel van
de invoer die moet worden gewijzigd tijdens het uitvoeren van de opdracht. Elk filter kan worden gebruikt op de
linkerkant van een is gelijk - welk pad het ook selecteert uit de invoer, zal zijn waar de
opdracht wordt uitgevoerd.

Dit is een zeer krachtige operatie. Stel dat we een opmerking aan blogposts willen toevoegen met behulp van
dezelfde "blog"-invoer hierboven. Deze keer willen we alleen reageren op de berichten die zijn geschreven door
"Stedolan". We kunnen deze berichten vinden met behulp van de eerder beschreven functie "selecteren":

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

De paden die door deze bewerking worden geboden, verwijzen naar elk van de berichten die "stedolan" heeft geschreven, en
we kunnen op elk ervan commentaar geven op dezelfde manier als voorheen:

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

MODULES

jq heeft een bibliotheek/modulesysteem. Modules zijn bestanden waarvan de naam eindigt op .jq.

Modules die door een programma worden geïmporteerd, worden gezocht in een standaardzoekpad (zie hieronder). De
importeren en omvatten Met richtlijnen kan de importeur dit pad wijzigen.

Paden in het zoekpad zijn onderhevig aan verschillende vervangingen.

Voor paden die beginnen met "~/", wordt "~" vervangen door de homedirectory van de gebruiker.

Voor paden die beginnen met "$ORIGIN/", wordt het pad van het uitvoerbare bestand jq vervangen
"$ORIGIN".

Voor paden die beginnen met "./" of paden die "." zijn, is het pad van het opgenomen bestand
vervangen door ".". Voor programma's op het hoogste niveau die op de opdrachtregel worden gegeven, wordt current
map wordt gebruikt.

Importrichtlijnen kunnen optioneel een zoekpad specificeren waaraan het standaardpad wordt toegevoegd.

Het standaardzoekpad is het zoekpad dat aan de -L opdrachtregeloptie, anders
["~/.jq", "$ORIGIN/../lib/jq", "$OORSPRONG/../ lib"].

Null- en lege tekenreekspadelementen beëindigen de zoekpadverwerking.

Er zou naar een afhankelijkheid met het relatieve pad "foo/bar" worden gezocht in "foo/bar.jq" en
"foo/bar/bar.jq" in het opgegeven zoekpad. Dit is bedoeld om modules te kunnen plaatsen
in een map samen met bijvoorbeeld versiebeheerbestanden, README-bestanden, enzovoort,
maar ook om modules met één bestand mogelijk te maken.

Opeenvolgende componenten met dezelfde naam mogen geen dubbelzinnigheden vermijden (bijv.
"foe/foe").

Bijvoorbeeld met -L$HOME/.jq een module foo is te vinden in $HOME/.jq/foo.jq en
$HOME/.jq/foo/foo.jq.

Als "$HOME/.jq" een bestand is, wordt het in het hoofdprogramma geplaatst.

importeren RelatievePathString as NAAM [ ];
Importeert een module gevonden op het opgegeven pad relatief aan een map in een zoekpad. Een ".jq"
het achtervoegsel wordt toegevoegd aan de relatieve padreeks. De symbolen van de module worden voorafgegaan door
"NAAM::".

De optionele metagegevens moeten een constante jq-expressie zijn. Het moet een voorwerp met sleutels zijn
zoals "homepage" enzovoort. Op dit moment gebruikt jq alleen de "zoek" sleutel/waarde van de
metagegevens. De metadata wordt ook beschikbaar gesteld aan gebruikers via de modulemeta ingebouwd.

De "zoek"-sleutel in de metagegevens, indien aanwezig, moet een tekenreeks- of arraywaarde hebben (array
van snaren); dit is het zoekpad dat moet worden voorafgegaan aan het zoekpad op het hoogste niveau.

omvatten RelatievePathString [ ];
Importeert een module gevonden op het opgegeven pad relatief aan een map in een zoekpad alsof dit het geval is
werden op hun plaats opgenomen. Er wordt een achtervoegsel ".jq" toegevoegd aan de relatieve padreeks. De
De symbolen van de module worden geïmporteerd in de naamruimte van de beller alsof de inhoud van de module dat wel zou hebben
direct opgenomen.

De optionele metagegevens moeten een constante jq-expressie zijn. Het moet een voorwerp met sleutels zijn
zoals "homepage" enzovoort. Op dit moment gebruikt jq alleen de "zoek" sleutel/waarde van de
metagegevens. De metadata wordt ook beschikbaar gesteld aan gebruikers via de modulemeta ingebouwd.

importeren RelatievePathString as $NAAM [ ];
Importeert een JSON-bestand gevonden op het opgegeven pad relatief aan een map in een zoekpad. A
Het achtervoegsel ".json" wordt toegevoegd aan de relatieve padtekenreeks. De gegevens van het bestand zijn
beschikbaar als $NAAM::NAAM.

De optionele metagegevens moeten een constante jq-expressie zijn. Het moet een voorwerp met sleutels zijn
zoals "homepage" enzovoort. Op dit moment gebruikt jq alleen de "zoek" sleutel/waarde van de
metagegevens. De metadata wordt ook beschikbaar gesteld aan gebruikers via de modulemeta ingebouwd.

De "zoek"-sleutel in de metagegevens, indien aanwezig, moet een tekenreeks- of arraywaarde hebben (array
van snaren); dit is het zoekpad dat moet worden voorafgegaan aan het zoekpad op het hoogste niveau.

module ;
Deze richtlijn is geheel optioneel. Het is niet vereist voor een goede werking. Het dient
alleen met het doel om metagegevens te verstrekken die kunnen worden gelezen met de modulemeta ingebouwd.

De metagegevens moeten een constante jq-expressie zijn. Het moet een object zijn met sleutels zoals
"Startpagina". Op dit moment gebruikt jq deze metadata niet, maar wordt deze beschikbaar gesteld aan gebruikers
via de modulemeta ingebouwd.

modulemeta
Neemt een modulenaam als invoer en voert de metagegevens van de module uit als een object, met de
module importeert (inclusief metadata) als een arraywaarde voor de "deps" -sleutel.

Programma's kunnen dit gebruiken om de metadata van een module op te vragen, die ze vervolgens kunnen gebruiken
Zoek, download en installeer bijvoorbeeld ontbrekende afhankelijkheden.

Gebruik jq online met behulp van onworks.net-services