jq - Online în cloud

PROGRAM:

NUME

jq - Procesor JSON de linie de comandă

REZUMAT

jq [Opțiuni...] filtru [fișiere...]

jq poate transforma JSON în diferite moduri, prin selectare, iterare, reducere și în alt mod
alterarea documentelor JSON. De exemplu, rularea comenzii jq „hartă(.preț) | adăuga voi
luați o matrice de obiecte JSON ca intrare și returnați suma câmpurilor lor „preț”.

jq poate accepta și introducerea textului, dar implicit, jq citește un flux de entități JSON
(inclusiv numere și alte literale) din stdin. Spațiile albe sunt necesare doar pentru a separa
entități precum 1 și 2 și adevărat și fals. Una sau mai multe fișiere poate fi specificat, în care
caz jq va citi în schimb intrarea de la aceștia.

Opțiuni sunt descrise în INVOCAT JQ secțiune; acestea se referă în principal la intrare și la ieșire
formatare. filtru este scris în limbajul jq și specifică modul de transformare
fișier sau document de intrare.

FILTRE

Un program jq este un „filtru”: ia o intrare și produce o ieșire. Sunt multe
filtre încorporate pentru extragerea unui anumit câmp al unui obiect sau convertirea unui număr în
un șir sau diverse alte sarcini standard.

Filtrele pot fi combinate în diferite moduri - puteți conducta ieșirea unui singur filtru
alt filtru sau colectați rezultatul unui filtru într-o matrice.

Unele filtre produc rezultate multiple, de exemplu, există unul care produce toate
elemente ale matricei sale de intrare. Tubularea acelui filtru într-o secundă rulează al doilea filtru pentru
fiecare element al matricei. În general, lucruri care ar fi făcute cu bucle și iterații
în alte limbi se fac doar prin lipirea filtrelor împreună în jq.

Este important să rețineți că fiecare filtru are o intrare și o ieșire. Chiar și literalmente
precum „bună ziua” sau 42 sunt filtre - preiau o intrare, dar produc întotdeauna același literal ca
ieșire. Operațiile care combină două filtre, cum ar fi adăugarea, alimentează în general aceeași intrare
la amândouă și combină rezultatele. Deci, puteți implementa un filtru de mediere ca adăuga / lungime
- alimentarea matricei de intrare atât la adăuga filtrul și lungime se filtrează și apoi se efectuează
Divizia.

Dar asta este să ne devansăm. :) Să începem cu ceva mai simplu:

INVOCAT JQ

Filtrele jq rulează pe un flux de date JSON. Intrarea în jq este analizată ca o secvență de
valori JSON separate prin spații albe care sunt trecute prin filtrul furnizat una la a
timp. Ieșirile filtrului sunt scrise la ieșirea standard, din nou ca o secvență de
date JSON separate prin spații albe.

Notă: este important să țineți cont de regulile de citare ale shell-ului. Ca regulă generală, cel mai bine este să
citați întotdeauna (cu caractere cu ghilimele simple) programul jq, ca prea multe caractere cu
semnificație specială pentru jq sunt, de asemenea, meta-caractere shell. De exemplu, jq "foo" va eșua
majoritatea shell-urilor Unix pentru că va fi la fel ca jq foo, care în general va eșua
deoarece foo is nu definit. Când utilizați shell-ul de comandă Windows (cmd.exe), cel mai bine este să faceți
utilizați ghilimele duble în jurul programului dvs. jq atunci când sunt date pe linia de comandă (în loc de -f
fişier-program opțiunea), dar apoi ghilimelele duble din programul jq necesită scaparea barei oblice inverse.

Puteți afecta modul în care jq citește și scrie intrarea și ieșirea folosind o linie de comandă
opţiuni:

· --versiune:

Ieșiți versiunea jq și ieșiți cu zero.

· --secv:

Folosește application/json-seq Schema de tip MIME pentru separarea textelor JSON în intrarea jq
și ieșire. Aceasta înseamnă că un caracter ASCII RS (separator de înregistrări) este imprimat înainte
fiecare valoare la ieșire și un ASCII LF (line feed) sunt imprimate după fiecare ieșire. Intrare
Textele JSON care nu reușesc să analizeze sunt ignorate (dar avertizate cu privire la), eliminând toate
intrare ulterioară până la următorul RS. Aceasta mai analizează, de asemenea, rezultatul lui jq fără
--secv opțiune.

· --curent:

Analizați intrarea în flux, emițând matrice de valori ale căii și frunzelor
(scalare și matrice goale sau obiecte goale). De exemplu, "A" devine [[],"A"], și
[[],"a",["b"]] devine [[0],[]], [[1],"a"], și [[1,0],"b"].

Acest lucru este util pentru procesarea intrărilor foarte mari. Utilizați acest lucru împreună cu
filtrarea și reduce și pentru fiecare sintaxă pentru a reduce intrările mari treptat.

· --slurp/-s:

În loc să rulați filtrul pentru fiecare obiect JSON din intrare, citiți întreaga intrare
flux într-o matrice mare și rulați filtrul o singură dată.

· --input-brut/-R:

Nu analizați intrarea ca JSON. În schimb, fiecare linie de text este transmisă filtrului ca a
şir. Dacă este combinat cu --slurp, apoi întreaga intrare este transmisă filtrului ca a
un singur șir lung.

· --input-null/-n:

Nu citiți deloc nicio intrare! În schimb, filtrul este rulat o dată cu utilizarea zero ca intrare.
Acest lucru este util atunci când utilizați jq ca un simplu calculator sau pentru a construi date JSON din
zgârietură.

· --ieșire compactă / -c:

În mod implicit, jq pretty-tipărește ieșirea JSON. Utilizarea acestei opțiuni va avea ca rezultat mai multe
ieșire compactă prin plasarea fiecărui obiect JSON pe o singură linie.

· --tab:

Utilizați o filă pentru fiecare nivel de indentare în loc de două spații.

· --liniuță n:

Utilizați numărul dat de spații (nu mai mult de 8) pentru indentare.

· --culoare-ieșire / -C și --ieșire-monocrom / -M:

În mod implicit, jq scoate JSON colorat dacă scrie pe un terminal. Poți să o forțezi
produce culoare chiar dacă scrieți într-o țeavă sau într-un fișier folosind -C, și dezactivați culoarea cu -M.

· --ascii-ieșire / -a:

jq scoate de obicei puncte de cod Unicode non-ASCII ca UTF-8, chiar dacă intrarea este specificată
ele ca secvențe de evacuare (cum ar fi „\u03bc”). Folosind această opțiune, puteți forța jq să
produce ieșire ASCII pură cu fiecare caracter non-ASCII înlocuit cu echivalentul
secvență de evadare.

· --nebuffered

Spălați ieșirea după ce fiecare obiect JSON este tipărit (util dacă treceți lent
sursa de date în jq și canalizarea ieșirii jq în altă parte).

· --chei-sortare / -S:

Ieșiți câmpurile fiecărui obiect cu cheile în ordine sortată.

· --ieșire brută / -r:

Cu această opțiune, dacă rezultatul filtrului este un șir, atunci acesta va fi scris direct
la ieșire standard, în loc să fie formatat ca șir JSON cu ghilimele. Acesta poate
fi util pentru ca filtrele jq să vorbească cu sistemele care nu sunt bazate pe JSON.

· --join-output / -j:

Aprecieri -r dar jq nu va imprima o nouă linie după fiecare ieșire.

· -f nume de fișier / --din fisier nume de fișier:

Citiți filtrul din fișier, mai degrabă decât dintr-o linie de comandă, cum ar fi opțiunea -f awk. Tu
poate folosi, de asemenea, „#” pentru a face comentarii.

· -Ldirector / -L director:

Adăugați director la lista de căutare pentru module. Dacă se folosește această opțiune, nu
este folosită lista de căutare încorporată. Consultați secțiunea despre module de mai jos.

· -e / --starea-ieșire:

Setează starea de ieșire a lui jq la 0 dacă ultimele valori de ieșire nu au fost niciuna fals nici zero,
1 dacă ultima valoare de ieșire a fost oricare fals or zero, sau 4 dacă nu a fost vreodată un rezultat valid
produs. În mod normal, jq iese cu 2 dacă a existat vreo problemă de utilizare sau eroare de sistem, 3
dacă a existat o eroare de compilare a programului jq sau 0 dacă a rulat programul jq.

· --arg nume valoare:

Această opțiune transmite o valoare programului jq ca variabilă predefinită. Dacă rulați jq
cu --arg foo bar, Apoi $ foo este disponibil în program și are valoarea "bar".
Rețineți că valoare va fi tratat ca un șir, deci --arg foo 123 va lega $ foo la "123".

· --argjson nume JSON-text:

Această opțiune transmite o valoare codificată JSON programului jq ca variabilă predefinită. Dacă
alergi jq cu --argjson foo 123, Apoi $ foo este disponibil în program și are
valoare 123.

· --slurpfile nume-variabilă nume de fișier:

Această opțiune citește toate textele JSON din fișierul numit și leagă o matrice a fișierului
a analizat valorile JSON la variabila globală dată. Daca rulezi jq cu --argfile foo bar,
apoi $ foo este disponibil în program și are o matrice ale cărei elemente corespund
textele din dosarul numit bar.

· --argfile nume-variabilă nume de fișier:

Nu folosi. Utilizare --slurpfile in schimb.

(Această opțiune este ca --slurpfile, dar când fișierul are doar un text, atunci acesta este
folosit, altfel o serie de texte este folosită ca în --slurpfile.)

· --run-teste [nume de fișier]:

Rulează testele în fișierul dat sau intrarea standard. Aceasta trebuie să fie ultima opțiune oferită
și nu respectă toate opțiunile precedente. Intrarea constă din rânduri de comentarii, goale
linii și linii de program urmate de o linie de intrare, câte linii de ieșire sunt
așteptat (unul pentru fiecare ieșire) și o linie goală finală. Teste de eșec de compilare
începe cu o linie care conține doar „%%FAIL”, apoi o linie care conține programul la
compila, apoi o linie care conține un mesaj de eroare pentru a compara cu cel real.

Fiți avertizat că această opțiune se poate modifica înapoi, incompatibil.

BASIC FILTRE

.
Cel mai simplu (și cel mai puțin interesant) filtru absolut este .. Acesta este un filtru care își ia
intrare și o produce neschimbată ca ieșire.

Deoarece jq imprimă în mod implicit toate rezultatele, acest program banal poate fi o modalitate utilă de
formatarea ieșirii JSON de la, să zicem, răsuci.

jq ´.´
"Salut Lume!"
=> "Bună, lume!"

.foo, .foo.bar
Cel mai simplu util filtru este .foo. Când i se oferă un obiect JSON (alias dicționar sau hash) ca
intrare, produce valoarea la cheia „foo”, sau nulă dacă nu este prezentă.

Dacă cheia conține caractere speciale, trebuie să o înconjurați cu ghilimele duble, cum ar fi
acest: ."foo$".

Un filtru al formularului .foo.bar este echivalent cu .foo|.bar.

jq ´.foo´
{"foo": 42, "bar": "date mai puțin interesante"}
=> 42

jq ´.foo´
{"notfoo": adevărat, "alsonotfoo": fals}
=> nul

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

.foo?
La fel ca .foo, dar nu scoate nici măcar o eroare când . nu este o matrice sau un obiect.

jq ´.foo?´
{"foo": 42, "bar": "date mai puțin interesante"}
=> 42

jq ´.foo?´
{"notfoo": adevărat, "alsonotfoo": fals}
=> nul

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

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

.[ ], .[2], .[10:15]
De asemenea, puteți căuta câmpuri ale unui obiect folosind sintaxele de tipul .[„foo”] (.foo de mai sus este a
versiunea scurtă a acesteia). Acesta funcționează și pentru matrice, dacă cheia este un număr întreg.
Matricele sunt bazate pe zero (cum ar fi javascript), deci . [2] returnează al treilea element al matricei.

.[10:15] sintaxa poate fi folosită pentru a returna o sub-tază dintr-o matrice sau un subșir al unui șir.
Matricea returnată de .[10:15] va fi de lungime 5, continand elementele din indicele 10
(inclusiv) la indicele 15 (exclusiv). Oricare indice poate fi negativ (caz în care contează
înapoi de la sfârșitul matricei), sau omis (caz în care se referă la începutul sau
sfârşitul matricei).

. [2] sintaxa poate fi folosită pentru a returna elementul la indexul dat. Indicii negativi sunt
permis, cu -1 referindu-se la ultimul element, -2 referindu-se la ultimul element,
şi aşa mai departe.

.foo sintaxa funcționează numai pentru chei simple, adică chei care sunt toate caractere alfanumerice.
.[ ] funcționează cu taste care conțin caractere speciale, cum ar fi două puncte și puncte. Pentru
exemplu .["foo::bar"] și .[„foo.bar”] lucrează în timp ce .foo::bar și .foo.bar nu voi.

? „operator” poate fi folosit și cu operatorul slice, ca în .[10:15]?, care iese
valorile în care intrările sunt slice-able.

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

jq ´.[2]´
[{"name":"JSON", "good":true}, {"name":"XML", "good":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

.[]
Dacă utilizați .[index] sintaxă, dar omiteți în întregime indexul, acesta va reveni toate a
elemente ale unui tablou. Alergare .[] cu intrarea [1,2,3] va produce numerele ca trei
rezultate separate, mai degrabă decât ca o singură matrice.

Puteți utiliza acest lucru și pe un obiect și va returna toate valorile obiectului.

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

.[]?
Aprecieri .[], dar nu vor fi afișate erori dacă . nu este o matrice sau obiect.

,
Dacă două filtre sunt separate printr-o virgulă, atunci intrarea va fi introdusă în ambele și acolo
vor fi ieșiri multiple: mai întâi, toate ieșirile produse de expresia din stânga și
apoi toate iesirile produse de dreapta. De exemplu, filtrează .foo, .Cafenea, produce
atât câmpurile „foo” cât și câmpurile „bar” ca ieșiri separate.

jq ´.foo, .bar´
{"foo": 42, "bar": "altceva", "baz": true}
=> 42, „altceva”

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

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

|
| operatorul combină două filtre introducând ieșirile celui din stânga în
intrarea celui din dreapta. Este aproape la fel cu conducta shell-ului Unix, dacă
esti obisnuit cu asta.

Dacă cel din stânga produce rezultate multiple, cel din dreapta va fi rulat pentru
fiecare dintre aceste rezultate. Deci, expresia .[] | .foo preia câmpul „foo” al fiecăruia
element al matricei de intrare.

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

TIPURI AND VALORI

jq acceptă același set de tipuri de date ca JSON - numere, șiruri de caractere, boolean, matrice,
obiecte (care în limbajul JSON sunt hash-uri cu chei șir de caractere) și „null”.

Valorile booleene, nule, șirurile și numerele sunt scrise la fel ca în javascript. Exact ca
totul în jq, aceste valori simple iau o intrare și produc o ieșire - 42 este
expresie jq validă care preia o intrare, o ignoră și returnează în schimb 42.

Mulțime construcţie - []
Ca și în JSON, [] este folosit pentru a construi matrice, ca în [1,2,3]. Elementele matricelor pot
fie orice expresie jq. Toate rezultatele produse de toate expresiile sunt colectate
într-o matrice mare. Îl puteți folosi pentru a construi o matrice dintr-o cantitate cunoscută de valori
(ca în [.foo, .bar, .baz]) sau pentru a „colecta” toate rezultatele unui filtru într-o matrice (cum ar fi
in [.items[].name])

Odată ce înțelegeți operatorul ",", puteți privi sintaxa matricei jq într-un alt mod
lumina: expresia [1,2,3] nu folosește o sintaxă încorporată pentru matricele separate prin virgulă,
dar se aplică în schimb [] operator (colectați rezultate) la expresia 1,2,3 (care
produce trei rezultate diferite).

Daca ai un filtru X care produce patru rezultate, apoi expresia [X] va produce o
un singur rezultat, o matrice de patru elemente.

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

Obiecte - {}
Ca JSON, {} este pentru construirea de obiecte (aka dicționare sau hashes), ca în: {"A": 42,
„b”: 17/XNUMX/XNUMX}.

Dacă tastele sunt „sensibile” (toate caracterele alfabetice), atunci ghilimelele pot fi lăsate deoparte.
Valoarea poate fi orice expresie (deși poate fi necesar să o împachetați în paranteze dacă este
complicat), care se aplică la intrarea expresiei {} (rețineți, toate filtrele
au o intrare și o ieșire).

{foo: .bar}

va produce obiectul JSON {"foo": 42/XNUMX/XNUMX} dacă este dat obiectul JSON {"bar":42, „baz”:43}.
Puteți utiliza aceasta pentru a selecta anumite câmpuri ale unui obiect: dacă intrarea este un obiect cu
Câmpurile „utilizator”, „titlu”, „id” și „conținut” și doriți doar „utilizator” și „titlu”, puteți
scrie

{utilizator: .user, titlu: .title}

Deoarece este atât de comun, există o sintaxă de scurtătură: {utilizator, titlu}.

Dacă una dintre expresii produce rezultate multiple, vor fi mai multe dicționare
produs. Dacă intrarea este

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

apoi expresia

{utilizator, titlu: .titles[]}

va produce două rezultate:

{"user":"stedolan", "title": "JQ Primer"}
{"user":"stedolan", "title": "Mai multe JQ"}

Punând paranteze în jurul cheii înseamnă că va fi evaluată ca expresie. Cu
aceeași intrare ca mai sus,

{(.utilizator): .titluri}

produce

{"stedolan": ["JQ Primer", "Mai multe JQ"]}

jq ´{utilizator, titlu: .titles[]}´
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
=> {"user":"stedolan", "title": "JQ Primer"}, {"user":"stedolan", "title": "Mai multe JQ"}

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

INCORPORAT OPERATORI AND FUNCȚII

Unele operatori jq (de exemplu, +) fac lucruri diferite în funcție de tipul lor
argumente (matrice, numere etc.). Cu toate acestea, jq nu face niciodată conversii implicite de tip. Dacă
Dacă încercați să adăugați un șir la un obiect, veți primi un mesaj de eroare și niciun rezultat.

Plus - +
Operatorul + ia două filtre, le aplică pe ambele la aceeași intrare și adaugă
rezultate împreună. Ce înseamnă „adăugarea” depinde de tipurile implicate:

· Numere sunt adăugate prin aritmetică normală.

· Arrays sunt adăugate prin concatenare într-o matrice mai mare.

· Corzi sunt adăugate prin unirea într-un șir mai mare.

· Obiecte sunt adăugate prin fuziune, adică inserarea tuturor perechilor cheie-valoare din ambele
obiecte într-un singur obiect combinat. Dacă ambele obiecte conțin o valoare pentru același
cheie, obiectul din dreapta + învinge. (Pentru îmbinarea recursivă utilizați * operator.)

zero poate fi adăugat la orice valoare și returnează cealaltă valoare neschimbată.

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}´
zero
=> {"a": 42, "b": 2, "c": 3}

Scădere - -
La fel ca și scăderea aritmetică normală pe numere, - operatorul poate fi folosit pe matrice
pentru a elimina toate aparițiile elementelor celei de-a doua matrice din prima matrice.

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

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

Multiplicare, Divizia, formă - *, /, și %
Acești operatori infixi se comportă așa cum era de așteptat când li se dau două numere. Împărțirea la zero crește
o eroare. x % y calculează x modulo y.

Înmulțirea unui șir cu un număr produce concatenarea acelui șir atât de multe
ori. "X" * 0 produce zero.

Împărțirea unui șir la altul îl împarte pe primul folosindu-l pe al doilea ca separatori.

Înmulțirea a două obiecte le va îmbina recursiv: aceasta funcționează ca o adunare, dar dacă ambele
obiectele conțin o valoare pentru aceeași cheie, iar valorile sunt obiecte, cele două sunt îmbinate
cu aceeasi 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}}´
zero
=> {"k": {"a": 0, "b": 2, "c": 3}}

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

lungime
Funcția încorporată lungime primește lungimea diferitelor tipuri de valori:

· Lungimea a şir este numărul de puncte de cod Unicode pe care le conține (care va fi
la fel ca lungimea codificată JSON în octeți dacă este ASCII pur).

· Lungimea unui mulțime este numărul de elemente.

· Lungimea unui obiect este numărul de perechi cheie-valoare.

· Lungimea de zero este zero.

jq ´.[] | lungime´ [[1,2], "șir", {"a":2}, nul] => 2, 6, 1, 0

chei, chei_nesortate
Funcția încorporată chei, când i se oferă un obiect, returnează cheile acestuia într-o matrice.

Cheile sunt sortate „alfabetic”, după ordinea punctelor de cod Unicode. Acesta nu este un ordin
asta are un sens special într-o anumită limbă, dar poți conta că este
același lucru pentru oricare două obiecte cu același set de chei, indiferent de setările locale.

Cand chei primește un tablou, returnează indicii validi pentru acel tablou: numerele întregi
de la 0 la lungimea-1.

chei_nesortate funcția este la fel ca chei, dar dacă intrarea este un obiect, atunci tastele
nu vor fi sortate, în schimb cheile vor fi aproximativ în ordinea de inserare.

jq „chei”.
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Foo", "abc", "abcd"]

jq „chei”.
[42,3,35]
=> [0,1,2]

are (cheie)
Funcția încorporată are returnează dacă obiectul de intrare are cheia dată sau intrarea
array are un element la indexul dat.

are($key) are acelaşi efect ca verificarea dacă $ cheie este un membru al matricei returnate
by chei, Deși are va fi mai rapid.

jq „hartă(are(„foo”))’
[{"foo": 42}, {}]
=> [adevărat, fals]

jq ´harta(are(2))'
[[0,1], ["a","b","c"]]
=> [fals, adevărat]

in
Funcția încorporată in returnează cheia de intrare este în obiectul dat sau indexul de intrare
corespunde unui element din tabloul dat. Este, în esență, o versiune inversată a
are.

jq ´.[] | în({"foo": 42})´
[„foo”, „bar”]
=> adevărat, fals

jq „hartă(în([0,1]))”.
[2, 0]
=> [fals, adevărat]

cale(expresie_cale)
Afișează reprezentări matrice ale expresiei de cale dată în .. Ieșirile sunt matrice de
șiruri de caractere (chei în obiecte0 și/sau numere (indici de matrice.

Expresiile de cale sunt expresii jq ca .a, Dar, de asemenea, .[]. Există două tipuri de căi
expresii: cele care se pot potrivi exact și cele care nu. De exemplu, .abc este o
expresia calea potrivirii exacte, while .a[].b nu este.

cale (exact_path_expression) va produce reprezentarea matrice a expresiei cale
chiar dacă nu există în ., dacă . is zero sau o matrice sau un obiect.

cale (model) va produce reprezentări matrice ale potrivirii căilor model dacă
căi există în ..

Rețineți că expresiile de cale nu sunt diferite de expresiile normale. Expresia
cale(..|select(tip=="boolean")) scoate toate căile către valorile booleene în ., si doar
acele cărări.

jq ’cale(.a[0].b)’
zero
=> ["a",0,"b"]

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

del(expresie_cale)
Funcția încorporată del elimină o cheie și valoarea ei corespunzătoare dintr-un obiect.

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

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

to_enters, din_entrii, cu_intrari
Aceste funcții convertesc între un obiect și o matrice de perechi cheie-valoare. Dacă la_întrari
este trecut un obiect, apoi pentru fiecare k: v intrare în intrare, matricea de ieșire include
{"cheie": k, "valoare": v}.

din_intrari face conversia inversă și with_entries(foo) este o scurtătură pentru
la_întrari | harta (foo) | din_intrari, util pentru efectuarea unor operații la toate tastele și
valorile unui obiect. din_intrari acceptă cheie, cheie, nume, valoare și valoare ca chei.

jq „la_entrii”.
{"a": 1, "b": 2}
=> [{"key":"a", "value":1}, {"key":"b", "value":2}]

jq „din_entrii”.
[{"key":"a", "value":1}, {"key":"b", "value":2}]
=> {"a": 1, "b": 2}

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

select(expresie_booleană)
Funcția selectează (foo) își produce intrarea neschimbată dacă foo returnează adevărat pentru acea intrare,
și nu produce nicio ieșire altfel.

Este util pentru filtrarea listelor: [1,2,3] | harta(selectați(. >= 2))) vă va da [2,3].

jq „hartă(selectați(. >= 2))”.
[1,5,3,0,7]
=> [5,3,7]

jq ´.[] | select(.id == „al doilea”)´
[{"id": "primul", "val": 1}, {"id": "al doilea", "val": 2}]
=> {"id": "al doilea", "val": 2}

matrice, obiecte, iterabile, booleene, numere, normali, finite, siruri de caractere, nule, valori,
scalari
Aceste integrate selectează numai intrări care sunt matrice, obiecte, iterabile (matrice sau
obiecte), booleeni, numere, numere normale, numere finite, șiruri de caractere, nul, non-null
valori și, respectiv, non-iterabile.

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

gol
gol nu returnează niciun rezultat. Deloc. Nici măcar zero.

Este util ocazional. Vei sti daca ai nevoie :)

jq ´1, gol, 2´
zero
=> 1, 2

jq ´[1,2,gol,3]´
zero
=> [1,2,3]

eroare(mesaj)
Produce o eroare, la fel ca .a aplicat altor valori decât nul și obiecte ar, dar
cu mesajul dat ca valoare a erorii.

$__loc__
Produce un obiect cu o cheie „fișier” și o cheie „linie”, cu numele fișierului și numărul liniei
Unde $__loc__ apare, ca valori.

jq ´eroare încercare("\($__loc__)") captura .´
zero
=> "{\"fișier\":\" \",\"linia 1}"

harta(x), map_values(x)
Pentru orice filtru x, harta(x) va rula acel filtru pentru fiecare element al matricei de intrare și
produce la ieșiri o nouă matrice. harta(.+1) va incrementa fiecare element dintr-o matrice de
numere.

În mod similar, map_values(x) va rula acel filtru pentru fiecare element, dar va returna un
obiect atunci când un obiect este trecut.

harta(x) este echivalent cu [.[] | x]. De fapt, așa este definit. În mod similar,
map_values(x) este definit ca .[] |= x.

jq „hartă(.+1)”.
[1,2,3]
=> [2,3,4]

jq „valori_hartă(.+1)”.
{"a": 1, "b": 2, "c": 3}
=> {"a": 2, "b": 3, "c": 4}

poteci, căi(filtru_nod), căi_frunze
căi scoate căile către toate elementele din intrarea sa (cu excepția faptului că nu scoate fișierul
listă goală, reprezentând . însuși).

poteci (f) emite căile către orice valori pentru care f este adevarat. Acesta este, căi (numere)
emite căile către toate valorile numerice.

căi_frunze este un alias al căi (scalare); căi_frunze is depreciată și va fi eliminat în
următoarea lansare majoră.

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

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

adăuga
Filtrul adăuga ia ca intrare o matrice și produce ca ieșire elementele matricei
adăugate împreună. Acest lucru ar putea însemna însumat, concatenat sau îmbinat în funcție de tipurile de
elementele matricei de intrare - regulile sunt aceleași cu cele pentru + operator
(descris mai sus).

Dacă intrarea este o matrice goală, adăuga Returnează zero.

jq „adăugați”.
["a","b","c"]
=> "abc"

jq „adăugați”.
[1, 2, 3]
=> 6

jq „adăugați”.
[]
=> nul

orice, orice (condiție), orice(generator; condiție)
Filtrul Orice ia ca intrare o matrice de valori booleene și produce adevărat ca ieşire dacă
oricare dintre elementele matricei este adevărat.

Dacă intrarea este o matrice goală, Orice Returnează fals.

orice (condiție) formularul aplică condiția dată elementelor tabloului de intrare.

orice(generator; condiție) formularul aplică condiția dată tuturor ieșirilor
generator dat.

jq 'oricare'
[adevarat fals]
=> adevărat

jq 'oricare'
[fals, fals]
=> fals

jq 'oricare'
[]
=> fals

toate, toate (condiția), toate(generator; condiție)
Filtrul toate ia ca intrare o matrice de valori booleene și produce adevărat ca ieşire dacă
toate elementele matricei sunt adevărat.

toate (condiția) formularul aplică condiția dată elementelor tabloului de intrare.

toate(generator; condiție) formularul aplică condiția dată tuturor ieșirilor
generator dat.

Dacă intrarea este o matrice goală, toate Returnează adevărat.

jq 'toate'
[adevarat fals]
=> fals

jq 'toate'
[adevarat adevarat]
=> adevărat

jq 'toate'
[]
=> adevărat

[Necesită 1.5] aplatiza, aplatiza (adâncime)
Filtrul aplatiza ia ca intrare o matrice de matrice imbricate și produce o matrice plată în
care toate tablourile din interiorul tabloului original au fost înlocuite recursiv cu valorile lor.
Puteți să îi transmiteți un argument pentru a specifica câte niveluri de imbricare trebuie aplatizate.

aplatiza(2) este ca aplatiza, dar mergând doar până la două niveluri adâncime.

jq „aplatiza”.
[1, [2], [[3]]]
=> [1, 2, 3]

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

jq „aplatiza”.
[[]]
=> []

jq „aplatiza”.
[{"foo": "bar"}, [{"foo": "baz"}]]
=> [{"foo": "bar"}, {"foo": "baz"}]

interval (până la), interval(de la;până la) interval(de la;până;până)
gamă funcția produce o serie de numere. interval (4;10) produce 6 numere, din 4
(inclusiv) până la 10 (exclusiv). Numerele sunt produse ca ieșiri separate. Utilizare
[interval(4;10)] pentru a obține un interval ca o matrice.

Forma cu un singur argument generează numere de la 0 la numărul dat, cu un increment de
1.

Forma cu două argumente generează numere de la din la pâna la cu un increment de 1.

Forma cu trei argumente generează numere din la pâna la cu un increment de by.

jq „interval(2;4)”.
zero
=> 2, 3

jq ´[interval(2;4)]´
zero
=> [2,3]

jq ´[gamă(4)]'
zero
=> [0,1,2,3]

jq ´[interval(0;10;3)]´
zero
=> [0,3,6,9]

jq ´[interval(0;10;-1)]´
zero
=> []

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

podea
podea funcția returnează nivelul intrării sale numerice.

jq „etaj”.
3.14159
=> 3

sqrt
sqrt funcția returnează rădăcina pătrată a intrării sale numerice.

jq „sqrt”.
9
=> 3

tonumar
tonumar funcția își analizează intrarea ca număr. Se va converti în format corect
șiruri de caractere la echivalentul lor numeric, lasă numerele în pace și dau o eroare pentru toate celelalte
intrare.

jq ´.[] | tonumar'
[1, „1”]
=> 1, 1

tostring
tostring funcția își imprimă intrarea ca șir. Șirurile sunt lăsate neschimbate și toate
alte valori sunt codificate JSON.

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

tip
tip funcția returnează tipul argumentului său ca șir, care este unul dintre nul,
boolean, număr, șir, matrice sau obiect.

jq „hartă(tip)”.
[0, fals, [], {}, nul, „bună ziua”]
=> ["număr", "boolean", "matrice", "obiect", "null", "șir"]

infinit, Nu, este infinit, isnan, este finit, este normal
Unele operații aritmetice pot produce infinitate și valori „nu un număr” (NaN). The
este infinit returnări încorporate adevărat dacă intrarea sa este infinită. The isnan returnări încorporate adevărat
dacă intrarea sa este un NaN. The infinit builtin returnează o valoare infinită pozitivă. The nan
builtin returnează un NaN. The este normal builtin returnează adevărat dacă intrarea sa este un număr normal.

Rețineți că împărțirea la zero generează o eroare.

În prezent, majoritatea operațiilor aritmetice care operează pe infinitate, NaN și sub-normale nu o fac
ridica erori.

jq ´.[] | (infinit * .) < 0´
[-unsprezece]
=> adevărat, fals

jq ´infinit, nan | tip
zero
=> „număr”, „număr”

fel, sort_by(expresie_cale)
fel functions sortează intrarea sa, care trebuie să fie o matrice. Valorile sunt sortate în
urmatoarea ordine:

· zero

· fals

· adevărat

· numere

· șiruri de caractere, în ordine alfabetică (după valoarea punctului de cod Unicode)

· tablouri, în ordine lexicală

· obiecte

Ordonarea obiectelor este puțin complexă: mai întâi sunt comparate comparându-le
seturi de chei (ca matrice în ordine sortată), iar dacă cheile lor sunt egale, atunci valorile sunt
comparat cheie cu cheie.

fel poate fi folosit pentru a sorta după un anumit câmp al unui obiect sau prin aplicarea oricărui filtru jq.

sort_by(foo) compară două elemente prin compararea rezultatului de foo pe fiecare element.

jq 'sortare'
[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(expresie_cale)
group_by(.foo) ia ca intrare un tablou, grupează elementele având același .foo camp
în matrice separate și produce toate aceste matrice ca elemente ale unui tablou mai mare,
sortate după valoarea lui .foo camp.

Orice expresie jq, nu doar un acces la câmp, poate fi folosită în locul lui .foo. Sortarea
ordinea este aceeași ca cea descrisă în fel funcția de mai sus.

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(exp_cale)
Găsiți elementul minim sau maxim al matricei de intrare.

min_by(path_exp) și max_by(exp_cale) funcțiile vă permit să specificați un anumit
câmp sau proprietate de examinat, de ex min_by(.foo) găsește obiectul cu cel mai mic foo
camp.

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

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

unic, unic_prin(exp_cale)
unic funcția ia ca intrare o matrice și produce o matrice din aceleași elemente, în
ordine sortată, cu duplicatele eliminate.

unic_prin(exp_cale) funcţia va păstra un singur element pentru fiecare valoare obţinută de
aplicând argumentul. Gândiți-vă la asta ca a face o matrice prin luarea unui element din fiecare
grup produs de grup.

jq „unic”.
[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 „unic_după (lungime)”.
[„gros”, „slănină”, „pisoi”, „cicada”, „sparanghel”]
=> [„slănină”, „gros”, „sparanghel”]

inversa
Această funcție inversează o matrice.

jq „invers”.
[1,2,3,4]
=> [4,3,2,1]

conţine(element)
Filtrul conține (b) va produce adevărat dacă b este complet conținut în intrare. A
șirul B este conținut într-un șir A dacă B este un subșir al lui A. O matrice B este conținută în
un tablou A dacă toate elementele din B sunt conținute în orice element din A. Un obiect B este
conținute în obiectul A dacă toate valorile din B sunt conținute în valoarea din A cu
aceeași cheie. Se presupune că toate celelalte tipuri sunt cuprinse unele în altele dacă sunt egale.

jq „conține(„bară”)”.
"foobar"
=> adevărat

jq ´contine(["baz", "bar"])´
[„foobar”, „foobaz”, „blarp”]
=> adevărat

jq ´contine(["bazzzzz", "bar"])´
[„foobar”, „foobaz”, „blarp”]
=> fals

jq „conține({foo: 12, bar: [{barp: 12}]})”
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> adevărat

jq „conține({foo: 12, bar: [{barp: 15}]})”
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> fals

indici(i)
Afișează o matrice care conține indicii în . Unde s apare. Intrarea poate fi o matrice, în
caz în care dacă s este o matrice, atunci indicii de ieșire vor fi cei în care sunt introduse toate elementele .
se potrivesc cu cele ale s.

jq „indici(”, „)”.
„a,b, cd, efg, hijk”
=> [3,7,12]

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

jq „indici([1,2])”.
[0,1,2,3,1,4,2,5,1,2,6,7]
=> [1,8]

index(e), index(e)
Afișează indexul primului (index) sau ultimul (rindex) aparitia s în intrare.

jq „index(”, „)”.
„a,b, cd, efg, hijk”
=> 3

jq „rindex(”, „)”.
„a,b, cd, efg, hijk”
=> 12

în interiorul
Filtrul în interior (b) va produce adevărat dacă intrarea este complet conținută în b. Aceasta
este, în esență, o versiune inversată a conține.

jq „înăuntru(„foobar”)”.
"bar"
=> adevărat

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

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

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

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

începe cu(str)
ieşiri adevărat dacă . începe cu argumentul șir dat.

jq ´[.[]|începe cu(„foo”)]´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [fals, adevărat, fals, adevărat, fals]

se termina cu(str)
ieşiri adevărat dacă . se termină cu argumentul șir dat.

jq ´[.[]|se termina cu ("foo")]´
[„foobar”, „barfoo”]
=> [fals, adevărat]

combinatii, combinații (n)
Afișează toate combinațiile de elemente ale matricelor din matricea de intrare. Dacă i se oferă un
argument n, scoate toate combinațiile de n repetiții ale tabloului de intrare.

jq „combinații”.
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]

jq ´combinaţii(2)'
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]

ltrimstr(str)
Emite intrarea cu șirul de prefix dat eliminat, dacă începe cu acesta.

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

rtrimstr(str)
Emite intrarea cu șirul de sufix dat eliminat, dacă se termină cu acesta.

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

exploda
Convertește un șir de intrare într-o matrice de numere de puncte de cod ale șirului.

jq 'exploda'
"foobar"
=> [102,111,111,98,97,114]

implozie
Inversul lui explode.

jq „implode”.
[65, 66, 67]
=> "ABC"

împărţi
Împarte un șir de intrare pe argumentul separator.

jq „split(”, „)”.
„a, b, c, d, e,”
=> ["a","b,c,d","e",""]

join(str)
Unește matricea de elemente date ca intrare, folosind argumentul ca separator. Este
invers de împărţi: adică alergare split("foo") | alăturați-vă ("foo") peste orice șir de intrare
returnează șirul de intrare menționat.

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

ascii_downcase, ascii_upcase
Emiteți o copie a șirului de intrare cu caracterele alfabetice (az și AZ) convertite în
cazul specificat.

în timp ce(cond; Actualizați)
în timp ce(cond; Actualizați) funcția vă permite să aplicați în mod repetat o actualizare la . până la Cond
este fals.

Rețineți că în timp ce(cond; Actualizați) este definită intern ca o funcție jq recursivă. Recursiv
apeluri în interior în timp ce nu va consuma memorie suplimentară dacă actualizare produce cel mult unul
ieșire pentru fiecare intrare. Vezi mai jos subiectele avansate.

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

până la (cond; Următorul)
până la (cond; Următorul) funcția vă permite să aplicați în mod repetat expresia următor,
initial sa . apoi la propria sa ieșire, până când Cond este adevarat. De exemplu, acesta poate fi folosit
pentru a implementa o funcție factorială (vezi mai jos).

Rețineți că până la (cond; Următorul) este definită intern ca o funcție jq recursivă. Recursiv
apeluri în interior pana cand() nu va consuma memorie suplimentară dacă următor produce cel mult unul
ieșire pentru fiecare intrare. Vezi mai jos subiectele avansate.

jq ´[.,1]|până la(.[0] < 1; [.[0] - 1, .[1] * .[0]])|.[1]´
4
=> 24

recurs (f), recurs, recurs (f; condiție), recurse_down
recurs (f) funcția vă permite să căutați printr-o structură recursivă și să extrageți
date interesante de la toate nivelurile. Să presupunem că intrarea dvs. reprezintă un sistem de fișiere:

{"nume": "/", "copii": [
{"Nume": "/ cos", "copii": [
{"Nume": "/bin/ls", "copii": []},
{"Nume": "/ Bin / sh", "copii": []}]},
{"Nume": "/ Home", "copii": [
{"nume": "/acasă/stephen", "copii": [
{"nume": "/home/stephen/jq", "copii": []}]}]}]}

Acum să presupunem că doriți să extrageți toate numele de fișiere prezente. Trebuie să recuperați . Nume,
.copii[].nume, .copii[].copii[].nume, și așa mai departe. Puteți face acest lucru cu:

recurs(.copii[]) | .Nume

Când este sunat fără un argument, recurge este echivalent cu recurs(.[]?).

recurs (f) este identic cu recurs (f; . != nul) și poate fi folosit fără griji cu privire la
adâncimea recursiunii.

recurs (f; condiție) este un generator care începe prin a emite . iar apoi emite pe rând
.|f, .|f|f, .|f|f|f, ... atâta timp cât valoarea calculată satisface condiția. Pentru
de exemplu, pentru a genera toate numerele întregi, cel puțin în principiu, s-ar putea scrie recurs(.+1;
Adevărat).

Din motive de moștenire, recurse_down există ca alias pentru apelare recurge fara argumente.
Acest alias este luat în considerare depreciată și va fi eliminat în următoarea versiune majoră.

Recursivul apelează recurge nu va consuma memorie suplimentară oricând f produce la
majoritatea o singură ieșire pentru fiecare intrare.

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

jq „recurs”.
{"a":0,"b":[1]}
=> {"a":0,"b":[1]}, 0, [1], 1

jq „recurs(. * .; . < 20)”.
2
=> 2, 4, 16

..
Mâna scurtă pentru recurge fara argumente. Acesta este destinat să semene cu XPath //
operator. Rețineți că ..și nu funcționează; utilizare ..|a in schimb. În exemplul de mai jos folosim
..|.a? pentru a găsi toate valorile cheilor obiect „a” în orice obiect găsit „mai jos” ..

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

env
Afișează un obiect reprezentând mediul lui jq.

jq ´env.PAGER´
zero
=> "mai putin"

transpune
Transpuneți o matrice posibil zimțată (o matrice de matrice). Rândurile sunt căptușite cu valori nule, astfel încât
rezultatul este întotdeauna dreptunghiular.

jq „transpune”.
[[1], [2,3]]
=> [[1,2],[null,3]]

bsearch(x)
bsearch(x) efectuează o căutare binară pentru x în tabloul de intrare. Dacă intrarea este sortată și
conține x, atunci bsearch(x) va returna indexul său în matrice; în caz contrar, dacă matricea este
sortat, va returna (-1 - ix) unde ix este un punct de inserare astfel încât matricea ar fi
mai fi sortat după introducerea lui x la ix. Dacă matricea nu este sortată, bsearch(x)
va returna un număr întreg care probabil nu prezintă interes.

jq ´bsearch(0)'
[0,1]
=> 0

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

jq ´bsearch(4) ca $ix | daca $ix < 0 atunci .[-(1+$ix)] = 4 else . Sfârșit
[1,2,3]
=> [1,2,3,4]

Şir interpolare - \(foo)
În interiorul unui șir, puteți pune o expresie în interiorul parantelui după o bară oblică inversă. Oricare ar fi
returnările de expresie vor fi interpolate în șir.

jq ´"Intrarea a fost \(.), care este cu o mai mică decât \(.+1)"´
42
=> "Intrarea a fost 42, adică cu unu mai puțin decât 43"

Converti de la JSON
tojson și dinjson încorporate descarcă valorile ca texte JSON sau analizează textele JSON în
valori, respectiv. Incorporarea tojson diferă de tostring prin aceea că tostring returnează
șiruri nemodificate, în timp ce tojson codifică șiruri ca șiruri JSON.

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 siruri și evadarea
@foo sintaxa este folosită pentru a formata și a evada șiruri, ceea ce este util pentru construirea de adrese URL,
documente într-un limbaj precum HTML sau XML și așa mai departe. @foo poate fi folosit ca filtru
proprii, posibilele evadari sunt:

@text:

apeluri tostring, consultați acea funcție pentru detalii.

@json:

Serializează intrarea ca JSON.

@html:

Aplica HTML/XML escape, prin maparea caracterelor <<&´" către entitatea lor
echivalente <, >, &, ', ".

@uri:

Aplică codificarea procentuală, prin maparea tuturor caracterelor URI rezervate la a %XX secvenţă.

@csv:

Intrarea trebuie să fie o matrice și este redată ca CSV cu ghilimele duble pentru
șiruri de caractere și ghilimele scăpate prin repetare.

@tsv:

Intrarea trebuie să fie o matrice și este redată ca TSV (valori separate de tabulatori). Fiecare
matricea de intrare va fi tipărită ca o singură linie. Câmpurile sunt separate printr-o singură filă
(ascii 0x09). Introducerea caracterelor line-feed (ascii 0x0a), retur-căruș (ascii
0x0d), tab (ascii 0x09) și backslash (ascii 0x5c) va fi scos ca escape
Secvențele \n, \r, \t, \\ respectiv.

@SH:

Intrarea este scapă adecvată pentru utilizare într-o linie de comandă pentru un shell POSIX. Dacă
intrarea este o matrice, ieșirea va fi o serie de șiruri separate prin spațiu.

@base64:

Intrarea este convertită în base64, așa cum este specificat de RFC 4648.

Această sintaxă poate fi combinată cu interpolarea șirurilor într-un mod util. Puteți urmări o
@foo jeton cu un șir literal. Conținutul șirului literal va nu fi scăpat.
Cu toate acestea, toate interpolările făcute în interiorul acelui șir literal vor fi scapă. De exemplu,

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

va produce următoarea ieșire pentru intrare {"search":"ce is jq?"}:

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

Rețineți că barele oblice, semnul de întrebare etc. din URL nu sunt excluse, deoarece au făcut parte
a literalului șir.

jq ´@html´
„Acest lucru funcționează dacă x < y”
=> "Acest lucru funcționează dacă x < y"

jq ´@sh „ecou \(.)”´
"O'Hara's Ale"
=> "Echo ´O´\\´´Hara´\\´´s Ale'"

Date
jq oferă unele funcționalități de bază de gestionare a datelor, cu unele de nivel înalt și de nivel scăzut
încorporate. În toate cazurile, aceste integrate se ocupă exclusiv de ora în UTC.

fromdateiso8601 încorporat analizează data și ora în formatul ISO 8601 la un număr de secunde
din epoca Unix (1970-01-01T00:00:00Z). The toarteiso8601 builtin face invers.

din data încorporat analizează șiruri de date și oră. În prezent din data acceptă doar ISO 8601
șiruri de date și oră, dar în viitor va încerca să analizeze șiruri de date și oră în mai multe
formate.

la zi builtin este un alias pentru toarteiso8601.

acum builtin scoate ora curentă, în secunde de la epoca Unix.

De asemenea, sunt furnizate interfețe jq de nivel scăzut pentru funcțiile de timp C-library: strptime,
strftime, mktime, și gmtime. Consultați documentația sistemului de operare gazdă pentru
șiruri de format utilizate de strptime și strftime. Notă: acestea nu sunt neapărat stabile
interfețe în jq, în special în ceea ce privește funcționalitatea lor de localizare.

gmtime builtin consumă un număr de secunde de la epoca Unix și emite un „broken
timp de oprire" reprezentarea timpului ca o matrice de numere reprezentând (în această ordine): the
anul, luna (bazat pe zero), ziua lunii, ora zilei, minutul
ora, secunda din minut, ziua săptămânii și ziua anului -- toate
unică, dacă nu se specifică altfel.

mktime încorporat consumă reprezentări „timp defalcat” ale ieșirii de timp de gmtime
și strptime.

strptime(fmt) încorporat analizează șirurile de intrare care se potrivesc cu fmt argument. Ieșirea este în
reprezentarea „timp defalcat” consumată de gmtime si iesit de mktime.

strftime(fmt) formate încorporate o dată cu formatul dat.

Șirurile de format pentru strptime și strftime sunt descrise în biblioteca tipică C
documentație. Șirul de format pentru ISO 8601 datetime este „%Y-%m-%dT%H:%M:%SZ”.

Este posibil ca jq să nu suporte o parte sau toată această funcționalitate de dată pe unele sisteme.

jq „de la data”.
"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

CONDIȚIONALE AND COMPARAȚII

==, !=
Expresia „a == b” va produce „adevărat” dacă rezultatul lui a și b sunt egali (adică,
dacă reprezintă documente JSON echivalente) și „false” în caz contrar. În special, șiruri
nu sunt niciodată considerate egale cu numerele. Dacă veniți din Javascript, jq's == este ca
Javascript's === - luând în considerare valorile egale numai atunci când au același tip, precum și
aceeași valoare.

!= este „nu este egal”, iar ´a != b´ returnează valoarea opusă a lui ´a == b´

jq ´.[] == 1´
[1, 1.0, „1”, „banană”]
=> adevărat, adevărat, fals, fals

dacă-atunci-altfel
if A apoi B altfel C capăt va acționa la fel ca B if A produce o altă valoare decât false sau
nulă, dar acționează la fel ca C in caz contrar.

Verificarea pentru fals sau nul este o noțiune mai simplă de „adevăr” decât se găsește în Javascript
sau Python, dar înseamnă că uneori va trebui să fiți mai explicit cu privire la condiție
vrei: nu poți testa dacă, de exemplu, un șir este gol folosind if . Nume apoi A altfel B capăt,
vei avea nevoie de ceva mai asemănător if (.Nume | lungime) > 0 apoi A altfel B capăt in schimb.

Dacă condiția A produce rezultate multiple, este considerată „adevărată” dacă oricare dintre acestea
rezultatele nu sunt false sau nule. Dacă produce zero rezultate, este considerat fals.

Mai multe cazuri pot fi adăugate la un dacă se utilizează Elif A apoi B sintaxă.

jq 'dacă . == 0 atunci

„zero” elif . == 1 apoi „unul” alt „multe” sfârşitul´ 2 => „multe”

>, >=, <=, <
Operatorii de comparație >, >=, <=, < returnează dacă argumentul lor din stânga este mai mare decât,
mai mare sau egal cu, mai mic sau egal cu sau mai mic decât argumentul lor corect
(respectiv).

Ordinea este aceeași cu cea descrisă pentru fel, de mai sus.

jq ´. < 5′
2
=> adevărat

și/sau/nu
jq acceptă operatorii booleeni normali și/sau/nu. Ei au același standard de adevăr
ca și cum expresiile - false și null sunt considerate „valori false”, iar orice altceva este a
"valoare adevarata".

Dacă un operand al unuia dintre acești operatori produce rezultate multiple, operatorul însuși
va produce un rezultat pentru fiecare intrare.

nu este de fapt o funcție încorporată mai degrabă decât un operator, așa că este numită ca un filtru pentru
care lucruri pot fi transmise mai degrabă decât cu o sintaxă specială, ca în .foo și .Cafenea | nu.

Aceste trei produc doar valorile „adevărat” și „fals” și, prin urmare, sunt utile doar pentru autentic
Operații booleene, mai degrabă decât limbajul comun Perl/Python/Ruby al
„value_that_may_be_null or default”. Dacă doriți să utilizați această formă de „sau”, alegeți între
două valori în loc să evaluăm o condiție, consultați operatorul „//” de mai jos.

jq ´42 și „un șir”´
zero
=> adevărat

jq „(adevărat, fals) sau fals”.
zero
=> adevărat, fals

jq „(adevărat, adevărat) și (adevărat, fals)”.
zero
=> adevărat, fals, adevărat, fals

jq ´[adevărat, fals | nu
zero
=> [fals, adevărat]

alternativă operator - //
Un filtru al formularului a // b produce aceleași rezultate ca și a, dacă a produce alte rezultate
decât fals și zero. In caz contrar, a // b produce aceleași rezultate ca și b.

Acest lucru este util pentru a furniza valori implicite: .foo // 1 va evalua la 1 daca nu exista .foo
element din intrare. Este asemănător cu cum or este uneori folosit în Python (jq's or operator
este rezervată operațiilor strict booleene).

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

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

încearcă să prinzi
Erorile pot fi detectate prin utilizarea încerca EXP captură EXP. Se execută prima expresie, iar dacă
eșuează apoi al doilea este executat cu mesajul de eroare. Ieșirea handlerului, dacă
orice, este scos ca și cum ar fi fost rezultatul expresiei de încercat.

încerca EXP utilizări de formă gol ca handler de excepție.

jq ´try .o captură ". nu este un obiect"´
adevărat
=> ". nu este un obiect"

jq ´[.[]|încercați .a]´
[{}, adevărat, {"a":1}]
=> [null, 1]

jq ´eroare încercare(„o excepție”) captură .´
adevărat
=> „o excepție”

Breaking afară of Control structurile
O utilizare convenabilă a try/catch este să ieși din structurile de control precum reduce, pentru fiecare,
în timp ce, Și așa mai departe.

De exemplu:

# Repetați o expresie până când ridică „break” ca un
# eroare, apoi opriți repetarea fără a ridica din nou eroarea.
# Dar dacă eroarea surprinsă nu este „break”, atunci ridicați-o din nou.
încercați repeat(exp) catch .=="break" apoi goliți else error;

jq are o sintaxă pentru etichetele lexicale numite pentru a „rupe” sau „du-te (înapoi) la”:

etichetă $out | ... sparge $out ...

rupe $nume_etichetă expresia va face ca programul să acționeze ca și cum cel mai apropiat
(La stânga) etichetă $nume_etichetă produs gol.

Relația dintre rupe și corespunzătoare etichetă este lexical: eticheta trebuie să fie
„vizibil” din pauză.

A ieși dintr-o reduce, de exemplu:

etichetă $out | reduce .[] ca $item (null; if .==false atunci sparge $out else ... sfârșit)

Următorul program jq produce o eroare de sintaxă:

sparge $out

pentru că fără etichetă $out este vizibil.

? operator
? operator, folosit ca EXP?, este prescurtarea pentru încerca EXP.

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

REGULAR EXPRESII (PCRE)

jq folosește biblioteca de expresii regulate Oniguruma, la fel ca php, ruby, TextMate, Sublime Text,
etc, așa că descrierea de aici se va concentra pe specificul jq.

Filtrele jq regex sunt definite astfel încât să poată fi utilizate folosind unul dintre aceste modele:

ȘIR | FILTER( REGEX )
ȘIR | FILTRARE( REGEX; DRAPEURI )
ȘIR | FILTER( [REGEX] )
ȘIR | FILTRARE( [REGEX, FLAGS] )

unde: * STRING, REGEX și FLAGS sunt șiruri jq și supuse interpolării șirurilor jq; *
REGEX, după interpolarea șirurilor de caractere, ar trebui să fie un regex PCRE valid; * FILTER este unul dintre test,
Meci, Sau captura, așa cum este descris mai jos.

FLAGS este un șir format din unul sau mai multe dintre steagurile acceptate:

· g - Căutare globală (găsiți toate potrivirile, nu doar prima)

· i - Căutare fără majuscule

· m - Modul cu mai multe linii (´.´ se va potrivi cu liniile noi)

· n - Ignora meciurile goale

· p - Ambele moduri s și m sunt activate

· s - Mod o singură linie (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - Găsiți cele mai lungi potriviri posibile

· x - Format regex extins (ignorați spațiile albe și comentariile)

Pentru a potrivi spațiul alb într-un model x, utilizați un escape, cum ar fi \s, de ex

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

Rețineți că anumite steaguri pot fi specificate și în cadrul REGEX, de ex

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

evaluează la: adevărat, adevărat, fals, fals.

[Necesită 1.5] test(val), test (regex; steaguri)
Aprecieri Meci, dar nu returnează numai obiecte de potrivire adevărat or fals pentru dacă sau nu
regex se potrivește cu intrarea.

jq „test(„foo”)’
"foo"
=> adevărat

jq ´.[] | test("abc # spații sunt ignorate"; "ix")´
["xabcd", "ABC"]
=> adevărat, adevărat

[Necesită 1.5] potrivire(val), potrivire (regex; steaguri)
Meci scoate un obiect pentru fiecare potrivire pe care o găsește. Potrivirile au următoarele câmpuri:

· compensa - offset în puncte de cod UTF-8 de la începutul intrării

· lungime - lungimea în puncte de cod UTF-8 a meciului

· şir - sfoara cu care se potrivea

· capturi - o serie de obiecte reprezentând grupuri de captare.

Capturarea obiectelor de grup are următoarele câmpuri:

· compensa - offset în puncte de cod UTF-8 de la începutul intrării

· lungime - lungimea în puncte de cod UTF-8 ale acestui grup de captare

· şir - șirul care a fost capturat

· nume - numele grupului de capturare (sau zero dacă era nenumit)

Capturarea grupurilor care nu s-au potrivit cu nimic returnează un offset de -1

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

jq „match(„foo”)”.
"foo bar foo"
=> {"offset": 0, "lungime": 3, "string": "foo", "captures": []}

jq „match([„foo”, „ig”])’
"foo bar FOO"
=> {"offset": 0, "lungime": 3, "string": "foo", "captures": []}, {"offset": 8, "length": 3, "string": "FOO ", "captură": []}

jq ´match("foo (? bar)? foo"; "ig")´
"foo bar foo foo foo"
=> {"offset": 0, "lungime": 11, "string": "foo bar foo", "captures": [{"offset": 4, "length": 3, "string": "bar" , "nume": "bar123"}]}, {"offset": 12, "lungime": 8, "string": "foo foo", "captures": [{"offset": -1, "lungime" : 0, „șir”: nul, „nume”: „bar123”}]}

jq ´[ potrivire("."; "g")] | lungime
"abc"
=> 3

[Necesită 1.5] captura (val), captura (regex; steaguri)
Colectează capturile denumite într-un obiect JSON, cu numele fiecărei capturi ca cheie,
și șirul potrivit ca valoare corespunzătoare.

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

[Necesită 1.5] scanare (regex), scanare (regex; steaguri)
Emiteți un flux de subșiruri care nu se suprapun ale intrării care se potrivesc cu expresia regex în
în conformitate cu steagurile, dacă au fost specificate. Dacă nu există potrivire, fluxul este
gol. Pentru a captura toate potrivirile pentru fiecare șir de intrare, utilizați expresia [ expres ], de exemplu [
scanare (regex) ].

split(regex; steaguri)
Pentru compatibilitate inversă, împărţi se împarte pe un șir, nu pe un regex.

[Necesită 1.5] împărțiri (regex), împărțiri (regex; steaguri)
Acestea oferă aceleași rezultate ca și ale lor împărţi omologii, dar ca un flux în loc de un
matrice.

[Necesită 1.5] sub(regex; tostring) sub(regex; şir; steaguri)
Emiteți șirul obținut prin înlocuirea primei potriviri de regex din șirul de intrare cu
tostring, după interpolare. tostring ar trebui să fie un șir jq și poate conține referințe
la capturi numite. Capturile numite sunt, de fapt, prezentate ca un obiect JSON (cum ar fi
construit de captura) Pentru a tostring, deci o referire la o variabilă capturată numită „x”.
ia forma: „(.x)”.

[Necesită 1.5] gsub(regex; şir), gsub(regex; şir; steaguri)
gsub este ca sub dar toate aparițiile care nu se suprapun ale expresiei regex sunt înlocuite cu
șir, după interpolare.

ADVANCED CARACTERISTICI

Variabilele sunt o necesitate absolută în majoritatea limbajelor de programare, dar sunt retrogradate
la o „funcție avansată” în jq.

În majoritatea limbilor, variabilele sunt singurele mijloace de transmitere a datelor. Dacă calculezi a
valoare și doriți să o utilizați de mai multe ori, va trebui să o stocați într-o variabilă. La
transmiteți o valoare unei alte părți a programului, veți avea nevoie de acea parte a programului
definiți o variabilă (ca parametru de funcție, membru al obiectului sau orice altceva) în care să fie plasată
datele.

De asemenea, este posibil să definiți funcții în jq, deși aceasta este o caracteristică a cărei mai mare
utilizarea este definirea bibliotecii standard a jq (multe funcții jq, cum ar fi Hartă și găsi sunt de fapt
scris în jq).

jq are operatori de reducere, care sunt foarte puternici, dar puțin complicati. Din nou, acestea sunt
folosit în cea mai mare parte intern, pentru a defini câteva biți utile din biblioteca standard a jq.

Poate că nu este evident la început, dar jq este totul despre generatoare (da, așa cum se găsește adesea în
alte limbi). Unele utilități sunt furnizate pentru a ajuta la gestionarea generatoarelor.

Un suport minim de I/O (pe lângă citirea JSON de la intrarea standard și scrierea JSON în
ieșire standard) este disponibilă.

În cele din urmă, există un sistem modul/biblioteca.

Variabile
În jq, toate filtrele au o intrare și o ieșire, așa că nu este necesară instalarea manuală
transmite o valoare de la o parte a unui program la alta. Multe expresii, de exemplu a + b,
transmiteți intrarea lor la două subexpresii distincte (aici a și b ambele sunt trecute la fel
intrare), astfel încât variabilele nu sunt de obicei necesare pentru a utiliza o valoare de două ori.

De exemplu, calcularea valorii medii a unei matrice de numere necesită câteva
variabile în majoritatea limbilor - cel puțin una pentru a deține matricea, poate una pentru fiecare element
sau pentru un numărător de bucle. În jq, este pur și simplu adăuga / lungime - pentru adăuga expresia este dată de
matrice și își produce suma și lungime expresiei i se dă matricei și o produce
lungime.

Deci, există în general o modalitate mai curată de a rezolva majoritatea problemelor în jq decât definirea variabilelor.
Cu toate acestea, uneori fac lucrurile mai ușoare, așa că jq vă permite să definiți variabile folosind
expresie as $variabil. Toate numele variabilelor încep cu $. Iată o versiune puțin mai urâtă
al exemplului de mediere a matricei:

lungime ca $array_length | add / $array_length

Vom avea nevoie de o problemă mai complicată pentru a găsi o situație în care să folosim efectiv variabile
ne face viața mai ușoară.

Să presupunem că avem o serie de postări pe blog, cu câmpuri „autor” și „titlu” și altele
obiect care este folosit pentru a mapa numele de utilizator al autorului cu nume reale. Intrarea noastră arată astfel:

{"posts": [{"title": "Primul psot", "author": "anon"},
{"title": "Un articol bine scris", "autor": "persoana1"}],
"realnames": {"anon": "Laș anonim",
"person1": "Persoana McPherson"}}

Dorim să producem postările cu câmpul autor care conțin un nume real, ca în:

{"title": "Primul psot", "autor": "Laș anonim"}
{"title": "Un articol bine scris", "autor": "Persoana McPherson"}

Folosim o variabilă, $names, pentru a stoca obiectul realnames, astfel încât să ne putem referi la el mai târziu
când căutați numele de utilizator ale autorului:

.nume reale ca $nume | .posturi[] | {titlu, autor: $names[.author]}

Expresia exp as $x | ... înseamnă: pentru fiecare valoare a expresiei exp, rulați restul
conducta cu întreaga intrare originală și cu $x setată la acea valoare. Prin urmare as
funcționează ca o buclă foreach.

Așa cum {foo} este un mod la îndemână de a scrie {foo: .foo}, asa de {$foo} este un mod la îndemână de a scrie
{foo:$foo}.

Pot fi declarate mai multe variabile folosind un singur as exprimare prin furnizarea unui model
care se potrivește cu structura intrării (aceasta este cunoscută sub numele de „destructurare”):

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

Declarațiile de variabile în modele de matrice (de exemplu, . as [$în primul rând, $ secundă]) se leagă de
elementele matricei intră din elementul de la indicele zero în sus, în ordine. Când nu există
valoare la index pentru un element de model de matrice, zero este legat de acea variabilă.

Variabilele sunt acoperite peste restul expresiei care le definește, deci

.nume reale ca $nume | (.posts[] | {titlu, autor: $names[.author]})

va funcționa, dar

(.realnames ca $names | .posts[]) | {titlu, autor: $names[.author]}

nu va.

Pentru teoreticienii limbajului de programare, este mai corect să spunem că variabilele jq sunt
legături cu scop lexical. În special, nu există nicio modalitate de a schimba valoarea unei legături;
se poate configura doar o nouă legare cu același nume, dar care nu va fi vizibilă unde
cel vechi era.

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

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

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

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

Definire funcţii
Puteți da un nume unui filtru folosind sintaxa „def”:

def increment: . + 1;

De atunci înainte, creştere este utilizabil ca filtru la fel ca o funcție încorporată (de fapt, aceasta
este modul în care sunt definite unele dintre elementele încorporate). O funcție poate lua argumente:

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

Argumentele sunt transmise ca filtre, nu ca valori. Se poate face referire la același argument
de mai multe ori cu intrări diferite (aici f este rulat pentru fiecare element al matricei de intrare).
Argumentele unei funcții funcționează mai mult ca apeluri inverse decât ca argumente de valoare. Aceasta este
important de înțeles. Considera:

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

Rezultatul va fi 20 pentru că f is .*2, iar în timpul primei invocari a f . va fi 5,
iar a doua oară va fi 10 (5 * 2), deci rezultatul va fi 20. Argumente ale funcției
sunt filtre, iar filtrele așteaptă o intrare când sunt invocate.

Dacă doriți comportamentul valoare-argument pentru definirea funcțiilor simple, puteți utiliza doar a
variabilă:

def addvalue(f): f ca $f | harta(. + $f);

Sau folosiți mâna scurtă:

def valoare adăugată($f): ...;

Cu oricare dintre definiții, valoare adăugată (.foo) va adăuga intrările curente .foo câmp pentru fiecare
element al matricei.

Sunt permise mai multe definiții folosind același nume de funcție. Fiecare redefinire înlocuiește
cea precedentă pentru același număr de argumente de funcție, dar numai pentru referințe din
funcții (sau program principal) ulterioare redefinirii.

jq ´def valoare adăugată(f): . + [f]; map(adăugare(.[0]))´
[[1,2],[10,20]]
=> [[1,2,1], [10,20,10]]

jq ´def addvalue(f): f ca $x | harta(. + $x); valoare adăugată(.[0])´
[[1,2],[10,20]]
=> [[1,2,1,2], [10,20,1,2]]

Reduce
reduce sintaxa din jq vă permite să combinați toate rezultatele unei expresii prin
acumulându-le într-un singur răspuns. Ca exemplu, vom trece [3,2,1] la acest
expresie:

reduce .[] ca $articol (0; . + $articol)

Pentru fiecare rezultat care .[] produce, . + $item este rulat pentru a acumula un total curent,
începând de la 0. În acest exemplu, .[] produce rezultatele 3, 2 și 1, deci efectul este
similar cu a rula ceva de genul acesta:

0 | (3 ca $articol | . + $articol) |
(2 ca $articol | . + $articol) |
(1 ca $articol | . + $articol)

jq „reduce .[] ca $articol (0; . + $item)”.
[10,2,5,3]
=> 20

limită (n; exp)
limita funcția extrage până la n iesiri din exp.

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

primul (expr), ultimul (expr), al-lea (n; expr)
primul (expr) și ultimul (expr) funcțiile extrag prima și ultima valoare din expres,
respectiv.

al-lea (n; expr) funcția extrage a n-a valoare rezultată de expres. Aceasta poate fi definită ca
Def al-lea (n; expr): ultima(limita(n + 1; expr));. Rețineți că al-lea (n; expr) nu suporta
valori negative ale n.

jq ´[primul(interval(.)), ultimul(interval(.)), nth(./2; interval(.))]´
10
=> [0,9,5]

primul, ultimul, al n-lea(n)
primul și ultimul funcțiile extrag prima și ultima valoare din orice tablou la ..

al n-lea(n) funcția extrage a n-a valoare a oricărei matrice la ..

jq ´[interval(.)]|[primul, ultimul, a n-(5)]'
10
=> [0,9,5]

pentru fiecare
pentru fiecare sintaxa este similară cu reduce, dar destinat să permită construcția de limita
și reductoare care produc rezultate intermediare (vezi exemplu).

Forma este pentru fiecare EXP as $var (INIT; ACTUALIZAȚI; EXTRAGE). Ca reduce, INIT este evaluat
o dată pentru a produce o valoare de stare, apoi fiecare ieșire a EXP este legat de $var, UPDATE is
evaluat pentru fiecare ieșire a EXP cu starea actuală şi cu $var vizibil. Fiecare valoare
ieșire de UPDATE înlocuiește starea anterioară. In cele din urma, EXTRAGE este evaluat pentru fiecare nou
stare pentru a extrage o ieșire din pentru fiecare.

Acest lucru este de cele mai multe ori util doar pentru construcție reduce- și limita-funcții asemănătoare. Dar asta este
mult mai general, deoarece permite reduceri parțiale (vezi exemplul de mai jos).

jq ´[foreach .[] ca $item ([[],[]]; dacă $item == null, atunci [[],.[0]] else [(.[0] + [$item]),[ ]] sfârşit; dacă $item == null, atunci .[1] altfel sfârşitul gol)]´
[1,2,3,4,null,"a","b",null]
=> [[1,2,3,4],["a","b"]]

Recursivitate
Așa cum este descris mai sus, recurge folosește recursiunea și orice funcție jq poate fi recursivă. The
în timp ce builtin este implementat și în termeni de recursivitate.

Apelurile de coadă sunt optimizate ori de câte ori iese expresia din stânga apelurilor recursive
ultima sa valoare. În practică, aceasta înseamnă că expresia din stânga recursivului
apelul nu ar trebui să producă mai mult de o ieșire pentru fiecare intrare.

De exemplu:

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

def while(cond; update):
def _while:
if cond then ., (update | _while) else empty end;
_in timp ce;

def repetare(exp):
def _repeat:
exp, _repetă;
_repeta;

Generatoare și iteratoare
Unii operatori și funcții jq sunt de fapt generatoare prin faptul că pot produce zero,
una sau mai multe valori pentru fiecare intrare, așa cum s-ar putea aștepta în altă programare
limbi care au generatoare. De exemplu, .[] generează toate valorile din intrarea sa
(care trebuie să fie o matrice sau un obiect), interval (0; 10) generează numerele întregi între 0 și
10 și așa mai departe.

Chiar și operatorul virgulă este un generator, generând mai întâi valorile generate de
expresie din stânga virgulei, apoi pentru fiecare dintre acestea, valorile generate de
expresie din dreapta virgulei.

gol builtin este generatorul care produce zero ieșiri. The gol builtin
face înapoi la expresia generatoare precedentă.

Toate funcțiile jq pot fi generatoare doar folosind generatoare încorporate. De asemenea, este posibil
pentru a defini noi generatori folosind doar recursiunea și operatorul virgulă. Dacă recursiv
apelul(ele) este(sunt) „în poziție de coadă”, atunci generatorul va fi eficient. În exemplu
sub apelul recursiv de către _gamă pentru sine este în poziţia de coadă. Exemplul arată
trei subiecte avansate: recursiunea cozii, construcția generatorului și sub-funcții.

jq ´def range(init; upto; by): def _range: if (prin > 0 și . < upto) sau (prin < 0 și . > upto) atunci ., ((.+by)|_range) else . Sfârșit; if by == 0 then init else init|_range end | selectează((cu > 0 și . < până la) sau (cu < 0 și . > până la)); interval (0; 10; 3)´
zero
=> 0, 3, 6, 9

jq ´def while(cond; update): def _while: if cond then ., (update | _while) else empty end; _in timp ce; [în timp ce(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

MATH

jq are în prezent doar suport pentru numere în virgulă mobilă cu precizie dublă IEEE754 (64 de biți).

Pe lângă operatorii aritmetici simpli precum +, jq are, de asemenea, majoritatea funcțiilor matematice standard
din biblioteca de matematică C. C funcții matematice care iau un singur argument de intrare (de exemplu, păcat())
sunt disponibile ca funcții jq cu argument zero. C funcții matematice care necesită două intrări
argumente (de exemplu, pow()) sunt disponibile ca funcții jq cu două argumente care ignoră ..

Disponibilitatea funcțiilor matematice standard depinde de disponibilitatea funcțiilor corespunzătoare
funcții matematice în sistemul dvs. de operare și biblioteca de matematică C. Funcții matematice indisponibile
va fi definit dar va genera o eroare.

I / O

În acest moment, jq are suport minim pentru I/O, mai ales sub formă de control asupra când
intrările sunt citite. Două funcții încorporate sunt prevăzute pentru aceasta, intrare și intrări, care a citit
din aceleași surse (de ex. stdin, fișiere numite pe linia de comandă) ca jq însuși. Aceste
două încorporate și propriile acțiuni de citire ale lui jq pot fi intercalate unul cu celălalt.

Unul încorporat oferă capabilități minime de ieșire, depana. (Reamintim că un program jq
valorile de ieșire sunt întotdeauna afișate ca texte JSON activate stdout.) Cel depana încorporat poate avea
Comportament specific aplicației, cum ar fi executabilele care utilizează libjq C API, dar nu sunt
executabilul jq în sine.

intrare
Emite o intrare nouă.

intrări
Emite toate intrările rămase, una câte una.

Acest lucru este util în primul rând pentru reduceri ale intrărilor unui program.

depana
Determină producerea unui mesaj de depanare bazat pe valoarea de intrare. Executabilul jq împachetează
valoarea de intrare cu ["DEBUG:", ] și imprimă asta și o nouă linie pe stderr,
compact. Acest lucru se poate schimba în viitor.

input_filename
Returnează numele fișierului a cărui intrare este în prezent filtrată. Rețineți că acest lucru va
nu funcționează bine decât dacă jq rulează într-o locație UTF-8.

intrare_număr_linie
Returnează numărul de linie al intrării în curs de filtrare.

FlUXURIlOR

Cu --curent opțiunea jq poate analiza textele de intrare într-un mod de streaming, permițând jq
programe pentru a începe procesarea textelor JSON mari imediat, mai degrabă decât după analizare
completează. Dacă aveți un singur text JSON cu dimensiunea de 1 GB, transmiterea în flux vă va permite
pentru a o procesa mult mai repede.

Cu toate acestea, streamingul nu este ușor de gestionat, așa cum va avea programul jq [ ,
] (și alte câteva forme) ca intrări.

Sunt furnizate mai multe funcții încorporate pentru a ușura gestionarea fluxurilor.

Exemplele de mai jos folosesc forma transmisă în flux a [0,[1]], Care este
[[0],0],[[1,0],1],[[1,0]],[[1]].

Formele de streaming includ [ , ] (pentru a indica orice valoare scalară, matrice goală,
sau obiect gol) și [ ] (pentru a indica sfârșitul unui tablou sau al unui obiect). Viitor
versiunile jq rulează cu --curent și -seq poate scoate forme suplimentare, cum ar fi ["eroare
mesaj"] când un text introdus nu reușește să fie analizat.

truncate_stream(stream_expression)
Consumă un număr ca intrare și trunchiază numărul corespunzător de elemente de cale din
stânga ieșirilor expresiei de streaming date.

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

fromstream(stream_expression)
Afișează valori corespunzătoare rezultatelor expresiei fluxului.

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

a curge
a curge builtin scoate forma transmisă în flux a intrării sale.

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

MISIUNE

Atribuirea funcționează puțin diferit în jq decât în ​​majoritatea limbajelor de programare. jq nu
distinge între referințe și copii ale ceva - două obiecte sau matrice sunt
fie egal, fie nu egal, fără nicio altă noțiune de a fi „același obiect” sau „nu”.
același obiect”.

Dacă un obiect are două câmpuri care sunt tablouri, .foo și .Cafenea, și adăugați ceva la
.foo, Apoi .Cafenea nu va deveni mai mare. Chiar dacă tocmai ai setat .Cafenea = .foo. Daca esti folosit
la programare în limbaje precum Python, Java, Ruby, Javascript etc., atunci vă puteți gândi
ca și cum jq face o copie profundă completă a fiecărui obiect înainte de a face misiunea
(pentru performanță, de fapt nu face asta, dar asta este ideea generală).

Toți operatorii de atribuire din jq au expresii de cale în partea stângă.

=
Filtrul .foo = 1 va lua ca intrare un obiect și va produce ca ieșire un obiect cu
Câmpul „foo” setat la 1. Nu există nicio noțiune de „modificare” sau „schimbare” a ceva în jq -
toate valorile jq sunt imuabile. De exemplu,

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

nu va avea efectul secundar de a seta .bar.baz să fie setat la 1, deoarece are un aspect similar
program în Javascript, Python, Ruby sau alte limbi. Spre deosebire de aceste limbi (dar
precum Haskell și alte limbaje funcționale), nu există noțiune de două matrice sau
obiectele fiind „aceeași matrice” sau „același obiect”. Ele pot fi egale, sau nu egale, dar
dacă îl schimbăm pe unul dintre ele în niciun caz, celălalt nu se va schimba la spatele nostru.

Aceasta înseamnă că este imposibil să construiți valori circulare în jq (cum ar fi un tablou al cărui
primul element este el însuși). Acest lucru este destul de intenționat și asigură că orice este un jq
programul poate produce poate fi reprezentat în JSON.

Rețineți că partea stângă a lui ´=´ se referă la o valoare în .. Prin urmare $var.foo = 1 nu va funcționa
cum era de așteptat ($var.foo nu este o expresie de cale validă sau utilă în .); utilizare $var | .foo = 1
in schimb.

Dacă partea dreaptă a lui ´=´ produce mai multe valori, atunci pentru fiecare astfel de valoare jq va
setați căile din partea stângă la valoarea și apoi va scoate modificată ..
De exemplu, (.a,.b)=gamă(2) iesiri {"a":0,"b":0}, Apoi {"a":1,"b":1}. Actualizarea"
formularele de atribuire (vezi mai jos) nu fac acest lucru.

Notă și asta .a,.b=0 nu se setează .a și .b, Dar (.a,.b)=0 setează ambele.

|=
Pe lângă operatorul de atribuire ´=´, jq furnizează operatorul „actualizare” ´|=´, care
ia un filtru în partea dreaptă și calculează noua valoare pentru proprietatea lui .
fiind atribuit prin rularea vechii valori prin această expresie. De exemplu, .foo |=
.+1 va construi un obiect cu câmpul „foo” setat la „foo” de intrare plus 1.

Acest exemplu ar trebui să arate diferența dintre ´=´ și ´|=´:

Furnizați intrarea ´{"a": {"b": 10}, "b": 20}´ la programele:

.a = .b .a |= .b

Primul va seta câmpul „a” al intrării în câmpul „b” al intrării și va produce
ieșirea {"a": 20}. Acesta din urmă va seta câmpul „a” al intrării la câmpul „a”.
câmpul „b”, producând {„a”: 10}.

Partea din stânga poate fi orice expresie generală a căii; vedea cale().

Rețineți că partea stângă a lui ´|=´ se referă la o valoare în .. Prin urmare $var.foo |= . + 1 nu va
functioneaza conform asteptarilor ($var.foo nu este o expresie de cale validă sau utilă în .); utilizare $var | .foo
|= . + 1 in schimb.

Dacă partea dreaptă emite valori multiple, va fi folosită doar ultima.

jq ´(..|select(type=="boolean")) |= dacă . apoi 1 alt 0 sfârşit'
[adevărat,fals,[5,adevărat,[adevărat,[fals]],fals]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, /=, %=, // =
jq are câțiva operatori de formă a op= b, care sunt toate echivalente cu a |= . op b. Asa de,
+= 1 poate fi folosit pentru a incrementa valori.

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

Complex misiuni
Sunt permise mult mai multe lucruri în partea stângă a unei sarcini jq decât în ​​majoritatea
limbi. Am văzut deja accesări simple pe câmp în partea stângă și nu este
surpriză că accesele la matrice funcționează la fel de bine:

.posts[0].title = „Manual JQ”

Ceea ce poate fi surprinzător este că expresia din stânga poate produce multiple
rezultate, referindu-se la diferite puncte din documentul de intrare:

.postări[].commentarii |= . + [„asta este grozav”]

Acest exemplu adaugă șirul „aceasta este grozav” la matricea „comentarii” a fiecărei postări din
intrarea (unde intrarea este un obiect cu un câmp „posts” care este o matrice de postări).

Când jq întâlnește o sarcină precum „a = b”, înregistrează „calea” luată pentru a selecta o
parte a documentului de intrare în timpul executării a. Această cale este apoi folosită pentru a găsi din ce parte
intrarea să se modifice în timpul executării sarcinii. Orice filtru poate fi utilizat pe
partea stângă a unui egal - oricare dintre căile pe care le selectează din intrare va fi acolo unde
se execută însărcinarea.

Aceasta este o operațiune foarte puternică. Să presupunem că dorim să adăugăm un comentariu la postările de blog, folosind
aceeași intrare „blog” de mai sus. De data aceasta, vrem să comentăm doar postările scrise de
„stedolan”. Putem găsi acele postări folosind funcția „selectare” descrisă mai devreme:

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

Căile oferite de această operațiune indică fiecare dintre postările pe care le-a scris „stedolan” și
putem comenta fiecare dintre ele în același mod în care am făcut-o înainte:

(.posturi[] | select(.author == „stedolan”) | .comments) |=
. + [„teribil.”]

MODULE

jq are un sistem de bibliotecă/module. Modulele sunt fișiere ale căror nume se termină în .jq.

Modulele importate de un program sunt căutate într-o cale de căutare implicită (vezi mai jos). The
import și include directivele permit importatorului să modifice această cale.

Căile din calea de căutare sunt supuse diferitelor înlocuiri.

Pentru căile care încep cu „~/”, directorul principal al utilizatorului este înlocuit cu „~”.

Pentru căile care încep cu „$ORIGIN/”, calea executabilului jq este înlocuită
„$ORIGIN”.

Pentru căile care încep cu „./” sau căile care sunt „.”, calea fișierului inclus este
înlocuit cu „.”. Pentru programele de nivel superior date pe linia de comandă, curentul
directorul este utilizat.

Directivele de import pot specifica opțional o cale de căutare la care este atașată valoarea implicită.

Calea de căutare implicită este calea de căutare dată către -L opțiunea de linie de comandă, altfel
["~/.jq", „$ORIGIN/../lib/jq”, „$ORIGIN/../ lib"].

Elementele de cale de șir nule și goale termină procesarea căii de căutare.

O dependență cu calea relativă „foo/bar” ar fi căutată în „foo/bar.jq” și
„foo/bar/bar.jq” în calea de căutare dată. Acesta este destinat să permită amplasarea modulelor
într-un director împreună cu, de exemplu, fișiere de control al versiunii, fișiere README și așa mai departe,
dar și pentru a permite module cu un singur fișier.

Componentele consecutive cu același nume nu sunt permise pentru a evita ambiguitățile (de exemplu,
„foo/foo”).

De exemplu, cu -L$ACASĂ/.jq un modul foo pot fi găsite în $HOME/.jq/foo.jq și
$HOME/.jq/foo/foo.jq.

Dacă „$HOME/.jq” este un fișier, acesta provine din programul principal.

import RelativePathString as NUME [ ];
Importă un modul găsit la calea dată în raport cu un director dintr-o cale de căutare. Un „.jq”
sufixul va fi adăugat la șirul de cale relativă. Simbolurile modulului sunt prefixate cu
"NUME::".

Metadatele opționale trebuie să fie o expresie jq constantă. Ar trebui să fie un obiect cu chei
cum ar fi „homepage” și așa mai departe. În acest moment, jq folosește doar cheia/valoarea „căutare” a
metadate. Metadatele sunt, de asemenea, puse la dispoziția utilizatorilor prin intermediul modulemeta incorporat.

Tasta „căutare” din metadate, dacă este prezentă, ar trebui să aibă un șir sau o valoare de matrice (array
de șiruri); aceasta este calea de căutare care urmează să fie prefixată la calea de căutare de nivel superior.

include RelativePathString [ ];
Importă un modul găsit la calea dată în raport cu un director dintr-o cale de căutare ca și cum ar fi
au fost incluse pe loc. Un sufix „.jq” va fi adăugat la șirul de cale relativă. The
Simbolurile modulului sunt importate în spațiul de nume al apelantului ca și cum conținutul modulului ar fi avut
fost inclus direct.

Metadatele opționale trebuie să fie o expresie jq constantă. Ar trebui să fie un obiect cu chei
cum ar fi „homepage” și așa mai departe. În acest moment, jq folosește doar cheia/valoarea „căutare” a
metadate. Metadatele sunt, de asemenea, puse la dispoziția utilizatorilor prin intermediul modulemeta incorporat.

import RelativePathString as $NAME [ ];
Importă un fișier JSON găsit la calea dată în raport cu un director dintr-o cale de căutare. A
Sufixul „.json” va fi adăugat la șirul de cale relativă. Datele fișierului vor fi
disponibil ca $NAME::NAME.

Metadatele opționale trebuie să fie o expresie jq constantă. Ar trebui să fie un obiect cu chei
cum ar fi „homepage” și așa mai departe. În acest moment, jq folosește doar cheia/valoarea „căutare” a
metadate. Metadatele sunt, de asemenea, puse la dispoziția utilizatorilor prin intermediul modulemeta incorporat.

Tasta „căutare” din metadate, dacă este prezentă, ar trebui să aibă un șir sau o valoare de matrice (array
de șiruri); aceasta este calea de căutare care urmează să fie prefixată la calea de căutare de nivel superior.

modul ;
Această directivă este în întregime opțională. Nu este necesar pentru o funcționare corectă. Serveste
numai scopul furnizării de metadate care pot fi citite cu modulemeta incorporat.

Metadatele trebuie să fie o expresie jq constantă. Ar trebui să fie un obiect cu chei de genul
"pagina principala". În acest moment, jq nu utilizează aceste metadate, dar sunt puse la dispoziție utilizatorilor
prin intermediul modulemeta incorporat.

modulemeta
Preia un nume de modul ca intrare și scoate metadatele modulului ca obiect, cu
importurile modulelor (inclusiv metadate) ca valoare de matrice pentru cheia „deps”.

Programele pot folosi acest lucru pentru a interoga metadatele unui modul, pentru care apoi le-ar putea folosi
de exemplu, căutați, descărcați și instalați dependențe lipsă.

Utilizați jq online folosind serviciile onworks.net