jq - Online sa Cloud

PROGRAMA:

NAME

jq - Command-line na JSON processor

SINOPSIS

jq [pagpipilian...] filter [file...]

jq maaaring baguhin ang JSON sa iba't ibang paraan, sa pamamagitan ng pagpili, pag-ulit, pagbabawas at iba pa
nakakasira ng mga dokumento ng JSON. Halimbawa, ang pagpapatakbo ng command jq ´mapa(.presyo) | idagdag' habilin
kumuha ng hanay ng mga JSON object bilang input at ibalik ang kabuuan ng kanilang mga field na "presyo".

jq maaari ring tumanggap ng text input, ngunit bilang default, jq nagbabasa ng stream ng mga JSON entity
(kabilang ang mga numero at iba pang literal) mula sa si stdin. Whitespace lang ang kailangan para paghiwalayin
mga entity gaya ng 1 at 2, at totoo at mali. Isa o higit pa file maaaring tukuyin, kung saan
kaso jq magbabasa na lang ng input mula sa mga iyon.

Ang pagpipilian ay inilarawan sa PAGTATANGGI JQ seksyon; karamihan sila ay may kinalaman sa input at output
pag-format Ang filter ay nakasulat sa wikang jq at tinutukoy kung paano baguhin ang
input file o dokumento.

Mga filter

Ang isang jq program ay isang "filter": ito ay nangangailangan ng isang input, at gumagawa ng isang output. Mayroong maraming
builtin na mga filter para sa pagkuha ng isang partikular na field ng isang bagay, o pag-convert ng isang numero sa
isang string, o iba't ibang karaniwang gawain.

Maaaring pagsamahin ang mga filter sa iba't ibang paraan - maaari mong i-pipe ang output ng isang filter
isa pang filter, o kolektahin ang output ng isang filter sa isang array.

Ang ilang mga filter ay gumagawa ng maraming resulta, halimbawa mayroong isa na gumagawa ng lahat ng mga resulta
elemento ng input array nito. Ang pagpi-pipe ng filter na iyon sa isang segundo ay nagpapatakbo ng pangalawang filter para sa
bawat elemento ng array. Sa pangkalahatan, ang mga bagay na gagawin sa mga loop at pag-ulit
sa ibang mga wika ay ginagawa lamang sa pamamagitan ng pagdikit ng mga filter sa jq.

Mahalagang tandaan na ang bawat filter ay may input at output. Kahit literal
tulad ng "hello" o 42 ay mga filter - kumukuha sila ng input ngunit palaging gumagawa ng parehong literal bilang
output. Ang mga operasyong pinagsasama ang dalawang filter, tulad ng karagdagan, ay karaniwang nagpapakain sa parehong input
sa pareho at pagsamahin ang mga resulta. Kaya, maaari kang magpatupad ng isang average na filter bilang idagdag / haba
- pagpapakain sa input array pareho sa idagdag filter at ang haba filter at pagkatapos ay gumaganap
ang dibisyon.

Ngunit iyon ay nauuna sa ating sarili. :) Magsimula tayo sa mas simple:

PAGTATANGGI JQ

Ang mga filter ng jq ay tumatakbo sa isang stream ng data ng JSON. Ang input sa jq ay na-parse bilang isang sequence ng
mga value ng JSON na pinaghihiwalay ng whitespace na ipinapasa sa ibinigay na filter isa sa a
oras. Ang (mga) output ng filter ay isinusulat sa standard out, muli bilang isang sequence ng
data ng JSON na pinaghihiwalay ng whitespace.

Tandaan: mahalagang alalahanin ang mga panuntunan sa pagsipi ng shell. Bilang isang pangkalahatang tuntunin ito ay pinakamahusay na
palaging quote (na may single-quote na mga character) ang jq program, bilang masyadong maraming mga character na may
Ang espesyal na kahulugan ng jq ay mga shell meta-character din. Halimbawa, jq "foo" ay mabibigo sa
karamihan sa mga shell ng Unix dahil iyon ay magiging katulad ng jq foo, na sa pangkalahatan ay mabibigo
dahil sa foo is hindi tinukoy. Kapag gumagamit ng Windows command shell (cmd.exe) pinakamahusay na
gumamit ng double quotes sa paligid ng iyong jq program kapag ibinigay sa command-line (sa halip na ang -f
program-file opsyon), ngunit pagkatapos ay ang double-quotes sa jq program ay nangangailangan ng backslash escaping.

Maaari mong maapektuhan kung paano binabasa at isinusulat ng jq ang input at output nito gamit ang ilang command-line
na pagpipilian:

· --bersyon:

I-output ang jq na bersyon at lumabas na may zero.

· --seq:

Gamitin ang application/json-seq MIME type scheme para sa paghihiwalay ng mga JSON text sa jq's input
at output. Nangangahulugan ito na ang isang character na ASCII RS (record separator) ay naka-print bago
bawat halaga sa output at isang ASCII LF (line feed) ay naka-print pagkatapos ng bawat output. Input
Ang mga text ng JSON na hindi na-parse ay binabalewala (ngunit binigyan ng babala), itinatapon ang lahat
kasunod na input hanggang sa susunod na RS. Ito ay higit na nag-parse sa output ng jq nang walang
--seq pagpipilian.

· --stream:

I-parse ang input sa streaming fashion, na naglalabas ng mga array ng path at mga value ng dahon
(scalar at walang laman na array o walang laman na bagay). Halimbawa, "a" nagiging [[],"a"], at
[[],"a",["b"]] nagiging [[0],[]], [[1],"a"], at [[1,0],"b"].

Ito ay kapaki-pakinabang para sa pagproseso ng napakalaking input. Gamitin ito kasabay ng
pagsasala at ang bawasan at unahan syntax upang bawasan ang malalaking input nang paunti-unti.

· --slurp/-s:

Sa halip na patakbuhin ang filter para sa bawat JSON object sa input, basahin ang buong input
stream sa isang malaking array at patakbuhin ang filter nang isang beses lang.

· --raw input/-R:

Huwag i-parse ang input bilang JSON. Sa halip, ang bawat linya ng text ay ipinapasa sa filter bilang a
string. Kung isasama sa --slurp, pagkatapos ay ipapasa ang buong input sa filter bilang a
solong mahabang string.

· --null-input/-n:

Huwag basahin ang anumang input sa lahat! Sa halip, ang filter ay pinapatakbo kapag ginamit walang halaga bilang input.
Ito ay kapaki-pakinabang kapag gumagamit ng jq bilang isang simpleng calculator o upang bumuo ng JSON data mula sa
kumamot.

· --compact-output / -c:

Bilang default, ang jq pretty-prints JSON output. Ang paggamit sa opsyong ito ay magreresulta sa higit pa
compact na output sa halip na ilagay ang bawat JSON object sa isang linya.

· --tab:

Gumamit ng tab para sa bawat antas ng indentation sa halip na dalawang puwang.

· --indent n:

Gamitin ang ibinigay na bilang ng mga puwang (hindi hihigit sa 8) para sa indentation.

· --kulay-output / -C at --monochrome-output / -M:

Bilang default, ang jq ay naglalabas ng kulay na JSON kung sumusulat sa isang terminal. Maaari mong pilitin ito
gumawa ng kulay kahit na sumusulat sa isang pipe o isang file gamit -C, at huwag paganahin ang kulay gamit ang -M.

· --ascii-output / -a:

Ang jq ay karaniwang naglalabas ng mga non-ASCII Unicode codepoint bilang UTF-8, kahit na tinukoy ang input
ang mga ito bilang mga escape sequence (tulad ng "\u03bc"). Gamit ang opsyong ito, maaari mong pilitin ang jq na
gumawa ng purong ASCII na output na may bawat hindi ASCII na character na pinalitan ng katumbas
pagkakasunud-sunod ng pagtakas.

· --unbuffered

I-flush ang output pagkatapos mai-print ang bawat object ng JSON (kapaki-pakinabang kung mabagal ang pagpi-pipe mo
data source sa jq at piping jq's output sa ibang lugar).

· --sort-keys / -S:

I-output ang mga patlang ng bawat bagay gamit ang mga susi sa pinagsunod-sunod na pagkakasunud-sunod.

· --raw-output / -r:

Sa opsyong ito, kung ang resulta ng filter ay isang string, ito ay direktang isusulat
sa karaniwang output sa halip na ma-format bilang isang JSON string na may mga quote. Maaari itong
maging kapaki-pakinabang para sa paggawa ng mga filter ng jq na makipag-usap sa mga sistemang hindi nakabatay sa JSON.

· --join-output / -j:

katulad -r ngunit ang jq ay hindi magpi-print ng bagong linya pagkatapos ng bawat output.

· -f filename / --mula sa file filename:

Basahin ang filter mula sa file sa halip na mula sa isang command line, tulad ng awk´s -f na opsyon. Ikaw
maaari ding gumamit ng ´#´ para magkomento.

· -Ldirectory / -L direktoryo:

Prepend direktoryo sa listahan ng paghahanap para sa mga module. Kung gagamitin ang opsyong ito, hindi
ginagamit ang builtin na listahan ng paghahanap. Tingnan ang seksyon sa mga module sa ibaba.

· -e / --exit-status:

Itinatakda ang exit status ng jq sa 0 kung ang mga huling halaga ng output ay wala hindi totoo ni walang halaga,
1 kung ang huling halaga ng output ay alinman hindi totoo or walang halaga, o 4 kung walang wastong resulta
ginawa. Karaniwang lumalabas ang jq na may 2 kung mayroong anumang problema sa paggamit o error sa system, 3
kung mayroong isang jq program compile error, o 0 kung ang jq program ay tumakbo.

· --arg pangalan halaga:

Ang opsyong ito ay nagpapasa ng halaga sa jq program bilang isang paunang natukoy na variable. Kung tumakbo ka jq
sa --arg foo bar, Pagkatapos $foo ay magagamit sa programa at may halaga "bar".
Tandaan na ang halaga ay ituturing bilang isang string, kaya --arg foo 123 magbibigkis $foo sa "123".

· --argjson pangalan JSON-text:

Ang opsyong ito ay nagpapasa ng JSON-encoded value sa jq program bilang isang paunang natukoy na variable. Kung
tumakbo ka sa jq kasama --argjson foo 123, Pagkatapos $foo ay magagamit sa programa at mayroong
halaga 123.

· --slurpfile variable-pangalan filename:

Binabasa ng opsyong ito ang lahat ng JSON text sa pinangalanang file at nagbubuklod ng array ng
na-parse ang mga halaga ng JSON sa ibinigay na global variable. Kung nagpapatakbo ka ng jq na may --argfile foo bar,
pagkatapos $foo ay magagamit sa programa at may array na ang mga elemento ay tumutugma sa
ang mga teksto sa file na pinangalanan bar.

· --argfile variable-pangalan filename:

Huwag gamitin. Gamitin --slurpfile sa halip.

(Ang pagpipiliang ito ay tulad ng --slurpfile, ngunit kapag ang file ay may isang text lang, iyon ay
ginamit, kung hindi, isang hanay ng mga teksto ang ginagamit tulad ng sa --slurpfile.)

· --run-tests [filename]:

Pinapatakbo ang mga pagsubok sa ibinigay na file o karaniwang input. Ito dapat ang huling opsyon na ibinigay
at hindi pinarangalan ang lahat ng naunang opsyon. Ang input ay binubuo ng mga linya ng komento, walang laman
mga linya, at mga linya ng programa na sinusundan ng isang linya ng input, kasing dami ng mga linya ng output
inaasahan (isa sa bawat output), at isang pagwawakas na walang laman na linya. Mga pagsubok sa kabiguan ng compilation
magsimula sa isang linya na naglalaman lamang ng "%%FAIL", pagkatapos ay isang linya na naglalaman ng program sa
mag-compile, pagkatapos ay isang linya na naglalaman ng mensahe ng error upang ihambing sa aktwal.

Maging babala na ang opsyong ito ay maaaring magbago pabalik-hindi tugma.

BATAYANG Mga filter

.
Ang pinakasimpleng (at hindi gaanong kawili-wili) na filter ay .. Ito ay isang filter na kumukuha nito
input at ginagawa itong hindi nagbabago bilang output.

Dahil ang jq bilang default ay nagpi-print ng lahat ng output, ang maliit na programang ito ay maaaring maging isang kapaki-pakinabang na paraan ng
pag-format ng output ng JSON mula sa, sabihin nating, kulutan.

jq ´.´
"Hello, mundo!"
=> "Kumusta, mundo!"

.foo, .foo.bar
Ang pinakasimpleng kapaki-pakinabang ang filter ay .foo. Kapag binigyan ng JSON object (aka diksyunaryo o hash) bilang
input, ito ay gumagawa ng halaga sa key na "foo", o null kung walang naroroon.

Kung ang susi ay naglalaman ng mga espesyal na character, kailangan mong palibutan ito ng mga dobleng panipi tulad ng
ito: ."foo$".

Isang filter ng form .foo.bar ay katumbas ng .foo|.bar.

jq ´.foo´
{"foo": 42, "bar": "hindi gaanong kawili-wiling data"}
=> 42

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

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

.foo?
Tulad ng .foo, ngunit hindi naglalabas ng kahit na isang error kapag . ay hindi isang array o isang bagay.

jq ´.foo?´
{"foo": 42, "bar": "hindi gaanong kawili-wiling data"}
=> 42

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

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

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

.[ ], .[2], .[10:15]
Maaari ka ring maghanap ng mga field ng isang object gamit ang syntax like .["foo"] (.foo sa itaas ay a
shorthand na bersyon nito). Gumagana rin ang isang ito para sa mga array, kung ang susi ay isang integer.
Ang mga array ay zero-based (tulad ng javascript), kaya . [2] ibinabalik ang ikatlong elemento ng array.

Ang .[10:15] syntax ay maaaring gamitin upang ibalik ang isang subarray ng isang array o substring ng isang string.
Ang array ay ibinalik ni .[10:15] magiging 5 ang haba, na naglalaman ng mga elemento mula sa index 10
(kasama) hanggang index 15 (eksklusibo). Maaaring negatibo ang alinmang index (kung saan ito ay binibilang
pabalik mula sa dulo ng array), o tinanggal (kung saan ito ay tumutukoy sa simula o
dulo ng array).

Ang . [2] syntax ay maaaring gamitin upang ibalik ang elemento sa ibinigay na index. Ang mga negatibong indeks ay
pinapayagan, na may -1 na tumutukoy sa huling elemento, -2 na tumutukoy sa susunod sa huling elemento,
at iba pa.

Ang .foo Gumagana lamang ang syntax para sa mga simpleng key ie mga key na pawang mga alphanumeric na character.
.[ ] gumagana sa mga key na naglalaman ng mga espesyal na character tulad ng mga tutuldok at tuldok. Para sa
halimbawa .["foo::bar"] at .["foo.bar"] magtrabaho habang .foo::bar at .foo.bar Hindi gagawin.

Ang ? Ang "operator" ay maaari ding gamitin sa slice operator, gaya ng sa .[10:15]?, na naglalabas
mga halaga kung saan ang mga input ay 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}]
=> null

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

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

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

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

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

.[]
Kung gagamitin mo ang .[index] syntax, ngunit ganap na alisin ang index, babalik ito lahat ng
mga elemento ng isang array. Tumatakbo .[] kasama ang input [1,2,3] gagawa ng mga numero bilang tatlo
hiwalay na mga resulta, sa halip na bilang isang array.

Maaari mo ring gamitin ito sa isang bagay, at ibabalik nito ang lahat ng mga halaga ng bagay.

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

.[]?
katulad .[], ngunit walang mga error na ilalabas kung . ay hindi isang array o object.

,
Kung ang dalawang filter ay pinaghihiwalay ng kuwit, ang input ay ipapakain sa pareho at doon
ay magiging maramihang mga output: una, lahat ng mga output na ginawa ng kaliwang expression, at
pagkatapos ang lahat ng mga output na ginawa ng kanan. Halimbawa, salain .foo, .Cafe, gumagawa
parehong mga field na "foo" at "bar" bilang magkahiwalay na mga output.

jq ´.foo, .bar´
{"foo": 42, "bar": "something else", "baz": true}
=> 42, "iba pa"

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

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

|
Ang | Pinagsasama ng operator ang dalawang filter sa pamamagitan ng pagpapakain sa (mga) output ng isa sa kaliwa
ang input ng nasa kanan. Ito ay halos kapareho ng pipe ng Unix shell, kung
nakasanayan mo na yan.

Kung ang isa sa kaliwa ay gumagawa ng maraming mga resulta, ang isa sa kanan ay tatakbo para sa
bawat isa sa mga resultang iyon. Kaya, ang expression .[] | .foo kinukuha ang field na "foo" ng bawat isa
elemento ng input array.

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

MGA uRI AT Mga halaga

Sinusuportahan ng jq ang parehong hanay ng mga datatype tulad ng JSON - mga numero, string, boolean, array,
mga bagay (na sa JSON-speak ay mga hash na may lamang string keys), at "null".

Ang mga Boolean, null, string at numero ay isinulat sa parehong paraan tulad ng sa javascript. Kagaya ng
lahat ng iba pa sa jq, ang mga simpleng halagang ito ay kumukuha ng input at gumagawa ng output - 42 ay isang
wastong jq expression na kumukuha ng input, binabalewala ito, at nagbabalik ng 42 sa halip.

Ayos konstruksyon - []
Tulad ng sa JSON, [] ay ginagamit upang bumuo ng mga array, tulad ng sa [1,2,3]. Ang mga elemento ng array ay maaari
maging anumang jq expression. Ang lahat ng mga resulta na ginawa ng lahat ng mga expression ay nakolekta
sa isang malaking hanay. Maaari mo itong gamitin upang bumuo ng isang array mula sa isang kilalang dami ng mga halaga
(tulad ng sa [.foo, .bar, .baz]) o upang "kolektahin" ang lahat ng mga resulta ng isang filter sa isang array (bilang
in [.items[].name])

Kapag naunawaan mo na ang "," operator, maaari mong tingnan ang jq's array syntax sa ibang
liwanag: ang ekspresyon [1,2,3] ay hindi gumagamit ng built-in na syntax para sa comma-separated arrays,
ngunit sa halip ay inilalapat ang [] operator (mangolekta ng mga resulta) sa expression na 1,2,3 (na
gumagawa ng tatlong magkakaibang resulta).

Kung mayroon kang isang filter X na gumagawa ng apat na resulta, pagkatapos ay ang expression [X] ay bubuo ng a
solong resulta, isang hanay ng apat na elemento.

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

bagay - {}
Tulad ni JSON, {} ay para sa pagbuo ng mga bagay (aka mga diksyunaryo o hash), tulad ng sa: {"a": 42,
"b": labintatlo}.

Kung ang mga susi ay "makatwiran" (lahat ng mga alphabetic na character), maaaring iwanan ang mga quote.
Ang halaga ay maaaring anumang expression (bagaman maaaring kailanganin mong balutin ito sa mga panaklong kung ito ay
kumplikado), na inilalapat sa input ng expression ng {} (tandaan, lahat ng mga filter
may input at output).

{foo: .bar}

gagawa ng JSON object {"foo": labintatlo} kung bibigyan ng JSON object {"bar":42, "baz":43}.
Magagamit mo ito upang pumili ng mga partikular na field ng isang object: kung ang input ay isang object na may
"user", "title", "id", at "content" fields at gusto mo lang ng "user" at "title", maaari mong
magsulat

{user: .user, title: .title}

Dahil ito ay karaniwan, mayroong isang shortcut syntax: {user, pamagat}.

Kung ang isa sa mga expression ay naglalabas ng maraming resulta, marami ang mga diksyunaryo
ginawa. Kung ang input's

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

tapos yung expression

{user, pamagat: .titles[]}

gagawa ng dalawang output:

{"user":"stedolan", "title": "JQ Primer"}
{"user":"stedolan", "title": "Higit pang JQ"}

Ang paglalagay ng mga panaklong sa paligid ng susi ay nangangahulugan na ito ay susuriin bilang isang expression. Kasama ang
parehong input tulad ng nasa itaas,

{(.user): .titles}

naglalabas

{"stedolan": ["JQ Primer", "Higit pang JQ"]}

jq ´{user, pamagat: .titles[]}´
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
=> {"user":"stedolan", "title": "JQ Primer"}, {"user":"stedolan", "title": "Higit pang JQ"}

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

BUILTIN OPERATOR AT Mga function

Ilang jq operator (halimbawa, +) gumawa ng iba't ibang bagay depende sa uri ng kanilang
mga argumento (mga array, numero, atbp.). Gayunpaman, ang jq ay hindi kailanman gumagawa ng mga implicit na uri ng mga conversion. Kung
subukan mong magdagdag ng isang string sa isang bagay makakakuha ka ng isang mensahe ng error at walang resulta.

Dagdag - +
Ang namamahala + tumatagal ng dalawang filter, inilalapat ang mga ito pareho sa parehong input, at idinaragdag ang
magkakasamang resulta. Ang ibig sabihin ng "pagdaragdag" ay depende sa mga uri na kasangkot:

· Numero ay idinagdag ng normal na arithmetic.

· Mga Arrays ay idinagdag sa pamamagitan ng pagsasama-sama sa isang mas malaking array.

· String ay idinagdag sa pamamagitan ng pagsasama sa isang mas malaking string.

· bagay ay idinagdag sa pamamagitan ng pagsasama, ibig sabihin, pagpasok ng lahat ng mga pares ng key-value mula sa pareho
mga bagay sa isang pinagsamang bagay. Kung ang parehong mga bagay ay naglalaman ng isang halaga para sa pareho
key, ang bagay sa kanan ng + panalo. (Para sa recursive merge gamitin ang * operator.)

walang halaga maaaring idagdag sa anumang halaga, at ibinabalik ang iba pang halaga nang hindi nagbabago.

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

Pagbabawas - -
Pati na rin ang normal na pagbabawas ng arithmetic sa mga numero, ang - operator ay maaaring gamitin sa arrays
upang alisin ang lahat ng mga paglitaw ng mga elemento ng pangalawang array mula sa unang array.

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

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

pagpaparami, paghati, anyo - *, /, at %
Ang mga infix operator na ito ay kumikilos gaya ng inaasahan kapag binigyan ng dalawang numero. Dibisyon sa pamamagitan ng zero na pagtaas
isang error. x % y kinakalkula ang x modulo y.

Ang pag-multiply ng isang string sa isang numero ay nagbubunga ng pagsasama-sama ng string na iyon na marami
beses. "x" * 0 naglalabas walang halaga.

Ang paghahati ng isang string sa isa pang paghahati sa una gamit ang pangalawa bilang mga separator.

Ang pagpaparami ng dalawang bagay ay pagsasamahin ang mga ito nang pabalik-balik: ito ay gumagana tulad ng karagdagan ngunit kung pareho
ang mga bagay ay naglalaman ng isang halaga para sa parehong susi, at ang mga halaga ay mga bagay, ang dalawa ay pinagsama
na may parehong diskarte.

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}}´
walang halaga
=> {"k": {"a": 0, "b": 2, "c": 3}}

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

haba
Ang builtin function haba nakakakuha ng haba ng iba't ibang uri ng halaga:

· Ang haba ng a pisi ay ang bilang ng mga Unicode codepoint na nilalaman nito (na magiging
kapareho ng haba nito na naka-encode ng JSON sa mga byte kung ito ay purong ASCII).

· Ang haba ng isang ayos ay ang bilang ng mga elemento.

· Ang haba ng isang bagay ay ang bilang ng mga pares ng key-value.

· Ang haba ng walang halaga ay zero.

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

mga susi, keys_unsorted
Ang builtin function mga susi, kapag binigyan ng isang bagay, ibinabalik ang mga susi nito sa isang array.

Ang mga susi ay pinagsunod-sunod nang "alphabetically", ayon sa pagkakasunud-sunod ng unicode codepoint. Ito ay hindi isang utos
na may partikular na kahulugan sa anumang partikular na wika, ngunit maaasahan mo ito bilang ang
pareho para sa anumang dalawang bagay na may parehong hanay ng mga susi, anuman ang mga setting ng lokal.

Kailan mga susi ay binibigyan ng array, ibinabalik nito ang mga wastong indeks para sa array na iyon: ang mga integer
mula 0 hanggang haba-1.

Ang keys_unsorted function ay tulad ng mga susi, ngunit kung ang input ay isang bagay kung gayon ang mga susi
ay hindi pagbubukud-bukod, sa halip ang mga susi ay halos nasa insertion order.

jq 'mga susi'
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Foo", "abc", "abcd"]

jq 'mga susi'
[42,3,35]
=> [0,1,2]

may (susi)
Ang builtin function ay nagbabalik kung ang input object ay may ibinigay na key, o ang input
Ang array ay may elemento sa ibinigay na index.

may($key) ay may parehong epekto sa pagsuri kung $key ay isang miyembro ng array na ibinalik
by mga susi, bagaman ay magiging mas mabilis.

jq ´mapa(may("foo"))´
[{"foo": 42}, {}]
=> [totoo, mali]

jq ´mapa(ay(2))´
[[0,1], ["a","b","c"]]
=> [mali, totoo]

in
Ang builtin function in ibinabalik ang input key ay nasa ibinigay na bagay, o ang input index
tumutugma sa isang elemento sa ibinigay na array. Ito ay, mahalagang, isang baligtad na bersyon ng
ay.

jq ´.[] | sa({"foo": 42})´
["foo", "bar"]
=> totoo, mali

jq ´mapa(sa([0,1]))´
[2, 0]
=> [mali, totoo]

landas(path_expression)
Naglalabas ng mga representasyon ng array ng ibinigay na expression ng path sa .. Ang mga output ay mga arrays ng
mga string (mga susi sa mga bagay0 at/o mga numero (mga indeks ng array.

Ang mga expression ng path ay tulad ng mga expression ng jq .a, Ngunit din .[]. Mayroong dalawang uri ng landas
mga expression: mga maaaring tumugma nang eksakto, at mga hindi maaaring. Halimbawa, .abc ay isang
eksaktong tugma na expression ng path, habang .a[].b ay hindi.

path(exact_path_expression) gagawa ng array representation ng path expression
kahit na wala ito sa ., Kung . is walang halaga o isang array o isang bagay.

landas (pattern) gagawa ng array representasyon ng mga path na tumutugma huwaran kung ang
ang mga landas ay umiiral sa ..

Tandaan na ang mga expression ng path ay hindi naiiba sa mga normal na expression. Ang ekspresyon
path(..|select(type=="boolean")) output ang lahat ng mga path sa boolean value in ., at lamang
ang mga landas na iyon.

jq ´path(.a[0].b)´
walang halaga
=> ["a",0,"b"]

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

del(path_expression)
Ang builtin function del inaalis ang isang susi at ang katumbas na halaga nito mula sa isang bagay.

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

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

to_entry, from_entry, with_entry
Ang mga function na ito ay nagko-convert sa pagitan ng isang bagay at isang hanay ng mga pares ng key-value. Kung to_entry
ay ipinasa ang isang bagay, pagkatapos ay para sa bawat isa k: v entry sa input, kasama ang output array
{"key": k, "halaga": v}.

from_entry ginagawa ang kabaligtaran ng conversion, at with_entry(foo) ay isang shorthand para sa
to_entry | mapa(foo) | from_entry, kapaki-pakinabang para sa paggawa ng ilang operasyon sa lahat ng mga susi at
mga halaga ng isang bagay. from_entry tumatanggap ng susi, Susi, Pangalan, halaga at Halaga bilang mga susi.

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

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

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

piliin ang(boolean_expression)
Ang function na piliin(foo) gumagawa ng input nito na hindi nagbabago kung foo nagbabalik ng true para sa input na iyon,
at hindi gumagawa ng output kung hindi man.

Ito ay kapaki-pakinabang para sa pag-filter ng mga listahan: [1,2,3] | mapa(piliin(. >= 2)) bibigyan ka [2,3].

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

jq ´.[] | piliin ang(.id == "pangalawa")´
[{"id": "first", "val": 1}, {"id": "second", "val": 2}]
=> {"id": "pangalawa", "val": 2}

array, mga bagay, iterables, mga boolean, numero, normal, may hangganan, mga string, nulls, mga halaga,
mga scalar
Ang mga built-in na ito ay pumipili lamang ng mga input na mga array, object, iterable (arrays o
mga bagay), boolean, numero, normal na numero, may hangganang numero, string, null, non-null
values, at non-iterables, ayon sa pagkakabanggit.

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

walang laman
walang laman walang ibinabalik na resulta. Wala naman. Hindi man walang halaga.

Ito ay kapaki-pakinabang sa okasyon. Malalaman mo kung kailangan mo :)

jq ´1, walang laman, 2´
walang halaga
=> 1, 2

jq ´[1,2,walang laman,3]´
walang halaga
=> [1,2,3]

mali(mensahe)
Gumagawa ng isang error, tulad ng .a inilapat sa mga halaga maliban sa null at gagawin ng mga bagay, ngunit
na may ibinigay na mensahe bilang halaga ng error.

$__loc__
Gumagawa ng object na may "file" key at "line" key, na may filename at line number
saan $__loc__ nangyayari, bilang mga halaga.

jq ´try error("\($__loc__)") catch .´
walang halaga
=> "{\"file\":\" \",\"linya\":1}"

mapa(x), map_values(x)
Para sa anumang filter x, mapa(x) ay tatakbo sa filter na iyon para sa bawat elemento ng input array, at
gumawa ng mga output ng isang bagong array. mapa(.+1) ay dagdagan ang bawat elemento ng isang array ng
mga numero.

Katulad nito, map_values(x) ay magpapatakbo ng filter na iyon para sa bawat elemento, ngunit magbabalik ito ng isang
bagay kapag may ipinasa na bagay.

mapa(x) ay katumbas ng [.[] | x]. Sa katunayan, ito ay kung paano ito tinukoy. Katulad nito,
map_values(x) ay tinukoy bilang .[] |= x.

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

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

mga landas, mga landas (node_filter), leaf_paths
mga landas output ang mga landas sa lahat ng mga elemento sa input nito (maliban kung hindi ito naglalabas ng
walang laman na listahan, na kumakatawan sa . mismo).

mga landas(f) output ang mga path sa anumang mga halaga kung saan f ay totoo. Yan ay, mga landas (mga numero)
output ang mga path sa lahat ng mga numerong halaga.

leaf_paths ay isang alyas ng mga landas (scalar); leaf_paths is hindi na ginagamit at aalisin sa
ang susunod na major release.

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

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

idagdag
Ang filter idagdag tumatagal bilang input ng isang array, at gumagawa bilang output ng mga elemento ng array
idinagdag nang sama-sama. Ito ay maaaring mangahulugan ng summed, concatenated o merged depende sa mga uri ng
ang mga elemento ng input array - ang mga patakaran ay pareho sa para sa + opereytor
(inilarawan sa itaas).

Kung ang input ay isang walang laman na array, idagdag Babalik walang halaga.

jq 'dagdag'
["a","b","c"]
=> "abc"

jq 'dagdag'
[1, 2, 3]
=> 6

jq 'dagdag'
[]
=> null

kahit ano, anumang (kondisyon), anumang(generator; kondisyon)
Ang filter anumang tumatagal bilang input ang isang array ng mga boolean value, at gumagawa totoo bilang output kung
alinman sa mga elemento ng array ay totoo.

Kung ang input ay isang walang laman na array, anumang Babalik hindi totoo.

Ang anumang (kondisyon) inilalapat ng form ang ibinigay na kondisyon sa mga elemento ng array ng input.

Ang anumang(generator; kondisyon) inilalapat ng form ang ibinigay na kondisyon sa lahat ng mga output ng
binigay na generator.

jq 'kahit ano'
[totoo, mali]
=> totoo

jq 'kahit ano'
[false, false]
=> mali

jq 'kahit ano'
[]
=> mali

lahat, lahat (kondisyon), lahat(generator; kondisyon)
Ang filter lahat tumatagal bilang input ang isang array ng mga boolean value, at gumagawa totoo bilang output kung
lahat ng mga elemento ng array ay totoo.

Ang lahat(kondisyon) inilalapat ng form ang ibinigay na kondisyon sa mga elemento ng array ng input.

Ang lahat(generator; kondisyon) inilalapat ng form ang ibinigay na kondisyon sa lahat ng mga output ng
binigay na generator.

Kung ang input ay isang walang laman na array, lahat Babalik totoo.

jq 'lahat'
[totoo, mali]
=> mali

jq 'lahat'
[totoo totoo]
=> totoo

jq 'lahat'
[]
=> totoo

[Nangangailangan 1.5] patagin, patagin (lalim)
Ang filter patagin kumukuha bilang input ng array ng mga nested array, at gumagawa ng flat array in
na ang lahat ng mga array sa loob ng orihinal na array ay recursively na pinalitan ng kanilang mga halaga.
Maaari mong ipasa ang isang argument dito upang tukuyin kung gaano karaming mga antas ng nesting ang papatag.

patagin(2) ay tulad ng patagin, ngunit umabot lamang sa dalawang antas ang lalim.

jq 'patagin'
[1, [2], [[3]]]
=> [1, 2, 3]

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

jq 'patagin'
[[]]
=> []

jq 'patagin'
[{"foo": "bar"}, [{"foo": "baz"}]]
=> [{"foo": "bar"}, {"foo": "baz"}]

saklaw (hanggang sa), saklaw(mula sa;hanggang) saklaw(mula sa;hanggang;ni)
Ang saklaw ang function ay gumagawa ng isang hanay ng mga numero. saklaw(4;10) gumagawa ng 6 na numero, mula sa 4
(kasama) hanggang 10 (eksklusibo). Ang mga numero ay ginawa bilang hiwalay na mga output. Gamitin
[saklaw(4;10)] para makakuha ng range bilang array.

Ang isang form ng argumento ay bumubuo ng mga numero mula 0 hanggang sa ibinigay na numero, na may pagtaas ng
1.

Ang dalawang form ng argumento ay bumubuo ng mga numero mula sa mula sa hanggang na may dagdag na 1.

Ang tatlong form ng argumento ay bumubuo ng mga numero mula sa hanggang na may pagtaas ng by.

jq ´saklaw(2;4)´
walang halaga
=> 2, 3

jq ´[saklaw(2;4)]´
walang halaga
=> [2,3]

jq ´[saklaw(4)]´
walang halaga
=> [0,1,2,3]

jq ´[saklaw(0;10;3)]´
walang halaga
=> [0,3,6,9]

jq ´[saklaw(0;10;-1)]´
walang halaga
=> []

jq ´[saklaw(0;-5;-1)]´
walang halaga
=> [0,-1,-2,-3,-4]

palapag
Ang palapag ibinabalik ng function ang floor ng numeric input nito.

jq 'sahig'
3.14159
=> 3

sqrt
Ang sqrt ibinabalik ng function ang square root ng numeric input nito.

jq ´sqrt´
9
=> 3

tonumber
Ang tonumber pinapa-parse ng function ang input nito bilang isang numero. Ito ay magko-convert nang tama-format
string sa kanilang numeric equivalent, iwanan ang mga numero, at magbigay ng error sa lahat ng iba pa
input.

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

tostring
Ang tostring Ang function ay nagpi-print ng input nito bilang isang string. Ang mga string ay hindi nababago, at lahat
ang ibang mga value ay JSON-encoded.

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

uri
Ang uri Ibinabalik ng function ang uri ng argument nito bilang isang string, na isa sa null,
boolean, numero, string, array o object.

jq ´mapa(uri)´
[0, false, [], {}, null, "hello"]
=> ["numero", "boolean", "array", "object", "null", "string"]

walang katapusan, nan, walang hanggan, isnan, walang katapusan, Ay normal
Ang ilang mga pagpapatakbo ng arithmetic ay maaaring magbunga ng mga infinity at "hindi isang numero" (NaN) na mga halaga. Ang
walang katapusan builtin returns totoo kung ang input nito ay walang katapusan. Ang isnan builtin returns totoo
kung ang input nito ay isang NaN. Ang walang katapusan ang builtin ay nagbabalik ng positibong walang katapusang halaga. Ang nan
ang builtin ay nagbabalik ng isang NaN. Ang Ay normal Ang builtin ay nagbabalik ng true kung ang input nito ay isang normal na numero.

Tandaan na ang paghahati sa zero ay nagdudulot ng error.

Sa kasalukuyan, karamihan sa mga pagpapatakbo ng aritmetika na tumatakbo sa mga infinity, NaN, at sub-normal ay hindi gumagana
itaas ang mga pagkakamali.

jq ´.[] | (walang hanggan * .) < 0´
[-labing isang]
=> totoo, mali

jq ´walang katapusan, nan | uri'
walang halaga
=> "numero", "numero"

pag-uuri, sort_by(path_expression)
Ang uri inaayos ng mga function ang input nito, na dapat ay isang array. Ang mga halaga ay pinagsunod-sunod sa
sumusunod na pagkakasunud-sunod:

· walang halaga

· hindi totoo

· totoo

· numero

· mga string, sa alpabetikong pagkakasunud-sunod (sa pamamagitan ng unicode codepoint value)

· arrays, sa lexical order

· mga bagay

Ang pag-order para sa mga bagay ay medyo kumplikado: una sila ay inihambing sa pamamagitan ng paghahambing ng kanilang
mga hanay ng mga susi (bilang mga array sa pinagsunod-sunod na pagkakasunud-sunod), at kung ang kanilang mga susi ay pantay, ang mga halaga ay
inihambing ang susi sa susi.

uri ay maaaring gamitin upang pag-uri-uriin ayon sa isang partikular na field ng isang bagay, o sa pamamagitan ng paglalapat ng anumang jq filter.

sort_by(foo) naghahambing ng dalawang elemento sa pamamagitan ng paghahambing ng resulta ng foo sa bawat elemento.

jq 'pag-uuri'
[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(path_expression)
group_by(.foo) tumatagal bilang input ng array, pinapangkat ang mga elementong may pareho .foo parang
sa magkahiwalay na mga array, at gumagawa ng lahat ng mga array na ito bilang mga elemento ng mas malaking array,
pinagsunod-sunod ayon sa halaga ng .foo na patlang.

Anumang jq expression, hindi lamang isang field access, ay maaaring gamitin bilang kapalit ng .foo. Ang pag-uuri
ang pagkakasunud-sunod ay pareho sa inilarawan sa uri function sa itaas.

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(path_exp)
Hanapin ang minimum o maximum na elemento ng input array.

Ang min_by(path_exp) at max_by(path_exp) pinahihintulutan ka ng mga function na tukuyin ang isang partikular
patlang o ari-arian na susuriin, hal min_by(.foo) hinahanap ang bagay na may pinakamaliit foo
na patlang.

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

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

natatanging, unique_by(path_exp)
Ang kakaiba Ang function ay tumatagal bilang input ng array at gumagawa ng array ng parehong mga elemento, in
pinagsunod-sunod na pagkakasunud-sunod, na may mga duplicate na inalis.

Ang unique_by(path_exp) Ang function ay magpapanatili lamang ng isang elemento para sa bawat halaga na nakuha ng
paglalapat ng argumento. Isipin ito bilang paggawa ng array sa pamamagitan ng pagkuha ng isang elemento sa bawat isa
pangkat na ginawa ng grupo.

jq 'natatangi'
[1,2,5,3,5,3,1,3]
=> [1,2,3,5]

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

jq ´natatangi_sa(haba)´
["chunky", "bacon", "kuting", "cicada", "asparagus"]
=> ["bacon", "chunky", "asparagus"]

baligtarin
Binabaliktad ng function na ito ang isang array.

jq 'baligtad'
[1,2,3,4]
=> [4,3,2,1]

naglalaman ng(elemento)
Ang filter naglalaman ng(b) gagawa ng totoo kung ang b ay ganap na nakapaloob sa loob ng input. A
Ang string B ay nakapaloob sa isang string A kung ang B ay isang substring ng A. Ang isang array B ay nakapaloob sa
isang array A kung ang lahat ng mga elemento sa B ay nakapaloob sa anumang elemento sa A. Ang isang bagay B ay
nakapaloob sa bagay A kung ang lahat ng mga halaga sa B ay nakapaloob sa halaga sa A na may
parehong susi. Ang lahat ng iba pang mga uri ay ipinapalagay na nakapaloob sa bawat isa kung sila ay pantay.

jq ´naglalaman("bar")´).
"foobar"
=> totoo

jq ´naglalaman(["baz", "bar"])´
["foobar", "foobaz", "blarp"]
=> totoo

jq ´naglalaman ng(["bazzzzz", "bar"])´
["foobar", "foobaz", "blarp"]
=> mali

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

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

(mga) indeks
Naglalabas ng array na naglalaman ng mga indeks sa . saan s nangyayari. Ang input ay maaaring isang array, in
aling kaso kung s ay isang array kung gayon ang mga indeks na output ay ang mga kung saan ang lahat ng mga elemento ay nasa .
tumugma sa mga s.

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

jq ´mga indeks ng(1)´
[0,1,2,1,3,1,4]
=> [1,3,5]

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

(mga) index, rindex(s)
Naglalabas ng index ng una (index) o huli (rindex) paglitaw ng s sa input.

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

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

loob
Ang filter sa loob(b) ay magbubunga ng totoo kung ang input ay ganap na nakapaloob sa loob ng b. Ito
ay, mahalagang, isang baligtad na bersyon ng naglalaman ng.

jq ´sa loob("foobar")´).
"bar"
=> totoo

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

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

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

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

nagsisimula sa(str)
Output totoo kung . nagsisimula sa ibinigay na argumentong string.

jq ´[.[]|nagsisimula sa("foo")]´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [false, true, false, true, false]

nagtatapos sa(str)
Output totoo kung . nagtatapos sa ibinigay na argumentong string.

jq ´[.[]|nagtatapos sa("foo")]´
["foobar", "barfoo"]
=> [mali, totoo]

mga kumbinasyon, kumbinasyon(n)
Naglalabas ng lahat ng kumbinasyon ng mga elemento ng mga array sa input array. Kung bibigyan ng
argumento n, inilalabas nito ang lahat ng kumbinasyon ng n pag-uulit ng input array.

jq 'mga kumbinasyon'
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]

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

ltrimstr(str)
Inilalabas ang input nito nang inalis ang ibinigay na string ng prefix, kung magsisimula ito dito.

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

rtrimstr(str)
Ilalabas ang input nito nang inalis ang ibinigay na string ng suffix, kung nagtatapos ito dito.

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

sumabog
Kino-convert ang isang input string sa isang array ng mga codepoint number ng string.

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

sumabog
Ang kabaligtaran ng sumabog.

jq 'sumibog'
[65, 66, 67]
=> "ABC"

pagsibak
Naghahati ng input string sa separator argument.

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

sumali (str)
Sumasali sa hanay ng mga elemento na ibinigay bilang input, gamit ang argumento bilang separator. Ito ay ang
kabaligtaran ng pagsibak: ibig sabihin, tumatakbo split("foo") | sumali ("foo") sa anumang input string
ibinabalik ang nasabing input string.

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

ascii_downcase, ascii_upcase
Maglabas ng kopya ng input string na may mga alphabetic na character (az at AZ) na na-convert sa
ang tinukoy na kaso.

habang(cond; update)
Ang habang(cond; update) Binibigyang-daan ka ng function na paulit-ulit na maglapat ng update sa . hanggang kundisyon
ay hindi totoo.

Tandaan na ang habang(cond; update) ay panloob na tinukoy bilang isang recursive jq function. Recursive
mga tawag sa loob habang ay hindi kumonsumo ng karagdagang memorya kung update gumagawa ng hindi hihigit sa isa
output para sa bawat input. Tingnan ang mga advanced na paksa sa ibaba.

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

hanggang(cond; susunod)
Ang hanggang(cond; susunod) pinahihintulutan ka ng function na paulit-ulit na ilapat ang expression susunod,
sa simula sa . pagkatapos ay sa sarili nitong output, hanggang kundisyon ay totoo. Halimbawa, ito ay maaaring gamitin
upang ipatupad ang isang factorial function (tingnan sa ibaba).

Tandaan na ang hanggang(cond; susunod) ay panloob na tinukoy bilang isang recursive jq function. Recursive
mga tawag sa loob hanggang() ay hindi kumonsumo ng karagdagang memorya kung susunod gumagawa ng hindi hihigit sa isa
output para sa bawat input. Tingnan ang mga advanced na paksa sa ibaba.

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

recurse(f), paulit-ulit, recurse(f; kondisyon), recurse_down
Ang recurse(f) Binibigyang-daan ka ng function na maghanap sa pamamagitan ng recursive structure, at extract
kawili-wiling data mula sa lahat ng antas. Ipagpalagay na ang iyong input ay kumakatawan sa isang filesystem:

{"name": "/", "mga bata": [
{"pangalan": "/ bin", "mga anak": [
{"pangalan": "/bin/ls", "mga bata": []},
{"pangalan": "/ Bin / SH", "mga bata": []}]},
{"pangalan": "/ home", "mga anak": [
{"name": "/home/stephen", "children": [
{"name": "/home/stephen/jq", "children": []}]}]}]}

Ngayon ipagpalagay na gusto mong kunin ang lahat ng mga filename na naroroon. Kailangan mong kunin . Pangalan,
.mga bata[].pangalan, .bata[].bata[].pangalan, at iba pa. Magagawa mo ito sa:

recurse(.bata[]) | .pangalan

Kapag tinawag nang walang argumento, magaling muli ay katumbas ng umuulit(.[]?).

recurse(f) ay magkapareho sa recurse(f; . != wala) at maaaring gamitin nang walang pag-aalala tungkol sa
lalim ng recursion.

recurse(f; kondisyon) ay isang generator na nagsisimula sa pamamagitan ng paglabas ng . at pagkatapos ay naglalabas sa turn
.|f, .|f|f, .|f|f|f, ... hangga't ang nakalkulang halaga ay nakakatugon sa kundisyon. Para sa
halimbawa, upang makabuo ng lahat ng mga integer, kahit na sa prinsipyo, maaaring magsulat ang isa recurse(.+1;
totoo).

Para sa mga legacy na dahilan, recurse_down umiiral bilang alyas sa pagtawag magaling muli walang argumento.
Ang alyas na ito ay isinasaalang-alang hindi na ginagamit at aalisin sa susunod na major release.

Ang recursive ay tumatawag magaling muli hindi kumonsumo ng karagdagang memory kahit kailan f gumagawa sa
karamihan sa isang solong output para sa bawat input.

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

jq 'recurse'
{"a":0,"b":[1]}
=> {"a":0,"b":[1]}, 0, [1], 1

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

..
Maikling-kamay para sa magaling muli walang argumento. Ito ay inilaan upang maging katulad ng XPath //
operator. Tandaan na ..a hindi gumagana; gamitin ..|a sa halip. Sa halimbawa sa ibaba na ginagamit namin
..|.a? upang mahanap ang lahat ng mga halaga ng object key "a" sa anumang bagay na matatagpuan "sa ibaba" ..

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

env
Naglalabas ng isang bagay na kumakatawan sa kapaligiran ng jq.

jq 'env.PAGER'
walang halaga
=> "mas mababa"

baligtarin
Ilipat ang isang posibleng tulis-tulis na matrix (isang hanay ng mga array). Ang mga hilera ay may palaman na mga null kaya ang
ang resulta ay palaging hugis-parihaba.

jq 'transpose'
[[1], [2,3]]
=> [[1,2],[null,3]]

bsearch(x)
Ang bsearch(x) ay nagsasagawa ng binary na paghahanap para sa x sa input array. Kung ang input ay pinagsunod-sunod at
naglalaman ng x, pagkatapos ay ibabalik ng bsearch(x) ang index nito sa array; kung hindi, kung ang array ay
pinagsunod-sunod, babalik ito (-1 - ix) kung saan ang ix ay isang insertion point na gagawin ng array
maiayos pa rin pagkatapos ng pagpasok ng x sa ix. Kung ang array ay hindi pinagsunod-sunod, bsearch(x)
ay magbabalik ng integer na malamang na walang interes.

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

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

jq ´bsearch(4) bilang $ix | kung $ix < 0 kung gayon .[-(1+$ix)] = 4 pa . wakas'
[1,2,3]
=> [1,2,3,4]

Pisi paghihiwalay - \(foo)
Sa loob ng string, maaari kang maglagay ng expression sa loob ng parens pagkatapos ng backslash. Anuman ang
ang mga pagbabalik ng expression ay isasama sa string.

jq ´"Ang input ay \(.), na mas mababa ng isa sa \(.+1)"´
42
=> "Ang input ay 42, na isang mas mababa sa 43"

Palitan para kay mula kay JSON
Ang tojson at fromjson builtin dump value bilang JSON text o parse JSON texts sa
mga halaga, ayon sa pagkakabanggit. Ang tojson builtin ay naiiba sa tostring sa tostring returns na iyon
hindi binago ang mga string, habang ang tojson ay nag-encode ng mga string bilang mga string ng 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 string at escaping
Ang @foo Syntax ay ginagamit upang i-format at i-escape ang mga string, na kapaki-pakinabang para sa pagbuo ng mga URL,
mga dokumento sa isang wika tulad ng HTML o XML, at iba pa. @foo maaaring gamitin bilang isang filter sa
sarili nito, ang mga posibleng pagtakas ay:

@text:

Tawag tostring, tingnan ang function na iyon para sa mga detalye.

@json:

Sine-serye ang input bilang JSON.

@html:

Naglalapat ng HTML/XML escaping, sa pamamagitan ng pagmamapa sa mga character <>&´" sa kanilang entidad
mga katumbas <, >, &, ', ".

@uri:

Naglalapat ng percent-encoding, sa pamamagitan ng pagmamapa sa lahat ng nakareserbang URI character sa a %XX pagkakasunod-sunod.

@csv:

Ang input ay dapat na isang array, at ito ay nai-render bilang CSV na may double quotes para sa
mga string, at mga quote na nakatakas sa pamamagitan ng pag-uulit.

@tsv:

Ang input ay dapat isang array, at ito ay nai-render bilang TSV (tab-separated values). Bawat isa
Ang input array ay ipi-print bilang isang linya. Ang mga patlang ay pinaghihiwalay ng isang tab
(ascii 0x09). Mag-input ng mga character line-feed (ascii 0x0a), karwahe-pagbabalik (ascii
0x0d), tab (ascii 0x09) at backslash (ascii 0x5c) ay magiging output bilang pagtakas
pagkakasunud-sunod \n, \r, \t, \\ ayon sa pagkakabanggit.

@sh:

Ang input ay na-escape na angkop para sa paggamit sa isang command-line para sa isang POSIX shell. Kung ang
Ang input ay isang array, ang output ay isang serye ng mga string na pinaghihiwalay ng espasyo.

@base64:

Ang input ay na-convert sa base64 gaya ng tinukoy ng RFC 4648.

Ang syntax na ito ay maaaring isama sa string interpolation sa isang kapaki-pakinabang na paraan. Maaari mong sundin ang a
@foo token na may literal na string. Ang mga nilalaman ng string literal na kalooban hindi makatakas.
Gayunpaman, ang lahat ng interpolasyon na ginawa sa loob ng literal na string na iyon ay matatakasan. Halimbawa,

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

gagawa ng sumusunod na output para sa input {"search":"ano is jq?"}:

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

Tandaan na ang mga slash, tandang pananong, atbp. sa URL ay hindi nakatakas, dahil bahagi sila
ng string literal.

jq ´@html´
"Gumagana ito kung x < y"
=> "Gumagana ito kung x < y"

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

Petsa
Nagbibigay ang jq ng ilang pangunahing pag-andar sa paghawak ng petsa, na may ilang mataas na antas at mababang antas
builtins. Sa lahat ng kaso, eksklusibong nakikitungo ang mga builtin na ito sa oras sa UTC.

Ang mula sa petsaiso8601 Ang builtin ay nag-parse ng mga datetime sa ISO 8601 na format sa ilang segundo
mula noong Unix epoch (1970-01-01T00:00:00Z). Ang ngayoniso8601 Ginagawa ng builtin ang kabaligtaran.

Ang mula sa petsa pina-parse ng builtin ang mga string ng datetime. Kasalukuyan mula sa petsa Sinusuportahan lamang ang ISO 8601
datetime string, ngunit sa hinaharap ay susubukan nitong i-parse ang mga datetime string sa higit pa
format.

Ang ngayon builtin ay isang alias para sa ngayoniso8601.

Ang ngayon Ang builtin ay naglalabas ng kasalukuyang oras, sa mga segundo mula noong panahon ng Unix.

Ang mga low-level na jq interface sa C-library time function ay ibinibigay din: strptime,
strftime, mktime, at gmtime. Sumangguni sa dokumentasyon ng iyong host operating system para sa
format na mga string na ginagamit ng strptime at strftime. Tandaan: ang mga ito ay hindi kinakailangang stable
mga interface sa jq, lalo na sa kanilang pag-andar ng lokalisasyon.

Ang gmtime Ang builtin ay kumonsumo ng ilang segundo mula noong panahon ng Unix at naglalabas ng "broken
down time" na representasyon ng oras bilang isang hanay ng mga numero na kumakatawan (sa ganitong pagkakasunud-sunod): ang
taon, ang buwan (zero-based), ang araw ng buwan, ang oras ng araw, ang minuto ng
oras, segundo ng minuto, araw ng linggo, at araw ng taon -- lahat
one-based maliban kung iba ang nakasaad.

Ang mktime Ang builtin ay gumagamit ng "nasira na oras" na mga representasyon ng output ng oras sa pamamagitan ng gmtime
at strptime.

Ang strptime(fmt) builtin parses input string na tumutugma sa fmt argumento. Ang output ay nasa
ang representasyong "nasira down na oras" na ginagamit ng gmtime at output sa pamamagitan ng mktime.

Ang strftime(fmt) builtin format ng isang oras na may ibinigay na format.

Ang mga string ng format para sa strptime at strftime ay inilarawan sa karaniwang C library
dokumentasyon. Ang format string para sa ISO 8601 datetime ay "%Y-%m-%dT%H:%M:%SZ".

Maaaring hindi sinusuportahan ng jq ang ilan o lahat ng pagpapagana ng petsang ito sa ilang system.

jq 'mula'
"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

MGA KONDISYONAL AT PAGHAHAMBING

==, !=
Ang expression na ´a == b´ ay gagawa ng ´true´ kung ang resulta ng a at b ay pantay (iyon ay,
kung kinakatawan nila ang mga katumbas na dokumento ng JSON) at ´false´ kung hindi. Sa partikular, mga string
ay hindi kailanman itinuturing na katumbas ng mga numero. Kung nanggaling ka sa Javascript, ang jq's == ay parang
Javascript's === - isinasaalang-alang ang mga halaga na pantay lamang kapag mayroon silang parehong uri pati na rin
ang parehong halaga.

!= ay "hindi pantay", at ang ´a != b´ ay nagbabalik ng kabaligtaran na halaga ng ´a == b´

jq ´.[] == 1´
[1, 1.0, "1", "saging"]
=> totoo, totoo, mali, mali

kung sakali ay
if A pagkatapos B iba C dulo ay kikilos katulad ng B if A gumagawa ng halaga maliban sa false o
null, ngunit kumilos katulad ng C kung hindi man.

Ang pagsuri para sa mali o null ay isang mas simpleng ideya ng "katotohanan" kaysa sa makikita sa Javascript
o Python, ngunit nangangahulugan ito na kung minsan ay kailangan mong maging mas tahasang tungkol sa kundisyon
gusto mo: hindi mo masusubok kung, hal. walang laman ang string na ginagamit if . Pangalan pagkatapos A iba B dulo,
kakailanganin mo ng higit na katulad if (.pangalan | haba) > 0 pagkatapos A iba B dulo sa halip.

Kung ang kundisyon A ay gumagawa ng maraming resulta, ito ay itinuturing na "totoo" kung alinman sa mga iyon
ang mga resulta ay hindi mali o null. Kung wala itong resulta, ituturing itong mali.

Higit pang mga kaso ang maaaring idagdag sa isang kung gumagamit elif A pagkatapos B Syntax.

jq 'kung . == 0 pagkatapos

"zero" elif . == 1 pagkatapos ay "isa" pa "marami" dulo´ 2 => "marami"

>, >=, <=, <
Ang mga operator ng paghahambing >, >=, <=, < ibalik kung ang kanilang kaliwang argumento ay mas malaki kaysa sa,
mas malaki sa o katumbas ng, mas mababa sa o katumbas ng o mas mababa sa kanilang tamang argumento
(kanya-kanya).

Ang pag-order ay pareho sa inilarawan para sa uri, sa itaas.

jq ´. < 5'
2
=> totoo

at/o/hindi
Sinusuportahan ng jq ang mga normal na operator ng Boolean at/o/hindi. Pareho sila ng pamantayan ng katotohanan
na parang ang mga expression - false at null ay itinuturing na "false value", at anupaman ay a
"tunay na halaga".

Kung ang isang operand ng isa sa mga operator na ito ay gumagawa ng maraming resulta, ang operator mismo
gagawa ng resulta para sa bawat input.

hindi sa katunayan ay isang builtin na function sa halip na isang operator, kaya ito ay tinatawag bilang isang filter sa
kung aling mga bagay ang maaaring i-pipe sa halip na may espesyal na syntax, tulad ng sa .foo at .Cafe | hindi.

Ang tatlong ito ay gumagawa lamang ng mga halagang "totoo" at "mali", at sa gayon ay kapaki-pakinabang lamang para sa tunay
Boolean operations, sa halip na ang karaniwang Perl/Python/Ruby idiom ng
"value_that_may_be_null or default". Kung gusto mong gamitin ang form na ito ng "o", pagpili sa pagitan
dalawang halaga sa halip na suriin ang isang kundisyon, tingnan ang "//" operator sa ibaba.

jq ´42 at "isang string"´
walang halaga
=> totoo

jq ´(totoo, mali) o mali´
walang halaga
=> totoo, mali

jq ´(totoo, totoo) at (totoo, mali)´
walang halaga
=> totoo, mali, totoo, mali

jq ´[totoo, mali | hindi]'
walang halaga
=> [mali, totoo]

Alternatiba opereytor - //
Isang filter ng form a // b gumagawa ng parehong mga resulta bilang a, Kung a nagbubunga ng iba pang mga resulta
kaysa hindi totoo at walang halaga. Kung hindi man, a // b gumagawa ng parehong mga resulta bilang b.

Ito ay kapaki-pakinabang para sa pagbibigay ng mga default: .foo // 1 susuriin sa 1 kung wala .foo
elemento sa input. Ito ay katulad ng kung paano or minsan ay ginagamit sa Python (jq´s or opereytor
ay nakalaan para sa mahigpit na pagpapatakbo ng Boolean).

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

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

subukan-huli
Maaaring mahuli ang mga error sa pamamagitan ng paggamit sumubok Exp abutin Exp. Ang unang expression ay naisakatuparan, at kung
ito ay nabigo pagkatapos ay ang pangalawa ay naisakatuparan kasama ang mensahe ng error. Ang output ng handler, kung
any, ay output na parang ito ay ang output ng expression na subukan.

Ang sumubok Exp gamit ng form walang laman bilang exception handler.

jq ´try .a catch ". ay hindi bagay"´
totoo
=> ". ay hindi isang bagay"

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

jq ´try error("some exception") catch .´
totoo
=> "ilang exception"

Pagsira Palabas of kontrol kaayusan
Ang isang maginhawang paggamit ng try/catch ay ang pag-alis sa mga istrukturang kontrol tulad ng bawasan, unahan,
habang, At iba pa.

Halimbawa:

# Ulitin ang isang expression hanggang sa tumaas ang "break" bilang isang
# error, pagkatapos ay ihinto ang pag-uulit nang hindi muling itinataas ang error.
# Ngunit kung ang error na nahuli ay hindi "break" pagkatapos ay muling itaas ito.
subukan repeat(exp) catch .=="break" pagkatapos ay walang laman ang else error;

Ang jq ay may syntax para sa mga pinangalanang lexical na label na "masira" o "bumalik (bumalik) sa":

lagyan ng label ang $out | ... break $out ...

Ang masira $label_name expression ay magiging sanhi ng programa upang kumilos na parang ang pinakamalapit
(pa-kaliwa) etiketa $label_name ginawa walang laman.

Ang ugnayan sa pagitan ng masira at katumbas etiketa ay lexical: ang label ay dapat na
"nakikita" mula sa pahinga.

Upang lumabas sa a bawasan, Halimbawa:

lagyan ng label ang $out | bawasan ang .[] bilang $item (null; kung .==false pagkatapos ay i-break ang $out else ... end)

Ang sumusunod na jq program ay gumagawa ng syntax error:

masira $out

kasi walang label $out ay nakikita.

? opereytor
Ang ? operator, ginamit bilang EXP?, ay shorthand para sa sumubok Exp.

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

REGULAR MGA PAGPAPAHAYAG (PCRE)

jq ay gumagamit ng Oniguruma regular expression library, tulad ng php, ruby, TextMate, Sublime Text,
atbp, kaya ang paglalarawan dito ay tumutok sa mga detalye ng jq.

Tinukoy ang mga filter ng jq regex upang magamit ang mga ito gamit ang isa sa mga pattern na ito:

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

kung saan: * STRING, REGEX at FLAGS ay mga jq string at napapailalim sa jq string interpolation; *
Ang REGEX, pagkatapos ng interpolation ng string, ay dapat na isang wastong PCRE regex; * Isa ang FILTER sa pagsusulit,
tumugma, O pagbihag, tulad ng inilarawan sa ibaba.

Ang FLAGS ay isang string na binubuo ng isa pa sa mga sinusuportahang flag:

· g - Pandaigdigang paghahanap (hanapin ang lahat ng mga tugma, hindi lamang ang una)

· i - Case insensitive na paghahanap

· m - Multi line mode (´.´ ay tutugma sa mga bagong linya)

· n - Huwag pansinin ang mga walang laman na posporo

· p - Ang parehong s at m mode ay pinagana

· s - Single line mode (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - Maghanap ng pinakamahabang posibleng mga tugma

· x - Pinahabang format ng regex (balewala ang whitespace at mga komento)

Upang itugma ang whitespace sa isang x pattern gumamit ng escape gaya ng \s, hal

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

Tandaan na ang ilang mga flag ay maaari ding tukuyin sa loob ng REGEX, hal

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

sinusuri sa: totoo, tama, mali, mali.

[Nangangailangan 1.5] pagsubok(val), pagsubok(regex; mga watawat)
katulad tumugma, ngunit hindi nagbabalik ng mga bagay na tumutugma, lamang totoo or hindi totoo para man o hindi ang
tumutugma ang regex sa input.

jq ´test("foo")´).
"foo"
=> totoo

jq ´.[] | test("abc # spaces are ignored"; "ix")´
["xabcd", "ABC"]
=> totoo, totoo

[Nangangailangan 1.5] tugma(val), tugma(regex; mga watawat)
tumugma naglalabas ng isang bagay para sa bawat tugma na mahahanap nito. May mga sumusunod na field ang mga laban:

· ginalaw - offset sa UTF-8 codepoints mula sa simula ng input

· haba - haba sa UTF-8 codepoints ng laban

· pisi - ang string na katugma nito

· Kumukuha - isang hanay ng mga bagay na kumakatawan sa pagkuha ng mga grupo.

Ang pagkuha ng mga object ng pangkat ay may mga sumusunod na field:

· ginalaw - offset sa UTF-8 codepoints mula sa simula ng input

· haba - haba sa mga codepoint ng UTF-8 ng grupong ito sa pagkuha

· pisi - ang string na nakuha

· pangalan - ang pangalan ng grupong kumukuha (o walang halaga kung ito ay hindi pinangalanan)

Ang pagkuha ng mga pangkat na hindi tumugma sa anumang bagay ay nagbabalik ng offset na -1

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

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

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

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

jq ´[ tugma("."; "g")] | haba'
"abc"
=> 3

[Nangangailangan 1.5] makunan(val), makuha (regex; mga watawat)
Kinokolekta ang pinangalanang pagkuha sa isang JSON object, na may pangalan ng bawat pagkuha bilang susi,
at ang katugmang string bilang katumbas na halaga.

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

[Nangangailangan 1.5] scan(regex), i-scan(regex; mga watawat)
Maglabas ng stream ng hindi magkakapatong na mga substring ng input na tumutugma sa regex
alinsunod sa mga watawat, kung mayroon man ay tinukoy. Kung walang tugma, ang stream ay
walang laman. Upang makuha ang lahat ng mga tugma para sa bawat input string, gamitin ang idiom [ ipahayag ], halimbawa [
scan(regex) ].

split(regex; mga watawat)
Para sa pabalik na pagkakatugma, pagsibak nahati sa isang string, hindi isang regex.

[Nangangailangan 1.5] split(regex), split(regex; mga watawat)
Nagbibigay ang mga ito ng parehong mga resulta tulad ng kanilang pagsibak mga katapat, ngunit bilang isang stream sa halip na isang
pag-ayos.

[Nangangailangan 1.5] sub(regex; tostring) sub(regex; string; mga watawat)
Ilabas ang string na nakuha sa pamamagitan ng pagpapalit sa unang tugma ng regex sa input string ng
tostring, pagkatapos ng interpolation. tostring dapat ay isang jq string, at maaaring naglalaman ng mga sanggunian
sa pinangalanang mga kuha. Ang pinangalanang mga pagkuha ay, sa katunayan, ay ipinakita bilang isang JSON object (bilang
itinayo ni pagbihag) Upang tostring, kaya ang isang reference sa isang nakuhang variable na pinangalanang "x" ay gagawin
kunin ang form: "(.x)".

[Nangangailangan 1.5] gsub(regex; string), gsub(regex; string; mga watawat)
gsub ay tulad ng sub ngunit ang lahat ng hindi magkakapatong na pangyayari ng regex ay pinapalitan ng
string, pagkatapos ng interpolation.

ADVANCED TAMPOK

Ang mga variable ay isang ganap na pangangailangan sa karamihan ng mga programming language, ngunit ang mga ito ay nai-relegated
sa isang "advanced na tampok" sa jq.

Sa karamihan ng mga wika, ang mga variable ay ang tanging paraan ng pagpasa ng data. Kung kalkulahin mo ang a
halaga, at gusto mo itong gamitin nang higit sa isang beses, kakailanganin mong iimbak ito sa isang variable. Upang
magpasa ng halaga sa isa pang bahagi ng programa, kakailanganin mo ang bahaging iyon ng programa
tukuyin ang isang variable (bilang isang parameter ng function, miyembro ng object, o anuman) kung saan ilalagay
ang data

Posible rin na tukuyin ang mga function sa jq, bagaman ito ay isang tampok na ang pinakamalaking
Ang paggamit ay ang pagtukoy sa karaniwang aklatan ng jq (maraming mga function ng jq tulad ng mapa at mahanap ay sa katunayan
nakasulat sa jq).

Ang jq ay may mga operator ng pagbabawas, na napakalakas ngunit medyo nakakalito. Muli, ito ay
kadalasang ginagamit sa loob, upang tukuyin ang ilang kapaki-pakinabang na piraso ng karaniwang aklatan ng jq.

Maaaring hindi ito halata sa una, ngunit ang jq ay tungkol sa mga generator (oo, tulad ng madalas na matatagpuan sa
iba pang mga wika). Ang ilang mga kagamitan ay ibinigay upang tumulong sa pagharap sa mga generator.

Ilang kaunting suporta sa I/O (bukod sa pagbabasa ng JSON mula sa karaniwang input, at pagsusulat ng JSON sa
karaniwang output) ay magagamit.

Sa wakas, mayroong isang module/library system.

Variable
Sa jq, lahat ng mga filter ay may input at output, kaya hindi na kailangan ang manual plumbing
magpasa ng halaga mula sa isang bahagi ng isang programa patungo sa susunod. Maraming mga expression, halimbawa a + b,
ipasa ang kanilang input sa dalawang natatanging subexpression (dito a at b pareho silang pumasa
input), kaya ang mga variable ay hindi karaniwang kinakailangan upang gumamit ng isang halaga nang dalawang beses.

Halimbawa, ang pagkalkula ng average na halaga ng isang hanay ng mga numero ay nangangailangan ng ilang
mga variable sa karamihan ng mga wika - hindi bababa sa isa na humawak ng array, marahil isa para sa bawat elemento
o para sa isang loop counter. Sa jq, simple lang idagdag / haba - Ang idagdag ang pagpapahayag ay binibigyan ng
array at gumagawa ng kabuuan nito, at ang haba Ang expression ay binibigyan ng array at gumagawa nito
haba.

Kaya, sa pangkalahatan ay may mas malinis na paraan upang malutas ang karamihan sa mga problema sa jq kaysa sa pagtukoy ng mga variable.
Gayunpaman, minsan ginagawa nilang mas madali ang mga bagay, kaya hinahayaan ka ng jq na tukuyin ang mga variable na ginagamit
pagpapahayag as $variable. Ang lahat ng mga variable na pangalan ay nagsisimula sa $. Narito ang isang bahagyang pangit na bersyon
ng halimbawa ng array-averaging:

haba bilang $array_length | magdagdag ng / $array_length

Kakailanganin namin ang isang mas kumplikadong problema upang makahanap ng isang sitwasyon kung saan aktwal na gumagamit ng mga variable
ginagawang mas madali ang ating buhay.

Ipagpalagay na mayroon kaming isang hanay ng mga post sa blog, na may mga field na "may-akda" at "pamagat", at isa pa
bagay na ginagamit upang imapa ang mga username ng may-akda sa mga tunay na pangalan. Ang aming input ay mukhang:

{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "Isang artikulong mahusay ang pagkakasulat", "may-akda": "person1"}],
"realnames": {"anon": "Anonymous na Duwag",
"person1": "Person McPherson"}}

Gusto naming gumawa ng mga post na may patlang ng may-akda na naglalaman ng isang tunay na pangalan, tulad ng sa:

{"title": "Frist psot", "author": "Anonymous Coward"}
{"title": "Isang mahusay na pagkakasulat na artikulo", "may-akda": "Person McPherson"}

Gumagamit kami ng variable, $names, para i-store ang realnames object, para ma-refer namin ito sa ibang pagkakataon
kapag naghahanap ng mga username ng may-akda:

.realnames bilang $names | .post[] | {title, author: $names[.author]}

Ang pananalita exp as $x | ... ibig sabihin: para sa bawat halaga ng pagpapahayag exp, patakbuhin ang natitirang bahagi ng
ang pipeline na may buong orihinal na input, at may $x itinakda sa halagang iyon. Sa gayon as
gumagana bilang isang bagay ng isang foreach loop.

Tulad ng {foo} ay isang madaling paraan ng pagsulat {foo: .foo}, Kaya {$foo} ay isang madaling paraan ng pagsulat
{foo:$foo}.

Maaaring ideklara ang maramihang mga variable gamit ang isang solong as pagpapahayag sa pamamagitan ng pagbibigay ng pattern
na tumutugma sa istraktura ng input (ito ay kilala bilang "pagsira"):

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

Ang mga variable na deklarasyon sa mga pattern ng array (hal, . as [$una, $segundo]) magbigkis sa
mga elemento ng array mula sa elemento sa index zero sa itaas, sa pagkakasunud-sunod. Kapag wala
halaga sa index para sa isang elemento ng pattern ng array, walang halaga ay nakasalalay sa variable na iyon.

Ang mga variable ay saklaw sa natitirang bahagi ng expression na tumutukoy sa kanila, kaya

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

gagana, ngunit

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

ay hindi.

Para sa mga teorya ng programming language, mas tumpak na sabihin na ang mga variable ng jq ay
lexically-scoped bindings. Sa partikular, walang paraan upang baguhin ang halaga ng isang nagbubuklod;
maaari lamang mag-set up ng bagong binding na may parehong pangalan, ngunit hindi makikita kung saan
ang luma ay.

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

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

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

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

Pagtukoy Pag-andar
Maaari kang magbigay ng isang filter ng isang pangalan gamit ang "def" syntax:

def increment: . + 1;

Mula noon, pagtaas ay magagamit bilang isang filter tulad ng isang builtin na function (sa katunayan, ito
ay kung paano tinukoy ang ilan sa mga builtin). Ang isang function ay maaaring tumagal ng mga argumento:

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

Ang mga argumento ay ipinapasa bilang mga filter, hindi bilang mga halaga. Ang parehong argumento ay maaaring sanggunian
maraming beses na may iba't ibang mga input (dito f ay pinapatakbo para sa bawat elemento ng input array).
Ang mga argumento sa isang function ay gumagana nang mas katulad ng mga callback kaysa tulad ng mga argumento ng halaga. Ito ay
mahalagang maunawaan. Isaalang-alang:

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

Ang magiging resulta ay 20 dahil f is .*2, at sa unang panawagan ng f . ay magiging 5,
at sa pangalawang pagkakataon ito ay magiging 10 (5 * 2), kaya ang resulta ay magiging 20. Function arguments
ay mga filter, at inaasahan ng mga filter ang isang input kapag na-invoke.

Kung gusto mo ang pag-uugali ng value-argument para sa pagtukoy ng mga simpleng function, maaari mo lamang gamitin ang a
variable:

def addvalue(f): f bilang $f | mapa(. + $f);

O gamitin ang maikling kamay:

def addvalue($f): ...;

Sa alinmang kahulugan, addvalue(.foo) ay magdaragdag ng kasalukuyang input's .foo patlang sa bawat isa
elemento ng array.

Pinapayagan ang maramihang mga kahulugan gamit ang parehong pangalan ng function. Ang bawat re-definition ay pumapalit
ang nauna para sa parehong bilang ng mga argumento ng function, ngunit para lamang sa mga sanggunian mula sa
function (o pangunahing programa) kasunod ng muling pagtukoy.

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

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

Bawasan
Ang bawasan Ang syntax sa jq ay nagpapahintulot sa iyo na pagsamahin ang lahat ng mga resulta ng isang expression sa pamamagitan ng
pag-iipon ng mga ito sa iisang sagot. Bilang halimbawa, papasa tayo [3,2,1] Sa ganito
pagpapahayag:

bawasan ang .[] bilang $item (0; . + $item)

Para sa bawat resulta na .[] gumagawa, . + $item ay tumatakbo upang makaipon ng kabuuang tumatakbo,
simula sa 0. Sa halimbawang ito, .[] gumagawa ng mga resulta 3, 2, at 1, kaya ang epekto ay
katulad ng pagpapatakbo ng isang bagay tulad nito:

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

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

limitasyon(n; exp)
Ang limitasyon function extracts hanggang sa n mga output mula sa exp.

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

una (expr), huling(expr), nth(n; expr)
Ang una (expr) at huling(expr) Kinukuha ng mga function ang una at huling mga halaga mula sa ipahayag,
ayon sa pagkakabanggit.

Ang nth(n; expr) Kinukuha ng function ang nth value na output ng ipahayag. Ito ay maaaring tukuyin bilang
def nth(n; expr): huling(limitasyon(n + 1; expr));. Tandaan na nth(n; expr) ay hindi sumusuporta
negatibong halaga ng n.

jq ´[first(range(.)), last(range(.)), nth(./2; range(.))]´
10
=> [0,9,5]

una, huling, nth(n)
Ang una at huli ang mga function ay kinukuha ang una at huling mga halaga mula sa anumang array sa ..

Ang nth(n) Kinukuha ng function ang nth value ng anumang array sa ..

jq ´[range(.)]|[una, huli, wala(5)]´
10
=> [0,9,5]

unahan
Ang unahan ang syntax ay katulad ng bawasan, ngunit nilayon upang payagan ang pagtatayo ng limitasyon
at mga reducer na gumagawa ng mga intermediate na resulta (tingnan ang halimbawa).

Ang porma ay unahan Exp as $var (SA LOOB; I-UPDATE; EXTRACT). Katulad bawasan, INIT ay sinusuri
isang beses upang makabuo ng isang halaga ng estado, pagkatapos ay ang bawat output ng Exp ay nakasalalay sa $var, I-UPDATE is
nasuri para sa bawat output ng Exp sa kasalukuyang estado at sa $var nakikita. Ang bawat halaga
output ng I-UPDATE pumapalit sa dating estado. Sa wakas, MAGBABAGO ay sinusuri para sa bawat bago
estado upang kunin ang isang output ng unahan.

Ito ay kadalasang kapaki-pakinabang lamang para sa pagtatayo bawasan- At limitasyon-tulad ng mga function. Ngunit ito ay
mas pangkalahatan, dahil nagbibigay-daan ito para sa bahagyang pagbabawas (tingnan ang halimbawa sa ibaba).

jq ´[foreach .[] bilang $item ([[],[]]; kung $item == null then [[],.[0]] else [(.[0] + [$item]),[ ]] end; kung $item == null pagkatapos ay .[1] else walang laman na dulo)]´
[1,2,3,4,null,"a","b",null]
=> [[1,2,3,4],["a","b"]]

Recursion
Tulad ng inilarawan sa itaas, magaling muli gumagamit ng recursion, at anumang jq function ay maaaring recursive. Ang
habang Ang builtin ay ipinatupad din sa mga tuntunin ng recursion.

Ang mga tail call ay na-optimize sa tuwing ang expression sa kaliwa ng recursive call outputs
huling halaga nito. Sa pagsasagawa, nangangahulugan ito na ang expression sa kaliwa ng recursive
Ang tawag ay hindi dapat gumawa ng higit sa isang output para sa bawat input.

Halimbawa:

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

def while(cond; update):
def _while:
kung cond pagkatapos ., (update | _habang) iba walang laman dulo;
_habang;

def repeat(exp):
def _repeat:
exp, _repeat;
_ulitin;

generators at mga iterator
Ang ilang mga operator at function ng jq ay talagang mga generator na maaari silang makagawa ng zero,
isa, o higit pang mga halaga para sa bawat input, tulad ng inaasahan ng isa sa ibang programming
mga wika na mayroong mga generator. Halimbawa, .[] bumubuo ng lahat ng mga halaga sa input nito
(na dapat ay isang array o isang bagay), saklaw(0; 10) bumubuo ng mga integer sa pagitan ng 0 at
10, at iba pa.

Kahit na ang comma operator ay isang generator, na unang bumubuo ng mga value na nabuo ng
expression sa kaliwa ng kuwit, pagkatapos para sa bawat isa sa mga iyon, ang mga halaga ay nabuo ng
expression sa kanan ng kuwit.

Ang walang laman Ang builtin ay ang generator na gumagawa ng mga zero na output. Ang walang laman builtin
backtracks sa naunang generator expression.

Ang lahat ng jq function ay maaaring maging generator sa pamamagitan lamang ng paggamit ng builtin generators. Pwede rin naman
upang tukuyin ang mga bagong generator gamit lamang ang recursion at ang comma operator. Kung ang recursive
Ang (mga) tawag ay(ay) "nasa posisyon ng buntot" kung gayon ang generator ay magiging mahusay. Sa halimbawa
sa ibaba ng recursive na tawag ni _saklaw sa kanyang sarili ay nasa posisyon ng buntot. Nagpapakita ang halimbawa
tatlong advanced na paksa: tail recursion, pagbuo ng generator, at mga sub-function.

jq ´def range(init; upto; by): def _range: if (by > 0 and . < upto) or (by < 0 and . > upto) then ., ((.+by)|_range) else . wakas; if by == 0 then init else init|_range end | piliin((sa pamamagitan ng > 0 at . < hanggang sa) o (sa pamamagitan ng < 0 at . > hanggang)); saklaw(0; 10; 3)´
walang halaga
=> 0, 3, 6, 9

jq ´def while(cond; update): def _while: kung cond then ., (update | _while) else walang laman ang dulo; _habang; [habang(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

MATH

Ang jq ay kasalukuyang mayroon lamang IEEE754 double-precision (64-bit) floating point number na suporta.

Bukod sa mga simpleng arithmetic operator tulad ng +, ang jq ay mayroon ding karamihan sa mga karaniwang pag-andar sa matematika
mula sa C math library. C math function na kumukuha ng isang input argument (hal., kasalanan())
ay magagamit bilang zero-argument jq function. C math function na kumukuha ng dalawang input
mga argumento (hal. pow()) ay magagamit bilang dalawang-argumentong jq function na hindi pinapansin ..

Ang kakayahang magamit ng mga karaniwang function ng matematika ay nakasalalay sa pagkakaroon ng katumbas
math function sa iyong operating system at C math library. Hindi available na math function
ay tutukuyin ngunit magtataas ng error.

I / O

Sa oras na ito ang jq ay may kaunting suporta para sa I/O, karamihan ay nasa anyo ng kontrol sa kung kailan
binabasa ang mga input. Dalawang builtin na function ang ibinigay para dito, input at input, na nabasa
mula sa parehong mga mapagkukunan (hal, si stdin, mga file na pinangalanan sa command-line) bilang jq mismo. Ang mga ito
dalawang builtin, at sariling pagbabasa ng jq, ay maaaring i-interleaved sa isa't isa.

Ang isang builtin ay nagbibigay ng kaunting mga kakayahan sa output, mag-alis ng mga insekto. (Tandaan na ang isang jq program's
ang mga halaga ng output ay palaging output habang naka-on ang mga text ng JSON stdout.) Ang mag-alis ng mga insekto maaaring magkaroon ng builtin
pag-uugaling partikular sa application, gaya ng para sa mga executable na gumagamit ng libjq C API ngunit hindi
ang jq executable mismo.

input
Naglalabas ng isang bagong input.

input
I-output ang lahat ng natitirang input, isa-isa.

Ito ay pangunahing kapaki-pakinabang para sa mga pagbawas sa mga input ng isang programa.

mag-alis ng mga insekto
Nagdudulot ng debug na mensahe batay sa halaga ng input na gagawin. Ang jq executable wraps
ang halaga ng input na may ["DEBUG:", ] at ini-print iyon at isang bagong linya sa stderr,
compactly. Maaaring magbago ito sa hinaharap.

input_filename
Ibinabalik ang pangalan ng file na ang input ay kasalukuyang sinasala. Tandaan na ito ay
hindi gumagana nang maayos maliban kung tumatakbo ang jq sa isang lokal na UTF-8.

input_line_number
Ibinabalik ang numero ng linya ng input na kasalukuyang sinasala.

PAG-ISIP

Kasama ang --stream Ang opsyon na jq ay maaaring mag-parse ng mga input text sa isang streaming na paraan, na nagpapahintulot sa jq
mga program upang simulan kaagad ang pagproseso ng malalaking JSON text sa halip na pagkatapos ng pag-parse
nakumpleto. Kung mayroon kang isang text ng JSON na 1GB ang laki, magbibigay-daan ito sa iyo sa pag-stream
upang maproseso ito nang mas mabilis.

Gayunpaman, ang streaming ay hindi madaling harapin dahil magkakaroon ang jq program [ ,
] (at ilang iba pang anyo) bilang mga input.

Maraming mga builtin ang ibinigay upang gawing mas madali ang paghawak ng mga stream.

Ginagamit ng mga halimbawa sa ibaba ang naka-stream na anyo ng [0,[1]], Kung saan ay
[[0],0],[[1,0],1],[[1,0]],[[1]].

Kasama sa mga streaming form ang [ , ] (upang ipahiwatig ang anumang scalar value, walang laman na array,
o walang laman na bagay), at [ ] (upang ipahiwatig ang dulo ng isang array o bagay). kinabukasan
mga bersyon ng jq run with --stream at -seq maaaring maglabas ng mga karagdagang anyo tulad ng [" pagkakamali
mensahe"] kapag hindi na-parse ang isang input text.

truncate_stream(stream_expression)
Gumagamit ng numero bilang input at pinuputol ang katumbas na bilang ng mga elemento ng path mula sa
kaliwa ng mga output ng ibinigay na streaming expression.

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

fromstream(stream_expression)
Mga halaga ng output na tumutugma sa mga output ng expression ng stream.

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

mag-stream
Ang mag-stream Ang builtin ay naglalabas ng naka-stream na anyo ng input nito.

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

ASSIGNMENT

Ang pagtatalaga ay gumagana nang medyo naiiba sa jq kaysa sa karamihan ng mga programming language. hindi si jq
makilala ang pagkakaiba sa pagitan ng mga sanggunian at mga kopya ng isang bagay - dalawang bagay o array ay
alinman sa pantay o hindi pantay, nang walang anumang karagdagang paniwala ng pagiging "parehong bagay" o "hindi
ang parehong bagay".

Kung ang isang bagay ay may dalawang patlang na mga array, .foo at .Cafe, at may idinagdag ka sa
.foo, Pagkatapos .Cafe hindi lalago. Kahit na itinakda mo lang .Cafe = .foo. Kung ginamit ka
sa programming sa mga wika tulad ng Python, Java, Ruby, Javascript, atbp. pagkatapos ay maaari mong isipin
nito na parang gumagawa si jq ng buong malalim na kopya ng bawat bagay bago nito gawin ang takdang-aralin
(para sa pagganap, hindi talaga nito ginagawa iyon, ngunit iyon ang pangkalahatang ideya).

Ang lahat ng mga operator ng pagtatalaga sa jq ay may mga expression ng path sa kaliwang bahagi.

=
Ang filter .foo = 1 ay kukuha bilang input ng isang bagay at gagawa bilang output ng isang bagay na may
Ang field na "foo" ay nakatakda sa 1. Walang ideya ng "pagbabago" o "pagbabago" ng isang bagay sa jq -
lahat ng jq value ay hindi nababago. Halimbawa,

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

hindi magkakaroon ng side-effect ng pagtatakda ng .bar.baz na itatakda sa 1, bilang katulad ng hitsura
programa sa Javascript, Python, Ruby o iba pang mga wika. Hindi tulad ng mga wikang ito (ngunit
tulad ng Haskell at ilang iba pang mga functional na wika), walang paniwala ng dalawang arrays o
mga bagay na "parehong hanay" o "parehong bagay". Maaari silang maging pantay, o hindi pantay, ngunit
kung babaguhin natin ang isa sa kanila sa anumang pagkakataon ay magbabago ang isa sa likod natin.

Nangangahulugan ito na imposibleng bumuo ng mga pabilog na halaga sa jq (tulad ng isang array na ang
ang unang elemento ay mismo). Ito ay lubos na sinadya, at tinitiyak na ang anumang bagay na jq
program ay maaaring gawin ay maaaring katawanin sa JSON.

Tandaan na ang kaliwang bahagi ng ´=´ ay tumutukoy sa isang halaga sa .. Kaya naman $var.foo = 1 hindi gagana
tulad ng inaasahan ($var.foo ay hindi isang wasto o kapaki-pakinabang na pagpapahayag ng path sa .); gamitin $var | .foo = 1
sa halip.

Kung ang kanang bahagi ng ´=´ ay gumagawa ng maramihang mga halaga, kung gayon para sa bawat ganoong halaga ay gagawin ng jq
itakda ang mga landas sa kaliwang bahagi sa halaga at pagkatapos ay ilalabas nito ang binagong ..
Halimbawa, (.a,.b)=saklaw(2) output {"a":0,"b":0}, Pagkatapos {"a":1,"b":1}. Ang "update"
ang mga form ng pagtatalaga (tingnan sa ibaba) ay huwag gawin ito.

Tandaan din iyan .a,.b=0 hindi nakatakda .a at .b, Ngunit (.a,.b)=0 nagtatakda pareho.

|=
Pati na rin ang assignment operator ´=´, ang jq ay nagbibigay ng "update" operator ´|=´, na
kumukuha ng filter sa kanang bahagi at ginagawa ang bagong halaga para sa property ng .
na itinalaga sa pamamagitan ng pagpapatakbo ng lumang halaga sa pamamagitan ng expression na ito. Halimbawa, .foo |=
Ang .+1 ay bubuo ng object na may field na "foo" na nakatakda sa input's "foo" plus 1.

Dapat ipakita ng halimbawang ito ang pagkakaiba sa pagitan ng ´=´ at ´|=´:

Magbigay ng input ´{"a": {"b": 10}, "b": 20}´ sa mga program:

.a = .b .a |= .b

Itatakda ng dating ang field na "a" ng input sa field na "b" ng input, at maglalabas
ang output {"a": 20}. Itatakda ng huli ang field na "a" ng input sa field na "a".
"b" na field, na gumagawa ng {"a": 10}.

Ang kaliwang bahagi ay maaaring maging anumang pangkalahatang pagpapahayag ng landas; tingnan mo landas().

Tandaan na ang kaliwang bahagi ng ´|=´ ay tumutukoy sa isang halaga sa .. Kaya naman $var.foo |= . + 1 ay hindi
magtrabaho tulad ng inaasahan ($var.foo ay hindi isang wasto o kapaki-pakinabang na pagpapahayag ng path sa .); gamitin $var | .foo
|= . + 1 sa halip.

Kung ang kanang bahagi ay maglalabas ng maraming halaga, ang huli lang ang gagamitin.

jq ´(..|select(type=="boolean")) |= if . pagkatapos ay 1 pa 0 dulo´
[true,false,[5,true,[true,[false]],false]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, /=, %=, // =
Ang jq ay may ilang mga operator ng form a op= b, na lahat ay katumbas ng a |= . op b. Kaya,
+= 1 ay maaaring gamitin sa pagtaas ng mga halaga.

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

Mahirap unawain mga takdang-aralin
Mas maraming bagay ang pinapayagan sa kaliwang bahagi ng isang jq assignment kaysa sa karamihan
mga wika. Nakakita na kami ng mga simpleng pag-access sa field sa kaliwang bahagi, at hindi
sorpresa na ang pag-access ng array ay gumagana rin:

.posts[0].title = "Manwal ng JQ"

Ang maaaring dumating bilang isang sorpresa ay ang expression sa kaliwa ay maaaring makagawa ng maramihang
mga resulta, na tumutukoy sa iba't ibang mga punto sa dokumento ng pag-input:

.post[].komento |= . + ["ito ay mahusay"]

Ang halimbawang iyon ay nagdaragdag ng string na "maganda ito" sa hanay ng "mga komento" ng bawat post sa
ang input (kung saan ang input ay isang bagay na may field na "mga post" na isang hanay ng mga post).

Kapag nakatagpo ang jq ng isang takdang-aralin tulad ng ´a = b´, itinatala nito ang "path" na tinahak upang pumili ng a
bahagi ng input na dokumento habang isinasagawa ang a. Ang landas na ito ay pagkatapos ay ginagamit upang mahanap kung aling bahagi ng
ang input na babaguhin habang isinasagawa ang takdang-aralin. Anumang filter ay maaaring gamitin sa
kaliwang bahagi ng isang katumbas - alinman sa mga landas na pipiliin nito mula sa input ay kung saan ang
isinasagawa ang takdang-aralin.

Ito ay isang napakalakas na operasyon. Ipagpalagay na gusto naming magdagdag ng komento sa mga post sa blog, gamit
ang parehong "blog" na input sa itaas. Sa pagkakataong ito, gusto lang naming magkomento sa mga post na isinulat ni
"stedolan". Mahahanap natin ang mga post na iyon gamit ang function na "piliin" na inilarawan kanina:

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

Ang mga landas na ibinigay ng operasyong ito ay tumuturo sa bawat isa sa mga post na isinulat ng "stedolan", at
maaari tayong magkomento sa bawat isa sa kanila sa parehong paraan na ginawa natin noon:

(.post[] | piliin(.may-akda == "stedolan") | .komento) |=
. + ["kakila-kilabot."]

MGA MODULO

Ang jq ay may library/module system. Ang mga module ay mga file na ang mga pangalan ay nagtatapos .jq.

Hinahanap ang mga module na na-import ng isang program sa isang default na landas sa paghahanap (tingnan sa ibaba). Ang
angkat at isama pinahihintulutan ng mga direktiba ang importer na baguhin ang landas na ito.

Ang mga landas sa isang path ng paghahanap ay napapailalim sa iba't ibang mga pagpapalit.

Para sa mga landas na nagsisimula sa "~/", ang home directory ng user ay pinapalitan ng "~".

Para sa mga path na nagsisimula sa "$ORIGIN/", ang path ng jq executable ay pinapalitan
"$ORIGIN".

Para sa mga path na nagsisimula sa "./" o mga path na ".", ang path ng kasamang file ay
pinalitan ng ".". Para sa mga top-level na programa na ibinigay sa command-line, ang kasalukuyang
ginagamit ang direktoryo.

Ang mga direktiba sa pag-import ay maaaring opsyonal na tumukoy ng isang landas sa paghahanap kung saan nakadugtong ang default.

Ang default na landas sa paghahanap ay ang landas sa paghahanap na ibinigay sa -L command-line na opsyon, iba pa
["~/.jq", "$ORIGIN/../lib/jq", "$ORIGIN/../ lib"].

Ang mga walang laman at walang laman na elemento ng string path ay nagwawakas sa pagpoproseso ng search path.

Ang isang dependency na may kaugnay na landas na "foo/bar" ay hahanapin sa "foo/bar.jq" at
"foo/bar/bar.jq" sa ibinigay na landas sa paghahanap. Ito ay inilaan upang payagan ang mga module na mailagay
sa isang direktoryo kasama ng, halimbawa, mga version control file, README file, at iba pa,
ngunit upang payagan din ang mga module ng single-file.

Ang magkakasunod na bahagi na may parehong pangalan ay hindi pinapayagan upang maiwasan ang mga kalabuan (hal,
"foo/foo").

Halimbawa, kasama -L$HOME/.jq isang module foo ay matatagpuan sa $HOME/.jq/foo.jq at
$HOME/.jq/foo/foo.jq.

Kung ang "$HOME/.jq" ay isang file, ito ay mula sa pangunahing programa.

angkat RelativePathString as NAME [ ];
Nag-i-import ng module na matatagpuan sa ibinigay na path na nauugnay sa isang direktoryo sa isang path ng paghahanap. Isang ".jq"
idaragdag ang suffix sa relatibong string ng path. Ang mga simbolo ng module ay may prefix na
"PANGALAN::".

Ang opsyonal na metadata ay dapat na isang pare-parehong jq expression. Dapat itong isang bagay na may mga susi
tulad ng "homepage" at iba pa. Sa oras na ito ginagamit lamang ng jq ang "search" key/value ng
metadata. Ang metadata ay ginawa ding available sa mga user sa pamamagitan ng modulemeta builtin.

Ang "search" key sa metadata, kung mayroon, ay dapat may string o array value (array
ng mga string); ito ang landas sa paghahanap na ilalagay sa nangungunang antas ng landas sa paghahanap.

isama RelativePathString [ ];
Nag-i-import ng module na matatagpuan sa ibinigay na path na nauugnay sa isang direktoryo sa isang path ng paghahanap na parang ito
ay kasama sa lugar. Ang isang ".jq" na suffix ay idaragdag sa relatibong string ng path. Ang
Ang mga simbolo ng module ay ini-import sa namespace ng tumatawag na parang mayroon ang nilalaman ng module
direktang isinama.

Ang opsyonal na metadata ay dapat na isang pare-parehong jq expression. Dapat itong isang bagay na may mga susi
tulad ng "homepage" at iba pa. Sa oras na ito ginagamit lamang ng jq ang "search" key/value ng
metadata. Ang metadata ay ginawa ding available sa mga user sa pamamagitan ng modulemeta builtin.

angkat RelativePathString as $NAME [ ];
Nag-i-import ng JSON file na matatagpuan sa ibinigay na path na nauugnay sa isang direktoryo sa isang path ng paghahanap. A
Ang ".json" na suffix ay idaragdag sa kaugnay na string ng path. Ang data ng file ay magiging
magagamit bilang $NAME::NAME.

Ang opsyonal na metadata ay dapat na isang pare-parehong jq expression. Dapat itong isang bagay na may mga susi
tulad ng "homepage" at iba pa. Sa oras na ito ginagamit lamang ng jq ang "search" key/value ng
metadata. Ang metadata ay ginawa ding available sa mga user sa pamamagitan ng modulemeta builtin.

Ang "search" key sa metadata, kung mayroon, ay dapat may string o array value (array
ng mga string); ito ang landas sa paghahanap na ilalagay sa nangungunang antas ng landas sa paghahanap.

module ;
Ang direktiba na ito ay ganap na opsyonal. Hindi ito kinakailangan para sa tamang operasyon. Ito'y nagsisilbing
ang layunin lamang ng pagbibigay ng metadata na mababasa gamit ang modulemeta builtin.

Ang metadata ay dapat na isang pare-parehong jq expression. Dapat itong isang bagay na may mga susi tulad ng
"homepage". Sa ngayon, hindi ginagamit ng jq ang metadata na ito, ngunit ginagawa itong available sa mga user
sa pamamagitan ng modulemeta builtin.

modulemeta
Kinukuha ang isang pangalan ng module bilang input at inilalabas ang metadata ng module bilang isang bagay, kasama ang
module's imports (kabilang ang metadata) bilang array value para sa "deps" key.

Magagamit ito ng mga program upang mag-query ng metadata ng isang module, na maaari nilang gamitin sa, para sa
halimbawa, maghanap, mag-download, at mag-install ng mga nawawalang dependency.

Gamitin ang jq online gamit ang mga serbisyo ng onworks.net