EnglishFrenchSpanyol

Ad


Favicon OnWorks

jq - Dalam talian di Awan

Jalankan jq dalam penyedia pengehosan percuma OnWorks melalui Ubuntu Online, Fedora Online, emulator dalam talian Windows atau emulator dalam talian MAC OS

Ini ialah arahan jq yang boleh dijalankan dalam penyedia pengehosan percuma OnWorks menggunakan salah satu daripada berbilang stesen kerja dalam talian percuma kami seperti Ubuntu Online, Fedora Online, emulator dalam talian Windows atau emulator dalam talian MAC OS.

JADUAL:

NAMA


jq - Pemproses JSON baris perintah

SINOPSIS


jq [pilihan...] menapis [fail...]

jq boleh mengubah JSON dalam pelbagai cara, dengan memilih, lelaran, mengurangkan dan sebaliknya
merosakkan dokumen JSON. Sebagai contoh, menjalankan arahan jq ´peta(.price) | Tambah akan
ambil tatasusunan objek JSON sebagai input dan kembalikan jumlah medan "harga" mereka.

jq boleh menerima input teks juga, tetapi secara lalai, jq membaca aliran entiti JSON
(termasuk nombor dan huruf lain) daripada stdin. Ruang putih hanya diperlukan untuk memisahkan
entiti seperti 1 dan 2, dan benar dan salah. Satu atau lebih fail boleh dinyatakan, di mana
kes jq sebaliknya akan membaca input daripada mereka.

. pilihan diterangkan dalam MENYERU JQ bahagian; kebanyakannya melibatkan input dan output
pemformatan. The menapis ditulis dalam bahasa jq dan menentukan cara mengubah
input fail atau dokumen.

FILTERS


Program jq ialah "penapis": ia mengambil input, dan menghasilkan output. Terdapat banyak
penapis terbina untuk mengekstrak medan tertentu objek, atau menukar nombor kepada
rentetan, atau pelbagai tugas standard lain.

Penapis boleh digabungkan dalam pelbagai cara - anda boleh menyalurkan output satu penapis ke dalam
penapis lain, atau kumpulkan output penapis ke dalam tatasusunan.

Sesetengah penapis menghasilkan berbilang hasil, contohnya ada satu yang menghasilkan semua
elemen tatasusunan inputnya. Menyalurkan penapis itu ke dalam satu saat menjalankan penapis kedua untuk
setiap elemen tatasusunan. Secara amnya, perkara yang akan dilakukan dengan gelung dan lelaran
dalam bahasa lain hanya dilakukan dengan melekatkan penapis bersama dalam jq.

Penting untuk diingat bahawa setiap penapis mempunyai input dan output. Malah secara literal
seperti "hello" atau 42 ialah penapis - mereka mengambil input tetapi sentiasa menghasilkan literal yang sama seperti
pengeluaran. Operasi yang menggabungkan dua penapis, seperti penambahan, biasanya memberi input yang sama
kepada kedua-duanya dan menggabungkan hasilnya. Jadi, anda boleh melaksanakan penapis purata sebagai menambah / panjang
- menyuap tatasusunan input kedua-duanya ke menambah penapis dan panjang penapis dan kemudian melakukan
bahagian itu.

Tetapi itu mendahului diri kita sendiri. :) Mari kita mulakan dengan sesuatu yang lebih mudah:

MENYERU JQ


penapis jq dijalankan pada aliran data JSON. Input kepada jq dihuraikan sebagai urutan
nilai JSON yang dipisahkan ruang putih yang disalurkan melalui penapis yang disediakan satu pada a
masa. Output(s) penapis ditulis mengikut standard keluar, sekali lagi sebagai urutan
data JSON yang dipisahkan ruang putih.

Nota: adalah penting untuk mengambil kira peraturan petikan shell. Sebagai peraturan umum, sebaiknya
sentiasa memetik (dengan aksara petikan tunggal) program jq, kerana terlalu banyak aksara dengan
makna istimewa kepada jq juga ialah aksara meta shell. Sebagai contoh, jq "foo" akan gagal pada
kebanyakan cengkerang Unix kerana itu akan sama seperti jq foo, yang biasanya akan gagal
kerana foo is tidak ditakrifkan. Apabila menggunakan shell arahan Windows (cmd.exe) sebaiknya
gunakan petikan berganda di sekitar program jq anda apabila diberikan pada baris arahan (bukannya -f
fail program pilihan), tetapi kemudian petikan berganda dalam program jq memerlukan garis miring ke belakang melarikan diri.

Anda boleh mempengaruhi cara jq membaca dan menulis input dan outputnya menggunakan beberapa baris arahan
pilihan yang berikut:

· --versi:

Keluarkan versi jq dan keluar dengan sifar.

· --seq:

Menggunakan application/json-seq Skim jenis MIME untuk memisahkan teks JSON dalam input jq
dan keluaran. Ini bermakna aksara ASCII RS (pemisah rekod) dicetak sebelum ini
setiap nilai pada output dan ASCII LF (line feed) dicetak selepas setiap output. Input
Teks JSON yang gagal dihuraikan diabaikan (tetapi diberi amaran), membuang semua
input seterusnya sehingga RS seterusnya. Ini lebih juga menghuraikan output jq tanpa
--seq pilihan.

· --strim:

Menghuraikan input dalam fesyen penstriman, mengeluarkan tatasusunan laluan dan nilai daun
(skalar dan tatasusunan kosong atau objek kosong). Sebagai contoh, "a" menjadi [[],"a"], dan
[[],"a",["b"]] menjadi [[0],[]], [[1],"a"], dan [[1,0],"b"].

Ini berguna untuk memproses input yang sangat besar. Gunakan ini bersama-sama dengan
penapisan dan mengurangkan and foreach sintaks untuk mengurangkan input besar secara berperingkat.

· --slurp/-s:

Daripada menjalankan penapis untuk setiap objek JSON dalam input, baca keseluruhan input
strim ke dalam tatasusunan yang besar dan jalankan penapis sekali sahaja.

· --input mentah/-R:

Jangan menghuraikan input sebagai JSON. Sebaliknya, setiap baris teks dihantar ke penapis sebagai a
tali. Jika digabungkan dengan --slurp, maka keseluruhan input dihantar ke penapis sebagai a
tali panjang tunggal.

· --input-null/-n:

Jangan baca sebarang input sama sekali! Sebaliknya, penapis dijalankan sekali menggunakan sifar sebagai input.
Ini berguna apabila menggunakan jq sebagai kalkulator mudah atau untuk membina data JSON daripada
awal.

· --keluaran padat / -c:

Secara lalai, jq pretty-prints output JSON. Menggunakan pilihan ini akan menghasilkan lebih banyak lagi
output padat dengan meletakkan setiap objek JSON pada satu baris.

· --tab:

Gunakan tab untuk setiap tahap lekukan dan bukannya dua ruang.

· --indent n:

Gunakan bilangan ruang yang diberikan (tidak lebih daripada 8) untuk lekukan.

· --warna-output / -C and --output monokrom / -M:

Secara lalai, jq mengeluarkan JSON berwarna jika menulis ke terminal. Anda boleh memaksanya
menghasilkan warna walaupun menulis pada paip atau fail menggunakan -C, dan lumpuhkan warna dengan -M.

· --ascii-output / -a:

jq biasanya mengeluarkan titik kod Unicode bukan ASCII sebagai UTF-8, walaupun input ditentukan
mereka sebagai urutan melarikan diri (seperti "\u03bc"). Menggunakan pilihan ini, anda boleh memaksa jq untuk
menghasilkan output ASCII tulen dengan setiap aksara bukan ASCII digantikan dengan yang setara
urutan melarikan diri.

· --tidak ditimbal

Siram output selepas setiap objek JSON dicetak (berguna jika anda membuat paip perlahan
sumber data ke dalam jq dan menyalurkan output jq di tempat lain).

· --kunci-isih / -S:

Keluarkan medan setiap objek dengan kekunci dalam susunan yang disusun.

· --output mentah / -r:

Dengan pilihan ini, jika hasil penapis ialah rentetan maka ia akan ditulis terus
kepada output standard dan bukannya diformatkan sebagai rentetan JSON dengan petikan. Ini boleh
berguna untuk membuat penapis jq bercakap dengan sistem bukan berasaskan JSON.

· --menyertai-output / -j:

suka -r tetapi jq tidak akan mencetak baris baharu selepas setiap output.

· -f nama fail / --dari-fail nama fail:

Baca penapis daripada fail dan bukannya daripada baris arahan, seperti pilihan awk´s -f. awak
juga boleh menggunakan ´#´ untuk membuat ulasan.

· -Ldirektori / -L direktori:

Bersiaplah direktori ke senarai carian untuk modul. Jika pilihan ini digunakan maka tidak
senarai carian terbina digunakan. Lihat bahagian modul di bawah.

· -e / --status keluar:

Tetapkan status keluar jq kepada 0 jika nilai keluaran terakhir bukan kedua-duanya palsu tidak sifar,
1 jika nilai keluaran terakhir adalah sama ada palsu or sifar, atau 4 jika tiada keputusan yang sah
dihasilkan. Biasanya jq keluar dengan 2 jika terdapat sebarang masalah penggunaan atau ralat sistem, 3
jika terdapat ralat penyusunan program jq, atau 0 jika program jq berjalan.

· --arg nama nilai:

Pilihan ini memberikan nilai kepada program jq sebagai pembolehubah yang dipratentukan. Jika anda menjalankan jq
bersama --arg foo bar, Maka $foo tersedia dalam program dan mempunyai nilai "bar".
Perhatikan bahawa nilai akan dianggap sebagai rentetan, jadi --arg foo 123 akan mengikat $foo kepada "123".

· --argjson nama Teks JSON:

Pilihan ini menghantar nilai yang dikodkan JSON kepada program jq sebagai pembolehubah yang dipratentukan. Jika
anda menjalankan jq dengan --argjson foo 123, Maka $foo tersedia dalam program ini dan mempunyai
nilai 123.

· --slurpfile nama ubah nama fail:

Pilihan ini membaca semua teks JSON dalam fail bernama dan mengikat tatasusunan fail
menghuraikan nilai JSON kepada pembolehubah global yang diberikan. Jika anda menjalankan jq dengan --argfile foo bar,
kemudian $foo tersedia dalam program dan mempunyai tatasusunan yang elemennya sepadan
teks dalam fail bernama bar.

· --argfile nama ubah nama fail:

Jangan guna. guna --slurpfile sebaliknya.

(Pilihan ini adalah seperti --slurpfile, tetapi apabila fail hanya mempunyai satu teks, maka itu adalah
digunakan, jika tidak pelbagai teks digunakan seperti dalam --slurpfile.)

· --lari-ujian [nama fail]:

Menjalankan ujian dalam fail atau input standard yang diberikan. Ini mestilah pilihan terakhir yang diberikan
dan tidak menghormati semua pilihan sebelumnya. Input terdiri daripada baris ulasan, kosong
baris, dan baris program diikuti dengan satu baris input, seberapa banyak baris output
dijangka (satu setiap keluaran), dan baris kosong penamat. Ujian kegagalan kompilasi
mulakan dengan baris yang mengandungi hanya "%% FAIL", kemudian baris yang mengandungi program ke
susun, kemudian baris yang mengandungi mesej ralat untuk dibandingkan dengan yang sebenar.

Berhati-hati bahawa pilihan ini boleh berubah ke belakang-tidak serasi.

ASAS FILTERS


.
Penapis yang paling mudah (dan paling tidak menarik) ialah .. Ini adalah penapis yang mengambilnya
input dan menghasilkannya tidak berubah sebagai output.

Oleh kerana jq secara lalai mencetak semua output, program remeh ini boleh menjadi cara yang berguna
memformat output JSON daripada, katakan, curl.

jq ´.´
"Hai dunia!"
=> "Hello, dunia!"

.foo, .foo.bar
Yang paling mudah berguna penapis adalah .foo. Apabila diberi objek JSON (aka kamus atau hash) sebagai
input, ia menghasilkan nilai pada kekunci "foo", atau batal jika tiada yang hadir.

Jika kunci mengandungi aksara khas, anda perlu mengelilinginya dengan petikan berganda seperti
ini: ."foo$".

Penapis borang .foo.bar adalah bersamaan dengan .foo|.bar.

jq ´.foo´
{"foo": 42, "bar": "data kurang menarik"}
=> 42

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

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

.foo?
Seperti .foo, tetapi tidak mengeluarkan walaupun ralat apabila . bukan tatasusunan atau objek.

jq ´.foo?´
{"foo": 42, "bar": "data kurang menarik"}
=> 42

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

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

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

.[ ], .[2], .[10:15]
Anda juga boleh mencari medan objek menggunakan sintaks seperti .["foo"] (.foo di atas ialah a
versi ringkas ini). Yang ini berfungsi untuk tatasusunan juga, jika kuncinya ialah integer.
Tatasusunan adalah berasaskan sifar (seperti javascript), jadi . [2] mengembalikan elemen ketiga tatasusunan.

. .[10:15] sintaks boleh digunakan untuk mengembalikan subarray tatasusunan atau subrentetan rentetan.
Tatasusunan dikembalikan oleh .[10:15] akan mempunyai panjang 5, mengandungi unsur-unsur dari indeks 10
(termasuk) hingga indeks 15 (eksklusif). Mana-mana indeks mungkin negatif (dalam hal ini ia dikira
ke belakang dari penghujung tatasusunan), atau ditinggalkan (dalam hal ini ia merujuk kepada permulaan atau
hujung tatasusunan).

. . [2] sintaks boleh digunakan untuk mengembalikan elemen pada indeks yang diberikan. Indeks negatif ialah
dibenarkan, dengan -1 merujuk kepada elemen terakhir, -2 merujuk kepada elemen seterusnya hingga terakhir,
dan sebagainya.

. .foo sintaks hanya berfungsi untuk kekunci semata-mata iaitu kekunci yang kesemuanya adalah aksara alfanumerik.
.[ ] berfungsi dengan kekunci yang mengandungi aksara khas seperti titik bertindih dan titik. Untuk
contoh .["foo::bar"] and .["foo.bar"] bekerja sambil .foo::bar and .foo.bar tidak akan.

. ? "operator" juga boleh digunakan dengan operator slice, seperti dalam .[10:15]?, yang mengeluarkan
nilai di mana input boleh dihiris.

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

.[]
Sekiranya anda menggunakannya .[indeks] sintaks, tetapi tinggalkan indeks sepenuhnya, ia akan kembali semua daripada
elemen tatasusunan. Berlari .[] dengan input [1,2,3] akan menghasilkan nombor sebagai tiga
keputusan berasingan, bukannya sebagai tatasusunan tunggal.

Anda juga boleh menggunakan ini pada objek, dan ia akan mengembalikan semua nilai objek.

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

.[]?
suka .[], tetapi tiada ralat akan dikeluarkan jika . bukan tatasusunan atau objek.

,
Jika dua penapis dipisahkan dengan koma, maka input akan dimasukkan ke dalam kedua-duanya dan di sana
akan menjadi berbilang output: pertama, semua output yang dihasilkan oleh ungkapan kiri, dan
maka semua keluaran yang dihasilkan oleh kanan. Sebagai contoh, penapis .foo, .Kafe, menghasilkan
kedua-dua medan "foo" dan medan "bar" sebagai output yang berasingan.

jq ´.foo, .bar´
{"foo": 42, "bar": "sesuatu yang lain", "baz": true}
=> 42, "sesuatu yang lain"

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

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

|
| operator menggabungkan dua penapis dengan menyuap keluaran yang di sebelah kiri ke dalam
input yang di sebelah kanan. Ia hampir sama dengan paip shell Unix, jika
anda sudah biasa dengan itu.

Jika yang di sebelah kiri menghasilkan berbilang hasil, yang di sebelah kanan akan dijalankan
setiap keputusan tersebut. Jadi, ungkapan .[] | .foo mendapatkan semula medan "foo" setiap satu
elemen tatasusunan input.

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

JENIS DAN NILAI-NILAI


jq menyokong set jenis data yang sama seperti JSON - nombor, rentetan, boolean, tatasusunan,
objek (yang dalam JSON-speak adalah cincang dengan kunci rentetan sahaja), dan "null".

Boolean, null, rentetan dan nombor ditulis dengan cara yang sama seperti dalam javascript. Seperti
semua yang lain dalam jq, nilai mudah ini mengambil input dan menghasilkan output - 42 ialah
ungkapan jq yang sah yang mengambil input, mengabaikannya dan mengembalikan 42 sebaliknya.

Array pembinaan - []
Seperti dalam JSON, [] digunakan untuk membina tatasusunan, seperti dalam [1,2,3]. Unsur-unsur tatasusunan boleh
menjadi sebarang ungkapan jq. Semua hasil yang dihasilkan oleh semua ungkapan dikumpul
menjadi satu susunan besar. Anda boleh menggunakannya untuk membina tatasusunan daripada kuantiti nilai yang diketahui
(seperti dalam [.foo, .bar, .baz]) atau untuk "mengumpul" semua hasil penapis ke dalam tatasusunan (as
in [.item[].nama])

Sebaik sahaja anda memahami pengendali ",", anda boleh melihat sintaks tatasusunan jq dalam yang berbeza
cahaya: ungkapan [1,2,3] tidak menggunakan sintaks terbina dalam untuk tatasusunan dipisahkan koma,
tetapi sebaliknya menggunakan [] operator (kumpul hasil) kepada ungkapan 1,2,3 (yang
menghasilkan tiga keputusan yang berbeza).

Jika anda mempunyai penapis X yang menghasilkan empat keputusan, kemudian ungkapan [X] akan menghasilkan a
hasil tunggal, susunan empat elemen.

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

Objek - {}
Seperti JSON, {} adalah untuk membina objek (aka kamus atau cincang), seperti dalam: {"a": 42,
"b": tiga belas}.

Jika kekunci "masuk akal" (semua aksara abjad), maka petikan boleh ditinggalkan.
Nilainya boleh berupa sebarang ungkapan (walaupun anda mungkin perlu membungkusnya dalam kurungan jika ia
rumit), yang akan digunakan pada input ungkapan {} (ingat, semua penapis
mempunyai input dan output).

{foo: .bar}

akan menghasilkan objek JSON {"foo": tiga belas} jika diberi objek JSON {"bar":42, "baz":43}.
Anda boleh menggunakan ini untuk memilih medan tertentu objek: jika input adalah objek dengan
medan "pengguna", "tajuk", "id", dan "kandungan" dan anda hanya mahu "pengguna" dan "tajuk", anda boleh
menulis

{user: .user, title: .title}

Kerana itu sangat biasa, terdapat sintaks pintasan: {pengguna, tajuk}.

Jika salah satu ungkapan menghasilkan berbilang hasil, berbilang kamus akan menjadi
dihasilkan. Jika input's

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

kemudian ungkapan

{pengguna, tajuk: .titles[]}

akan menghasilkan dua output:

{"user":"stedolan", "title": "JQ Primer"}
{"user":"stedolan", "title": "Lebih banyak JQ"}

Meletakkan kurungan di sekeliling kunci bermakna ia akan dinilai sebagai ungkapan. Dengan
input yang sama seperti di atas,

{(.user): .titles}

menghasilkan

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

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

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

BUILTIN PENGENDALI DAN FUNGSI


Beberapa operator jq (contohnya, +) melakukan perkara yang berbeza bergantung pada jenis mereka
hujah (susunan, nombor, dll.). Walau bagaimanapun, jq tidak pernah melakukan penukaran jenis tersirat. Jika
anda cuba menambah rentetan pada objek anda akan mendapat mesej ralat dan tiada hasil.

Selain itu - +
Pengendali + mengambil dua penapis, menggunakan kedua-duanya pada input yang sama, dan menambah
hasil bersama. Maksud "menambah" bergantung pada jenis yang terlibat:

· nombor ditambah dengan aritmetik biasa.

· Arrays ditambah dengan digabungkan ke dalam tatasusunan yang lebih besar.

· Rentetan ditambah dengan dicantumkan ke dalam rentetan yang lebih besar.

· Objek ditambah dengan menggabungkan, iaitu, memasukkan semua pasangan nilai kunci daripada kedua-duanya
objek menjadi satu objek gabungan. Jika kedua-dua objek mengandungi nilai yang sama
kunci, objek di sebelah kanan + menang. (Untuk gabungan rekursif gunakan * pengendali.)

sifar boleh ditambah kepada sebarang nilai, dan mengembalikan nilai lain tidak berubah.

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

Penolakan - -
Serta penolakan aritmetik biasa pada nombor, yang - operator boleh digunakan pada tatasusunan
untuk mengalih keluar semua kejadian unsur tatasusunan kedua daripada tatasusunan pertama.

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

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

pendaraban, pembahagian, modul - *, /, and %
Operator infiks ini berkelakuan seperti yang diharapkan apabila diberi dua nombor. Pembahagian dengan kenaikan sifar
kesilapan. x % y mengira x modulo y.

Mendarab rentetan dengan nombor menghasilkan gabungan rentetan itu sebanyak itu
kali. "x" * 0 menghasilkan sifar.

Membahagikan rentetan dengan yang lain membelah yang pertama menggunakan yang kedua sebagai pemisah.

Mendarab dua objek akan menggabungkannya secara rekursif: ini berfungsi seperti penambahan tetapi jika kedua-duanya
objek mengandungi nilai untuk kunci yang sama, dan nilai adalah objek, kedua-duanya digabungkan
dengan strategi yang sama.

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

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

panjang
Fungsi builtin panjang mendapat panjang pelbagai jenis nilai:

· Panjang a rentetan ialah bilangan titik kod Unicode yang terkandung di dalamnya (yang akan menjadi
sama dengan panjang yang dikodkan JSON dalam bait jika ia ASCII tulen).

· Panjang sebuah pelbagai ialah bilangan unsur.

· Panjang sebuah objek ialah bilangan pasangan nilai kunci.

· Panjang sifar adalah sifar.

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

kunci, keys_unsorted
Fungsi builtin kunci, apabila diberi objek, mengembalikan kuncinya dalam tatasusunan.

Kekunci diisih "mengikut abjad", mengikut susunan titik kod unikod. Ini bukan perintah
yang masuk akal dalam mana-mana bahasa tertentu, tetapi anda boleh mengharapkannya sebagai
sama untuk mana-mana dua objek dengan set kunci yang sama, tanpa mengira tetapan setempat.

Bila kunci diberikan tatasusunan, ia mengembalikan indeks yang sah untuk tatasusunan itu: integer
dari 0 hingga panjang-1.

. keys_unsorted fungsi adalah seperti kunci, tetapi jika input adalah objek maka kuncinya
tidak akan diisih, sebaliknya kekunci secara kasar akan berada dalam susunan sisipan.

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

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

mempunyai(kunci)
Fungsi builtin mempunyai mengembalikan sama ada objek input mempunyai kunci yang diberikan, atau input
tatasusunan mempunyai elemen pada indeks yang diberikan.

mempunyai($key) mempunyai kesan yang sama seperti memeriksa sama ada kunci $ ialah ahli tatasusunan yang dikembalikan
by kunci, walaupun mempunyai akan lebih pantas.

jq ´peta(mempunyai("foo"))´
[{"foo": 42}, {}]
=> [benar, salah]

jq ´peta(mempunyai(2))´
[[0,1], ["a","b","c"]]
=> [salah, benar]

in
Fungsi builtin in mengembalikan kunci input berada dalam objek yang diberikan, atau indeks input
sepadan dengan elemen dalam tatasusunan yang diberikan. Ia, pada asasnya, adalah versi songsang daripada
mempunyai.

jq ´.[] | dalam({"foo": 42})´
["foo", "bar"]
=> benar, salah

jq ´peta(dalam([0,1]))´
[2, 0]
=> [salah, benar]

jalan(path_expression)
Mengeluarkan perwakilan tatasusunan bagi ungkapan laluan yang diberikan dalam .. Output adalah tatasusunan daripada
rentetan (kunci dalam objek0 dan/atau nombor (indeks tatasusunan.

Ungkapan laluan adalah ungkapan jq seperti .a, Tetapi juga .[]. Terdapat dua jenis laluan
ungkapan: yang boleh sepadan dengan tepat, dan yang tidak boleh. Sebagai contoh, .abc merupakan
ungkapan laluan padanan tepat, manakala .a[].b tidak.

laluan(exact_path_expression) akan menghasilkan perwakilan tatasusunan bagi ungkapan laluan
walaupun ia tidak wujud dalam ., Jika . is sifar atau tatasusunan atau objek.

jalan (corak) akan menghasilkan perwakilan tatasusunan bagi padanan laluan pola jika
laluan wujud dalam ..

Ambil perhatian bahawa ungkapan laluan tidak berbeza daripada ungkapan biasa. Ekspresi
laluan(..|pilih(jenis=="boolean")) mengeluarkan semua laluan ke nilai boolean dalam ., dan hanya
jalan-jalan itu.

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

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

del(path_expression)
Fungsi builtin yang mengalih keluar kunci dan nilai yang sepadan daripada objek.

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, dengan_entri
Fungsi ini menukar antara objek dan tatasusunan pasangan nilai kunci. Jika kepada_entry
dilalui objek, kemudian untuk setiap k: v kemasukan dalam input, tatasusunan output termasuk
{"kunci": k, "nilai": v}.

from_entry melakukan penukaran yang bertentangan, dan with_entry(foo) adalah singkatan untuk
kepada_entry | peta(foo) | from_entry, berguna untuk melakukan beberapa operasi kepada semua kunci dan
nilai sesuatu objek. from_entry menerima kunci, Kunci, Nama, nilai dan Nilai sebagai kunci.

jq ´ke_entri´
{"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_enries(.key |= "KEY_" + .)´
{"a": 1, "b": 2}
=> {"KEY_a": 1, "KEY_b": 2}

pilih(ungkapan_boolean)
Majlis tersebut pilih(foo) menghasilkan inputnya tidak berubah jika foo kembali benar untuk input itu,
dan tidak menghasilkan keluaran sebaliknya.

Ia berguna untuk menapis senarai: [1,2,3] | peta(pilih(. >= 2)) akan memberikan anda [2,3].

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

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

tatasusunan, objek, boleh diulang, boolean, nombor, biasa, terhingga, rentetan, nulls, nilai,
skalar
Terbina dalam ini hanya memilih input yang merupakan tatasusunan, objek, iterable (tatasusunan atau
objek), boolean, nombor, nombor biasa, nombor terhingga, rentetan, nol, bukan nol
nilai, dan tidak boleh diulang, masing-masing.

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

kosong
kosong tidak mengembalikan hasil. Tiada langsung. Tak pun sifar.

Ia berguna sekali-sekala. Anda akan tahu jika anda memerlukannya :)

jq ´1, kosong, 2´
sifar
=> 1, 2

jq ´[1,2,kosong,3]´
sifar
=> [1,2,3]

kesilapan(mesej)
Menghasilkan ralat, sama seperti .a digunakan pada nilai selain null dan objek akan, tetapi
dengan mesej yang diberikan sebagai nilai ralat.

$__loc__
Menghasilkan objek dengan kunci "fail" dan kunci "baris", dengan nama fail dan nombor baris
di mana $__loc__ berlaku, sebagai nilai.

jq ´try error("\($__loc__)") tangkap .´
sifar
=> "{\"fail\":\" \",\"baris 1}"

peta(x), nilai_peta(x)
Untuk sebarang penapis x, peta(x) akan menjalankan penapis itu untuk setiap elemen tatasusunan input, dan
menghasilkan output tatasusunan baru. peta(.+1) akan menambah setiap elemen tatasusunan
nombor.

Begitu juga, nilai_peta(x) akan menjalankan penapis itu untuk setiap elemen, tetapi ia akan mengembalikan satu
objek apabila objek dilalui.

peta(x) adalah bersamaan dengan [.[] | x]. Sebenarnya, ini adalah bagaimana ia ditakrifkan. Begitu juga,
nilai_peta(x) ditakrifkan sebagai .[] |= x.

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

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

laluan, laluan(node_filter), laluan_daun
laluan mengeluarkan laluan ke semua elemen dalam inputnya (kecuali ia tidak mengeluarkan
senarai kosong, mewakili . sendiri).

laluan(f) mengeluarkan laluan ke mana-mana nilai yang f betul. Itu dia, laluan (nombor)
mengeluarkan laluan ke semua nilai berangka.

laluan_daun adalah alias daripada laluan (skalar); laluan_daun is deprecated dan akan dikeluarkan masuk
keluaran utama seterusnya.

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

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

menambah
Penapis menambah mengambil sebagai input tatasusunan, dan menghasilkan sebagai output elemen tatasusunan
ditambah bersama. Ini mungkin bermakna dijumlahkan, digabungkan atau digabungkan bergantung pada jenis
elemen tatasusunan input - peraturannya adalah sama seperti yang untuk + operator
(diterangkan di atas).

Jika input adalah tatasusunan kosong, menambah pulangan sifar.

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

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

jq 'tambah'
[]
=> null

ada, sebarang (syarat), mana-mana (penjana; keadaan)
Penapis mana-mana mengambil sebagai input tatasusunan nilai boolean, dan menghasilkan benar sebagai output jika
mana-mana elemen tatasusunan ialah benar.

Jika input adalah tatasusunan kosong, mana-mana pulangan palsu.

. sebarang (syarat) borang menggunakan syarat yang diberikan kepada elemen tatasusunan input.

. mana-mana (penjana; keadaan) borang menggunakan syarat yang diberikan kepada semua keluaran
penjana yang diberi.

jq 'mana-mana'
[betul salah]
=> benar

jq 'mana-mana'
[salah, palsu]
=> palsu

jq 'mana-mana'
[]
=> palsu

semua, semua (syarat), semua(penjana; keadaan)
Penapis semua mengambil sebagai input tatasusunan nilai boolean, dan menghasilkan benar sebagai output jika
semua elemen tatasusunan adalah benar.

. semua(syarat) borang menggunakan syarat yang diberikan kepada elemen tatasusunan input.

. semua(penjana; keadaan) borang menggunakan syarat yang diberikan kepada semua keluaran
penjana yang diberi.

Jika input adalah tatasusunan kosong, semua pulangan benar.

jq 'semua'
[betul salah]
=> palsu

jq 'semua'
[betul betul]
=> benar

jq 'semua'
[]
=> benar

[Memerlukan 1.5] ratakan, ratakan (dalam)
Penapis meratakan mengambil sebagai input tatasusunan bersarang, dan menghasilkan tatasusunan rata dalam
yang mana semua tatasusunan di dalam tatasusunan asal telah digantikan secara rekursif oleh nilainya.
Anda boleh memberikan hujah kepadanya untuk menentukan bilangan tahap sarang untuk diratakan.

meratakan(2) adalah seperti meratakan, tetapi hanya mencapai dua tahap dalam.

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

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

jq 'ratakan'
[[]]
=> []

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

julat (sehingga), julat (dari; sehingga) julat(dari;sehingga;oleh)
. pelbagai fungsi menghasilkan julat nombor. julat(4;10) menghasilkan 6 nombor, daripada 4
(termasuk) hingga 10 (eksklusif). Nombor-nombor itu dihasilkan sebagai output yang berasingan. guna
[julat(4;10)] untuk mendapatkan julat sebagai tatasusunan.

Borang argumen satu menjana nombor daripada 0 kepada nombor yang diberikan, dengan kenaikan sebanyak
1.

Dua bentuk hujah menjana nombor daripada dari kepada sehingga dengan kenaikan 1.

Tiga bentuk hujah menjana nombor dari kepada sehingga dengan kenaikan sebanyak by.

jq ´julat(2;4)´
sifar
=> 2, 3

jq ´[julat(2;4)]´
sifar
=> [2,3]

jq ´[pelbagai(4)]´
sifar
=> [0,1,2,3]

jq ´[julat(0;10;3)]´
sifar
=> [0,3,6,9]

jq ´[julat(0;10;-1)]´
sifar
=> []

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

lantai
. lantai fungsi mengembalikan lantai input berangkanya.

jq 'lantai'
3.14159
=> 3

persegi
. persegi fungsi mengembalikan punca kuasa dua input berangkanya.

jq ´sqrt´
9
=> 3

tonumber
. tonumber fungsi menghuraikan inputnya sebagai nombor. Ia akan menukar diformat dengan betul
rentetan kepada setara angka mereka, biarkan nombor sahaja, dan berikan ralat pada semua yang lain
input.

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

menjalin
. menjalin fungsi mencetak inputnya sebagai rentetan. Rentetan dibiarkan tidak berubah, dan semuanya
nilai lain dikodkan JSON.

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

jenis
. jenis fungsi mengembalikan jenis hujahnya sebagai rentetan, yang merupakan salah satu daripada null,
boolean, nombor, rentetan, tatasusunan atau objek.

jq ´peta(jenis)´
[0, palsu, [], {}, null, "hello"]
=> ["nombor", "boolean", "array", "objek", "null", "rentetan"]

tidak terhingga, nan, tidak terhingga, isnan, tidak terbatas, adalah perkara biasa
Sesetengah operasi aritmetik boleh menghasilkan nilai infiniti dan "bukan nombor" (NaN). The
tidak terhingga pulangan terbina benar jika inputnya tidak terhingga. The isnan pulangan terbina benar
jika inputnya ialah NaN. The tak terhingga builtin mengembalikan nilai tak terhingga yang positif. The nan
builtin mengembalikan NaN. The adalah perkara biasa builtin mengembalikan benar jika inputnya ialah nombor biasa.

Ambil perhatian bahawa pembahagian dengan sifar menimbulkan ralat.

Pada masa ini kebanyakan operasi aritmetik yang beroperasi pada infiniti, NaN dan sub-normal tidak
menimbulkan kesilapan.

jq ´.[] | (tak terhingga * .) < 0´
[-1, 1]
=> benar, salah

jq ´tak terhingga, nan | jenis'
sifar
=> "nombor", "nombor"

macam, sort_by(path_expression)
. jenis functions menyusun inputnya, yang mesti berupa tatasusunan. Nilai diisih dalam
perintah berikut:

· sifar

· palsu

· benar

· nombor

· rentetan, dalam susunan abjad (mengikut nilai titik kod unicode)

· tatasusunan, dalam susunan leksikal

· objek

Susunan untuk objek agak rumit: mula-mula mereka dibandingkan dengan membandingkannya
set kunci (sebagai tatasusunan dalam susunan yang disusun), dan jika kuncinya adalah sama maka nilainya adalah
membandingkan kunci demi kunci.

jenis boleh digunakan untuk mengisih mengikut medan tertentu objek, atau dengan menggunakan mana-mana penapis jq.

sort_by(foo) membandingkan dua elemen dengan membandingkan hasil daripada foo pada setiap elemen.

jq 'sort'
[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)
kumpulan_oleh(.foo) mengambil sebagai input tatasusunan, mengumpulkan unsur-unsur yang mempunyai sama .foo bidang
ke dalam tatasusunan berasingan, dan menghasilkan semua tatasusunan ini sebagai elemen tatasusunan yang lebih besar,
disusun mengikut nilai .foo lapangan.

Sebarang ungkapan jq, bukan hanya akses medan, boleh digunakan sebagai ganti .foo. Pengisihan
pesanan adalah sama seperti yang diterangkan dalam jenis fungsi di atas.

jq ´kumpulan_oleh(.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 maksima, min_by(path_exp), max_by(path_exp)
Cari elemen minimum atau maksimum tatasusunan input.

. min_by(path_exp) and max_by(path_exp) fungsi membenarkan anda untuk menentukan tertentu
bidang atau harta untuk diperiksa, cth min_by(.foo) mencari objek dengan terkecil foo
lapangan.

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

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

unik, unique_by(path_exp)
. unik fungsi mengambil sebagai input tatasusunan dan menghasilkan tatasusunan elemen yang sama, dalam
tertib diisih, dengan pendua dialih keluar.

. unique_by(path_exp) fungsi akan menyimpan hanya satu elemen untuk setiap nilai yang diperolehi oleh
mengaplikasikan hujah. Fikirkannya sebagai membuat tatasusunan dengan mengambil satu elemen daripada setiap elemen
kumpulan yang dihasilkan oleh kumpulan.

jq 'unik'
[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 ´unik_dengan(panjang)´
["ketul", "bacon", "kucing", "cicada", "asparagus"]
=> ["bacon", "chunky", "asparagus"]

berbalik
Fungsi ini membalikkan tatasusunan.

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

mengandungi(elemen)
Penapis mengandungi(b) akan menghasilkan benar jika b terkandung sepenuhnya dalam input. A
rentetan B terkandung dalam rentetan A jika B ialah subrentetan A. Tatasusunan B terkandung dalam
tatasusunan A jika semua elemen dalam B terkandung dalam mana-mana elemen dalam A. Objek B ialah
terkandung dalam objek A jika semua nilai dalam B terkandung dalam nilai dalam A dengan
kunci yang sama. Semua jenis lain diandaikan terkandung dalam satu sama lain jika ia adalah sama.

jq ´mengandungi("bar")´).
"foobar"
=> benar

jq ´mengandungi(["baz", "bar"])´
["foobar", "foobaz", "blarp"]
=> benar

jq ´mengandungi(["bazzzzz", "bar"])´
["foobar", "foobaz", "blarp"]
=> palsu

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

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

indeks
Mengeluarkan tatasusunan yang mengandungi indeks dalam . di mana s berlaku. Input mungkin array, in
kes yang mana jika s ialah tatasusunan maka keluaran indeks ialah tempat semua elemen masuk .
sepadan dengan yang s.

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

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

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

indeks, rindex(s)
Mengeluarkan indeks yang pertama (indeks) atau terakhir (rindex) kejadian s dalam input.

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

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

di dalam
Penapis dalam(b) akan menghasilkan benar jika input terkandung sepenuhnya dalam b. Ia
adalah, pada asasnya, versi songsang daripada mengandungi.

jq ´di dalam("foobar")´).
"bar"
=> benar

jq ´di dalam(["foobar", "foobaz", "blarp"])´
["baz", "bar"]
=> benar

jq ´di dalam(["foobar", "foobaz", "blarp"])´
["bazzzzz", "bar"]
=> palsu

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

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

bermula dengan(str)
Output benar kalau . bermula dengan hujah rentetan yang diberikan.

jq ´[.[]|bermula dengan("foo")]´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [salah, benar, salah, benar, palsu]

berakhir dengan(str)
Output benar kalau . berakhir dengan hujah rentetan yang diberikan.

jq ´[.[]|berakhir dengan("foo")]´
["foobar", "barfoo"]
=> [salah, benar]

gabungan, gabungan(n)
Mengeluarkan semua gabungan elemen tatasusunan dalam tatasusunan input. Jika diberi an
hujah n, ia mengeluarkan semua kombinasi n pengulangan tatasusunan input.

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

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

ltrimstr(str)
Mengeluarkan inputnya dengan rentetan awalan yang diberikan dialih keluar, jika ia bermula dengannya.

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

rtrimstr(str)
Mengeluarkan inputnya dengan rentetan akhiran yang diberikan dialih keluar, jika ia berakhir dengannya.

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

meletup
Menukar rentetan input kepada tatasusunan nombor titik kod rentetan.

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

meletup
Songsang meletup.

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

berpecah
Memisahkan rentetan input pada hujah pemisah.

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

sertai(str)
Menyertai tatasusunan elemen yang diberikan sebagai input, menggunakan hujah sebagai pemisah. Ia adalah
songsang daripada berpecah: iaitu berlari split("foo") | sertai("foo") atas sebarang rentetan input
mengembalikan rentetan input tersebut.

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

ascii_downcase, ascii_upcase
Keluarkan salinan rentetan input dengan aksara abjadnya (az dan AZ) ditukar kepada
kes yang ditentukan.

sementara(cond; kemas kini)
. sementara(cond; kemas kini) fungsi membolehkan anda menggunakan kemas kini berulang kali pada . sehingga cond
adalah palsu.

Perhatikan bahawa sementara(cond; kemas kini) ditakrifkan secara dalaman sebagai fungsi jq rekursif. rekursif
panggilan dalam manakala tidak akan menggunakan memori tambahan jika maklumat menghasilkan paling banyak satu
keluaran bagi setiap input. Lihat topik lanjutan di bawah.

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

sehingga(cond; seterusnya)
. sehingga(cond; seterusnya) fungsi membolehkan anda berulang kali menggunakan ungkapan seterusnya,
mulanya kepada . kemudian kepada keluarannya sendiri, sehingga cond betul. Sebagai contoh, ini boleh digunakan
untuk melaksanakan fungsi faktorial (lihat di bawah).

Perhatikan bahawa sehingga(cond; seterusnya) ditakrifkan secara dalaman sebagai fungsi jq rekursif. rekursif
panggilan dalam sehingga() tidak akan menggunakan memori tambahan jika seterusnya menghasilkan paling banyak satu
keluaran bagi setiap input. Lihat topik lanjutan di bawah.

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

berulang(f), berulang, berulang(f; keadaan), recurse_down
. berulang (f) fungsi membolehkan anda mencari melalui struktur rekursif, dan ekstrak
data yang menarik dari semua peringkat. Katakan input anda mewakili sistem fail:

{"nama": "/", "kanak-kanak": [
{"nama": "/ bin", "kanak-kanak": [
{"nama": "/bin/ls", "kanak-kanak": []},
{"nama": "/ Bin / sh", "kanak-kanak": []}]},
{"nama": "/ home", "kanak-kanak": [
{"name": "/home/stephen", "children": [
{"name": "/home/stephen/jq", "kanak-kanak": []}]}]}]}

Sekarang andaikan anda ingin mengekstrak semua nama fail yang ada. Anda perlu mendapatkan semula . Nama,
.anak[].nama, .anak[].anak[].nama, dan sebagainya. Anda boleh melakukan ini dengan:

recurse(.kanak-kanak[]) | .nama

Apabila dipanggil tanpa bantahan, berulang adalah bersamaan dengan berulang(.[]?).

berulang (f) sama dengan berulang(f; . != null) dan boleh digunakan tanpa kebimbangan tentang
kedalaman rekursi.

berulang(f; keadaan) ialah penjana yang bermula dengan memancarkan . dan kemudian memancarkan secara bergilir-gilir
.|f, .|f|f, .|f|f|f, ... selagi nilai yang dikira memenuhi syarat. Untuk
contoh, untuk menjana semua integer, sekurang-kurangnya pada dasarnya, seseorang boleh menulis recurse(.+1;
benar).

Atas sebab warisan, recurse_down wujud sebagai alias kepada panggilan berulang tanpa hujah.
Alias ​​ini dipertimbangkan deprecated dan akan dialih keluar dalam keluaran utama seterusnya.

Panggilan rekursif masuk berulang tidak akan menggunakan memori tambahan pada bila-bila masa f menghasilkan di
kebanyakan keluaran tunggal untuk setiap input.

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

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

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

..
Tangan pendek untuk berulang tanpa hujah. Ini bertujuan untuk menyerupai XPath //
pengendali. Perhatikan bahawa ..a tidak berfungsi; guna ..|a sebaliknya. Dalam contoh di bawah kita gunakan
..|.a? untuk mencari semua nilai kekunci objek "a" dalam mana-mana objek yang ditemui "di bawah" ..

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

env
Mengeluarkan objek yang mewakili persekitaran jq.

jq ´env.PAGER´
sifar
=> "kurang"

menukar
Transpose matriks yang mungkin bergerigi (susunan tatasusunan). Baris berlapik dengan nulls supaya
hasilnya sentiasa segi empat tepat.

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

bsearch(x)
bsearch(x) menjalankan carian binari untuk x dalam tatasusunan input. Jika input diisih dan
mengandungi x, maka bsearch(x) akan mengembalikan indeksnya dalam tatasusunan; sebaliknya, jika tatasusunan adalah
diisih, ia akan kembali (-1 - ix) di mana ix ialah titik sisipan supaya tatasusunan akan
masih boleh diisih selepas sisipan x pada ix. Jika tatasusunan tidak diisih, bsearch(x)
akan mengembalikan integer yang mungkin tidak menarik.

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

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

jq ´bsearch(4) sebagai $ix | jika $ix < 0 maka .[-(1+$ix)] = 4 lagi . tamat´
[1,2,3]
=> [1,2,3,4]

Rentetan interpolasi - \(foo)
Di dalam rentetan, anda boleh meletakkan ungkapan di dalam parens selepas garis miring ke belakang. Walau apa pun
pulangan ungkapan akan diinterpolasi ke dalam rentetan.

jq ´"Input ialah \(.), iaitu kurang satu daripada \(.+1)"´
42
=> "Input ialah 42, iaitu satu kurang daripada 43"

Tukar kepada/dari JSON
. tojson and fromjson binaan membuang nilai sebagai teks JSON atau menghuraikan teks JSON ke dalamnya
nilai, masing-masing. Tojson builtin berbeza daripada tostring dalam pengembalian tostring itu
rentetan tidak diubah suai, manakala tojson mengekod rentetan sebagai rentetan 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 tali and melarikan diri
. @foo sintaks digunakan untuk memformat dan melepaskan rentetan, yang berguna untuk membina URL,
dokumen dalam bahasa seperti HTML atau XML, dan sebagainya. @foo boleh digunakan sebagai penapis pada
sendiri, kemungkinan melarikan diri adalah:

@teks:

panggilan menjalin, lihat fungsi itu untuk butiran.

@json:

Mensiri input sebagai JSON.

@html:

Menggunakan HTML/XML escape, dengan memetakan aksara <>&´" kepada entiti mereka
setara <, >, &, ', ".

@uri:

Menggunakan pengekodan peratus, dengan memetakan semua aksara URI yang dikhaskan kepada a %XX urutan.

@csv:

Input mestilah tatasusunan dan ia dipaparkan sebagai CSV dengan petikan berganda untuk
rentetan, dan petikan terlepas dengan pengulangan.

@tsv:

Input mestilah tatasusunan dan ia dipaparkan sebagai TSV (nilai dipisahkan tab). setiap satu
tatasusunan input akan dicetak sebagai satu baris. Medan dipisahkan oleh satu tab
(ascii 0x09). Suapan baris aksara input (ascii 0x0a), pemulangan pengangkutan (ascii
0x0d), tab (ascii 0x09) dan garis miring ke belakang (ascii 0x5c) akan dikeluarkan sebagai pelarian
urutan \n, \r, \t, \\ masing-masing.

@sh:

Input dikeluarkan sesuai untuk digunakan dalam baris arahan untuk shell POSIX. Sekiranya
input ialah tatasusunan, output akan menjadi satu siri rentetan yang dipisahkan oleh ruang.

@base64:

Input ditukar kepada base64 seperti yang ditentukan oleh RFC 4648.

Sintaks ini boleh digabungkan dengan interpolasi rentetan dengan cara yang berguna. Anda boleh mengikuti a
@foo token dengan rentetan literal. Kandungan rentetan literal akan tidak terlepas.
Walau bagaimanapun, semua interpolasi yang dibuat di dalam rentetan literal itu akan dilepaskan. Sebagai contoh,

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

akan menghasilkan output berikut untuk input {"search":"apa is jq?"}:

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

Ambil perhatian bahawa garis miring, tanda soal, dsb. dalam URL tidak terlepas, kerana ia adalah sebahagian
daripada rentetan literal.

jq ´@html´
"Ini berfungsi jika x < y"
=> "Ini berfungsi jika x < y"

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

tarikh
jq menyediakan beberapa fungsi pengendalian tarikh asas, dengan beberapa tahap tinggi dan tahap rendah
binaan. Dalam semua kes binaan ini berurusan secara eksklusif dengan masa dalam UTC.

. fromdateiso8601 terbina dalam menghuraikan masa tarikh dalam format ISO 8601 kepada beberapa saat
sejak zaman Unix (1970-01-01T00:00:00Z). The todateiso8601 builtin melakukan songsang.

. dari tarikh terbina dalam menghuraikan rentetan datetime. Pada masa ini dari tarikh hanya menyokong ISO 8601
rentetan datetime, tetapi pada masa hadapan ia akan cuba menghuraikan rentetan datetime dengan lebih banyak lagi
format.

. sehingga kini builtin ialah alias untuk todateiso8601.

. kini builtin mengeluarkan masa semasa, dalam beberapa saat sejak zaman Unix.

Antara muka jq peringkat rendah kepada fungsi masa C-library juga disediakan: masa rehat,
masa strft, mktime, dan gmtime. Rujuk dokumentasi sistem pengendalian hos anda untuk
rentetan format yang digunakan oleh masa rehat and masa strft. Nota: ini tidak semestinya stabil
antara muka dalam jq, terutamanya tentang fungsi penyetempatan mereka.

. gmtime builtin menggunakan beberapa saat sejak zaman Unix dan mengeluarkan "broken
down time" perwakilan masa sebagai tatasusunan nombor yang mewakili (dalam susunan ini): the
tahun, bulan (berasaskan sifar), hari dalam bulan, jam dalam hari, minit
jam, detik dalam minit, hari dalam seminggu dan hari dalam setahun -- semuanya
berasaskan satu melainkan dinyatakan sebaliknya.

. mktime builtin menggunakan "masa rosak" perwakilan masa keluaran oleh gmtime
and masa rehat.

. strptime(fmt) terbina dalam menghuraikan rentetan input yang sepadan dengan fmt hujah. Outputnya masuk
perwakilan "masa rosak" yang digunakan oleh gmtime dan keluaran oleh mktime.

. strftime(fmt) terbina dalam memformat masa dengan format yang diberikan.

Rentetan format untuk masa rehat and masa strft diterangkan dalam perpustakaan C biasa
dokumentasi. Rentetan format untuk tarikh tarikh ISO 8601 ialah "%Y-%m-%dT%H:%M:%SZ".

jq mungkin tidak menyokong sebahagian atau semua fungsi tarikh ini pada sesetengah sistem.

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

SYARAT DAN PERBANDINGAN


==, !=
Ungkapan ´a == b´ akan menghasilkan ´benar´ jika hasil a dan b adalah sama (iaitu,
jika mereka mewakili dokumen JSON yang setara) dan ´palsu' sebaliknya. Khususnya, rentetan
tidak pernah dianggap sama dengan nombor. Jika anda datang dari Javascript, jq's == adalah seperti
Javascript === - mempertimbangkan nilai sama hanya apabila mereka mempunyai jenis yang sama dan juga
nilai yang sama.

!= ialah "tidak sama", dan ´a != b´ mengembalikan nilai bertentangan ´a == b´

jq ´.[] == 1´
[1, 1.0, "1", "pisang"]
=> benar, benar, salah, salah

jika-kemudian-lain
if A kemudian B lagi C akhir akan bertindak sama seperti B if A menghasilkan nilai selain palsu atau
null, tetapi bertindak sama seperti C sebaliknya.

Menyemak palsu atau null ialah tanggapan yang lebih mudah tentang "kebenaran" daripada yang terdapat dalam Javascript
atau Python, tetapi ini bermakna anda kadangkala perlu lebih jelas tentang keadaan tersebut
anda mahu: anda tidak boleh menguji sama ada, contohnya rentetan kosong menggunakan if . Nama kemudian A lagi B akhir,
anda akan memerlukan sesuatu yang lebih seperti if (.nama | panjang) > 0 kemudian A lagi B akhir sebaliknya.

Jika keadaan A menghasilkan berbilang hasil, ia dianggap "benar" jika mana-mana daripadanya
keputusan tidak palsu atau batal. Jika ia menghasilkan keputusan sifar, ia dianggap palsu.

Lebih banyak kes boleh ditambah kepada jika menggunakan elif A kemudian B Sintaks.

jq ´jika . == 0 kemudian

"sifar" elif . == 1 kemudian "satu" lagi "banyak" akhir´ 2 => "banyak"

>, >=, <=, <
Pengendali perbandingan >, >=, <=, < kembali sama ada hujah kiri mereka lebih besar daripada,
lebih besar daripada atau sama dengan, kurang daripada atau sama dengan atau kurang daripada hujah yang betul mereka
(masing-masing).

Pesanan adalah sama seperti yang diterangkan untuk jenis, di atas.

jq ´. < 5´
2
=> benar

dan/atau/tidak
jq menyokong pengendali Boolean biasa dan/atau/tidak. Mereka mempunyai standard kebenaran yang sama
seolah-olah ungkapan - false dan null dianggap "nilai palsu", dan apa-apa lagi ialah a
"nilai sebenar".

Jika operan salah satu operator ini menghasilkan berbilang hasil, operator itu sendiri
akan menghasilkan hasil bagi setiap input.

tidak sebenarnya adalah fungsi terbina dan bukannya pengendali, jadi ia dipanggil sebagai penapis untuk
perkara yang boleh disalurkan dan bukannya dengan sintaks khas, seperti dalam .foo and .Kafe | tidak.

Ketiga-tiga ini hanya menghasilkan nilai "benar" dan "salah", dan begitu juga hanya berguna untuk tulen
Operasi Boolean, bukannya simpulan bahasa Perl/Python/Ruby biasa
"value_that_may_be_null or default". Jika anda ingin menggunakan bentuk "atau" ini, pilih antara
dua nilai daripada menilai keadaan, lihat operator "//" di bawah.

jq ´42 dan "tali"´
sifar
=> benar

jq ´(benar, salah) atau palsu´
sifar
=> benar, salah

jq ´(benar, benar) dan (benar, salah)´
sifar
=> benar, salah, benar, salah

jq ´[benar, salah | bukan]´
sifar
=> [salah, benar]

Alternatif operator - //
Penapis borang a // b menghasilkan keputusan yang sama seperti a, Jika a menghasilkan hasil yang lain
daripada palsu and sifar. Jika tidak, a // b menghasilkan keputusan yang sama seperti b.

Ini berguna untuk menyediakan lalai: .foo // 1 akan menilai ke 1 jika tiada .foo
elemen dalam input. Ia serupa dengan bagaimana or kadangkala digunakan dalam Python (jq´s or operator
dikhaskan untuk operasi Boolean yang ketat).

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

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

cuba tangkap
Ralat boleh ditangkap dengan menggunakan cubalah EXP menangkap EXP. Ungkapan pertama dilaksanakan, dan jika
ia gagal maka yang kedua dilaksanakan dengan mesej ralat. Keluaran pengendali, jika
mana-mana, adalah output seolah-olah ia adalah output ungkapan untuk dicuba.

. cubalah EXP kegunaan borang kosong sebagai pengendali pengecualian.

jq ´try .a catch ". is not an object"´
benar
=> ". bukan objek"

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

jq ´try error("some exception") tangkap .´
benar
=> "beberapa pengecualian"

Berbuka keluar of kawalan struktur
Penggunaan try/catch yang mudah adalah untuk memecahkan struktur kawalan seperti mengurangkan, foreach,
manakala, Dan sebagainya.

Sebagai contoh:

# Ulang ungkapan sehingga ia menimbulkan "break" sebagai
# ralat, kemudian berhenti mengulangi tanpa menaikkan semula ralat.
# Tetapi jika ralat yang ditangkap tidak "pecah" maka naikkan semula.
cuba repeat(exp) tangkap .=="break" kemudian kosongkan lagi ralat;

jq mempunyai sintaks untuk label leksikal bernama untuk "pecah" atau "pergi (kembali) ke":

label $out | ... pecah $out ...

. memecahkan $label_name ungkapan akan menyebabkan atur cara bertindak seolah-olah yang terdekat
(ke kiri) label $label_name dihasilkan kosong.

Hubungan antara memecahkan dan sepadan label adalah leksikal: label mestilah
"kelihatan" dari waktu rehat.

Untuk keluar dari a mengurangkan, Contohnya:

label $out | kurangkan .[] sebagai $item (null; jika .==false maka pecahkan $out else ... tamat)

Program jq berikut menghasilkan ralat sintaks:

pecah $out

kerana tiada label $keluar kelihatan.

? operator
. ? operator, digunakan sebagai EXP?, ialah singkatan untuk cubalah EXP.

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

TETAP EKSPRESI (PCRE)


jq menggunakan perpustakaan ekspresi biasa Oniguruma, seperti php, ruby, TextMate, Sublime Text,
dll, jadi penerangan di sini akan memfokuskan pada spesifik jq.

Penapis jq regex ditakrifkan supaya ia boleh digunakan menggunakan salah satu daripada corak ini:

STRING | PENAPIS( REGEX )
STRING | PENAPIS( REGEX; BENDERA )
STRING | PENAPIS( [REGEX] )
STRING | PENAPIS( [REGEX, BENDERA] )

di mana: * STRING, REGEX dan FLAGS ialah rentetan jq dan tertakluk kepada interpolasi rentetan jq; *
REGEX, selepas interpolasi rentetan, hendaklah menjadi regex PCRE yang sah; * PENAPIS adalah salah satu daripada ujian,
sepadan dengan, Atau menangkap, seperti yang dijelaskan di bawah.

FLAGS ialah rentetan yang terdiri daripada satu daripada lebih daripada bendera yang disokong:

· g - Carian global (cari semua perlawanan, bukan hanya yang pertama)

· i - Carian tidak sensitif huruf

· m - Mod berbilang baris (´.´ akan sepadan dengan baris baharu)

· n - Abaikan padanan kosong

· p - Kedua-dua mod s dan m didayakan

· s - Mod baris tunggal (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - Cari perlawanan terpanjang yang mungkin

· x - Format regex lanjutan (abaikan ruang putih dan ulasan)

Untuk memadankan ruang putih dalam corak x gunakan escape seperti \s, cth

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

Ambil perhatian bahawa bendera tertentu juga boleh ditentukan dalam REGEX, cth

· jq -n ´("ujian", "Ujian", "ujian", "UJIAN") | ujian( "(?i)te(?-i)st" )´

menilai kepada: benar, benar, salah, salah.

[Memerlukan 1.5] ujian(val), ujian (regex; bendera)
suka sepadan dengan, tetapi tidak mengembalikan objek padan, sahaja benar or palsu untuk sama ada atau tidak
regex sepadan dengan input.

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

jq ´.[] | test("abc # ruang diabaikan"; "ix")´
["xabcd", "ABC"]
=> benar, benar

[Memerlukan 1.5] perlawanan(val), padankan(regex; bendera)
sepadan dengan mengeluarkan objek untuk setiap padanan yang ditemuinya. Perlawanan mempunyai medan berikut:

· mengimbangi - mengimbangi dalam titik kod UTF-8 dari permulaan input

· panjang - panjang dalam titik kod UTF-8 perlawanan

· rentetan - rentetan yang dipadankan

· menangkap - susunan objek yang mewakili kumpulan menangkap.

Menangkap objek kumpulan mempunyai medan berikut:

· mengimbangi - mengimbangi dalam titik kod UTF-8 dari permulaan input

· panjang - panjang dalam titik kod UTF-8 kumpulan penangkap ini

· rentetan - rentetan yang ditangkap

· nama - nama kumpulan penangkap (atau sifar jika ia tidak dinamakan)

Menangkap kumpulan yang tidak sepadan dengan apa-apa mengembalikan offset -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", "nama": 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 ", "menangkap": []}

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, "rentetan": null, "nama": "bar123"}]}

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

[Memerlukan 1.5] tangkap(val), tangkap(regex; bendera)
Mengumpul tangkapan yang dinamakan dalam objek JSON, dengan nama setiap tangkapan sebagai kunci,
dan rentetan yang dipadankan sebagai nilai yang sepadan.

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

[Memerlukan 1.5] imbasan (regex), imbasan(regex; bendera)
Keluarkan aliran subrentetan tidak bertindih bagi input yang sepadan dengan regex masuk
mengikut bendera, jika ada yang telah ditentukan. Jika tidak ada padanan, aliran adalah
kosong. Untuk menangkap semua padanan bagi setiap rentetan input, gunakan simpulan bahasa [ expr ], contohnya [
imbasan(regex) ].

split(regex; bendera)
Untuk keserasian ke belakang, berpecah berpecah pada rentetan, bukan regex.

[Memerlukan 1.5] pecahan(regex), pecahan(regex; bendera)
Ini memberikan hasil yang sama seperti mereka berpecah rakan sejawat, tetapi sebagai aliran bukannya sebuah
susunan.

[Memerlukan 1.5] sub(regex; menjalin) sub(regex; tali; bendera)
Pancarkan rentetan yang diperoleh dengan menggantikan padanan pertama regex dalam rentetan input dengan
menjalin, selepas interpolasi. menjalin mestilah rentetan jq, dan mungkin mengandungi rujukan
kepada tangkapan dinamakan. Tangkapan yang dinamakan, sebenarnya, dibentangkan sebagai objek JSON (as
dibina oleh menangkap) Untuk menjalin, jadi rujukan kepada pembolehubah yang ditangkap bernama "x" akan
ambil bentuk: "(.x)".

[Memerlukan 1.5] gsub(regex; tali), gsub(regex; tali; bendera)
gsub adalah seperti sub tetapi semua kejadian tidak bertindih regex digantikan oleh
rentetan, selepas interpolasi.

ADVANCED CIRI-CIRI


Pembolehubah adalah keperluan mutlak dalam kebanyakan bahasa pengaturcaraan, tetapi ia diturunkan
kepada "ciri lanjutan" dalam jq.

Dalam kebanyakan bahasa, pembolehubah adalah satu-satunya cara untuk menghantar data. Jika anda mengira a
nilai, dan anda ingin menggunakannya lebih daripada sekali, anda perlu menyimpannya dalam pembolehubah. Kepada
menghantar nilai ke bahagian lain program, anda memerlukan bahagian program itu
tentukan pembolehubah (sebagai parameter fungsi, ahli objek, atau apa sahaja) untuk diletakkan
data itu.

Ia juga mungkin untuk menentukan fungsi dalam jq, walaupun ini adalah ciri yang terbesar
penggunaan adalah mentakrifkan perpustakaan standard jq (banyak fungsi jq seperti peta and mencari sebenarnya
ditulis dalam jq).

jq mempunyai pengendali pengurangan, yang sangat berkuasa tetapi agak rumit. Sekali lagi, ini adalah
kebanyakannya digunakan secara dalaman, untuk menentukan beberapa bit berguna perpustakaan standard jq.

Ia mungkin tidak jelas pada mulanya, tetapi jq adalah mengenai penjana (ya, seperti yang sering dijumpai dalam
Bahasa lain). Beberapa utiliti disediakan untuk membantu menangani penjana.

Beberapa sokongan I/O minimum (selain membaca JSON daripada input standard, dan menulis JSON ke
output standard) tersedia.

Akhirnya, terdapat sistem modul/perpustakaan.

Pembolehubah
Dalam jq, semua penapis mempunyai input dan output, jadi paip manual tidak perlu
menghantar nilai dari satu bahagian program ke bahagian seterusnya. Banyak ungkapan, misalnya a + b,
lulus input mereka kepada dua subungkapan yang berbeza (di sini a and b kedua-duanya lulus sama
input), jadi pembolehubah biasanya tidak diperlukan untuk menggunakan nilai dua kali.

Sebagai contoh, mengira nilai purata tatasusunan nombor memerlukan beberapa
pembolehubah dalam kebanyakan bahasa - sekurang-kurangnya satu untuk memegang tatasusunan, mungkin satu untuk setiap elemen
atau untuk pembilang gelung. Dalam jq, ia mudah menambah / panjang - yang menambah ungkapan diberi
tatasusunan dan menghasilkan jumlahnya, dan panjang ungkapan diberikan tatasusunan dan menghasilkannya
panjang.

Jadi, secara amnya terdapat cara yang lebih bersih untuk menyelesaikan kebanyakan masalah dalam jq daripada menentukan pembolehubah.
Namun, kadangkala mereka membuat perkara lebih mudah, jadi jq membolehkan anda menentukan pembolehubah menggunakan
ungkapan as $ pemboleh ubah. Semua nama pembolehubah bermula dengan $. Ini versi yang sedikit hodoh
daripada contoh purata tatasusunan:

panjang sebagai $array_length | tambah / $array_length

Kami memerlukan masalah yang lebih rumit untuk mencari situasi di mana menggunakan pembolehubah sebenarnya
memudahkan hidup kita.

Katakan kita mempunyai pelbagai catatan blog, dengan medan "pengarang" dan "tajuk", dan satu lagi
objek yang digunakan untuk memetakan nama pengguna pengarang kepada nama sebenar. Input kami kelihatan seperti:

{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "Artikel yang ditulis dengan baik", "author": "person1"}],
"realnames": {"anon": "Pengecut Tanpa Nama",
"person1": "Person McPherson"}}

Kami ingin menghasilkan siaran dengan medan pengarang yang mengandungi nama sebenar, seperti dalam:

{"title": "Frist psot", "author": "Anonymous Coward"}
{"title": "Artikel yang ditulis dengan baik", "pengarang": "Person McPherson"}

Kami menggunakan pembolehubah, $names, untuk menyimpan objek nama sebenar, supaya kami boleh merujuknya kemudian
apabila mencari nama pengguna pengarang:

.nama sebenar sebagai $names | .posts[] | {tajuk, pengarang: $names[.author]}

Ekspresi exp as $x | ... bermakna: untuk setiap nilai ungkapan exp, jalankan selebihnya
saluran paip dengan keseluruhan input asal, dan dengan $x ditetapkan kepada nilai tersebut. Justeru as
berfungsi sebagai sesuatu gelung foreach.

Sama seperti {foo} adalah cara penulisan yang berguna {foo: .foo}, Jadi {$foo} adalah cara penulisan yang berguna
{foo:$foo}.

Pelbagai pembolehubah boleh diisytiharkan menggunakan satu as ekspresi dengan menyediakan corak
yang sepadan dengan struktur input (ini dikenali sebagai "memusnahkan"):

. sebagai {nama sebenar: $names, posts: [$first, $second]} | ...

Pengisytiharan pembolehubah dalam corak tatasusunan (cth, . as [$first, $second]) mengikat kepada
elemen tatasusunan dalam daripada elemen pada indeks sifar ke atas, mengikut tertib. Apabila tiada
nilai pada indeks untuk elemen corak tatasusunan, sifar terikat kepada pembolehubah itu.

Pembolehubah diskop ke atas seluruh ungkapan yang mentakrifkannya, jadi

.nama sebenar sebagai $names | (.posts[] | {title, author: $names[.author]})

akan berfungsi, tetapi

(.nama sebenar sebagai $names | .posts[]) | {tajuk, pengarang: $names[.author]}

tidak akan.

Bagi ahli teori bahasa pengaturcaraan, lebih tepat untuk mengatakan bahawa pembolehubah jq adalah
pengikatan berskop leksikal. Khususnya tiada cara untuk menukar nilai pengikatan;
seseorang hanya boleh menyediakan pengikatan baharu dengan nama yang sama, tetapi yang tidak akan kelihatan di mana
yang lama adalah.

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

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

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

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

Menetapkan Fungsi
Anda boleh memberi nama penapis menggunakan sintaks "def":

kenaikan def: . + 1;

Sejak itu, kenaikan boleh digunakan sebagai penapis sama seperti fungsi terbina (sebenarnya, ini
ialah bagaimana sesetengah binaan ditakrifkan). Fungsi boleh mengambil hujah:

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

Hujah diluluskan sebagai penapis, bukan sebagai nilai. Hujah yang sama boleh dirujuk
beberapa kali dengan input yang berbeza (di sini f dijalankan untuk setiap elemen tatasusunan input).
Argumen kepada fungsi berfungsi lebih seperti panggilan balik daripada seperti argumen nilai. Ini adalah
penting untuk difahami. Pertimbangkan:

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

Hasilnya akan menjadi 20 kerana f is .*2, dan semasa seruan pertama f . akan menjadi 5,
dan kali kedua ia akan menjadi 10 (5 * 2), jadi hasilnya akan menjadi 20. Hujah fungsi
ialah penapis dan penapis mengharapkan input apabila dipanggil.

Jika anda mahukan tingkah laku argumen nilai untuk mentakrifkan fungsi mudah, anda hanya boleh menggunakan a
pemboleh ubah:

def nilai tambah(f): f sebagai $f | peta(. + $f);

Atau gunakan tangan pendek:

def nilai tambah($f): ...;

Dengan mana-mana definisi, addvalue(.foo) akan menambah input semasa .foo bidang kepada masing-masing
elemen tatasusunan.

Berbilang takrifan menggunakan nama fungsi yang sama dibenarkan. Setiap definisi semula menggantikan
yang sebelumnya untuk bilangan argumen fungsi yang sama, tetapi hanya untuk rujukan daripada
fungsi (atau program utama) selepas definisi semula.

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

jq ´def nilai tambah(f): f sebagai $x | peta(. + $x); nilai tambah(.[0])´
[[1,2],[10,20]]
=> [[1,2,1,2], [10,20,1,2]]

Kurangkan
. mengurangkan sintaks dalam jq membolehkan anda menggabungkan semua hasil ungkapan oleh
mengumpulkannya menjadi satu jawapan. Sebagai contoh, kita akan lulus [3,2,1] untuk ini
ungkapan:

kurangkan .[] sebagai $item (0; . + $item)

Bagi setiap keputusan itu .[] menghasilkan, . + $item dijalankan untuk mengumpul jumlah berjalan,
bermula dari 0. Dalam contoh ini, .[] menghasilkan keputusan 3, 2, dan 1, jadi kesannya adalah
serupa dengan menjalankan sesuatu seperti ini:

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

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

had(n; exp)
. menghadkan ekstrak fungsi sehingga n keluaran daripada exp.

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

pertama (expr), terakhir(expr), nth(n; expr)
. pertama (expr) and terakhir(expr) fungsi mengekstrak nilai pertama dan terakhir daripada expr,
masing-masing.

. nth(n; expr) fungsi mengekstrak keluaran nilai ke-n oleh expr. Ini boleh ditakrifkan sebagai
def nth(n; expr): terakhir(had(n + 1; expr));. Perhatikan bahawa nth(n; expr) tidak menyokong
nilai negatif daripada n.

jq ´[pertama(julat(.)), terakhir(julat(.)), nth(./2; julat(.))]´
10
=> [0,9,5]

Pertama, terakhir, n(n)
. pertama and lepas fungsi mengekstrak nilai pertama dan terakhir daripada mana-mana tatasusunan di ..

. n(n) fungsi mengekstrak nilai ke-n mana-mana tatasusunan di ..

jq ´[julat(.)]|[pertama, terakhir, ke-(5)]´
10
=> [0,9,5]

foreach
. foreach sintaks adalah serupa dengan mengurangkan, tetapi bertujuan untuk membenarkan pembinaan menghadkan
dan pengurang yang menghasilkan keputusan pertengahan (lihat contoh).

Borangnya ialah foreach EXP as $var (DI DALAMNYA; KEMASKINI; EKSTRAK). Seperti mengurangkan, INIT dinilai
sekali untuk menghasilkan nilai keadaan, maka setiap keluaran daripada EXP terikat dengan $var, UPDATE is
dinilai bagi setiap keluaran bagi EXP dengan keadaan semasa dan dengan $var nampak. Setiap nilai
keluaran oleh UPDATE menggantikan keadaan sebelumnya. Akhirnya, EXTRACT dinilai untuk setiap yang baru
negeri untuk mengekstrak keluaran daripada foreach.

Ini kebanyakannya berguna hanya untuk membina mengurangkan- dan menghadkan-fungsi seperti. Tetapi ia adalah
lebih umum, kerana ia membenarkan pengurangan separa (lihat contoh di bawah).

jq ´[foreach .[] sebagai $item ([[],[]]; jika $item == null maka [[],.[0]] else [(.[0] + [$item]),[ ]] tamat; jika $item == null maka .[1] lain hujung kosong)]´
[1,2,3,4,null,"a","b",null]
=> [[1,2,3,4],["a","b"]]

Rekursi
Seperti yang dijelaskan di atas, berulang menggunakan rekursi, dan mana-mana fungsi jq boleh menjadi rekursif. The
manakala builtin juga dilaksanakan dari segi rekursi.

Panggilan ekor dioptimumkan apabila ungkapan di sebelah kiri output panggilan rekursif
nilai terakhirnya. Dalam amalan ini bermakna bahawa ungkapan di sebelah kiri rekursif
panggilan tidak boleh menghasilkan lebih daripada satu output untuk setiap input.

Sebagai contoh:

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

def while(cond; kemas kini):
def _while:
jika cond maka ., (kemas kini | _sementara) lain kosong hujung;
_sementara;

def ulang(exp):
def _repeat:
exp, _ulang;
_ulang;

penjana and iterator
Sesetengah pengendali dan fungsi jq sebenarnya adalah penjana kerana ia boleh menghasilkan sifar,
satu, atau lebih nilai untuk setiap input, seperti yang dijangkakan dalam pengaturcaraan lain
bahasa yang mempunyai penjana. Sebagai contoh, .[] menjana semua nilai dalam inputnya
(yang mestilah tatasusunan atau objek), julat(0; 10) menjana integer antara 0 dan
10, dan seterusnya.

Malah pengendali koma ialah penjana, menjana terlebih dahulu nilai yang dijana oleh
ungkapan di sebelah kiri koma, kemudian bagi setiap satu daripada itu, nilai yang dijana oleh
ungkapan di sebelah kanan koma.

. kosong builtin ialah penjana yang menghasilkan keluaran sifar. The kosong dibina
berundur ke ungkapan penjana sebelumnya.

Semua fungsi jq boleh menjadi penjana hanya dengan menggunakan penjana terbina. Ia juga boleh
untuk menentukan penjana baharu hanya menggunakan rekursi dan pengendali koma. Jika rekursif
panggilan (s) adalah (adalah) "dalam kedudukan ekor" maka penjana akan menjadi cekap. Dalam contoh
di bawah panggilan rekursif oleh _julat kepada dirinya sendiri berada dalam kedudukan ekor. Contoh menunjukkan
tiga topik lanjutan: rekursi ekor, pembinaan penjana dan sub-fungsi.

jq ´def range(init; upto; by): def _range: if (by > 0 and . < upto) atau (by < 0 and . > upto) then ., ((.+by)|_range) else . akhir; jika dengan == 0 maka init else init|_julat tamat | pilih((oleh > 0 dan . < hingga) atau (oleh < 0 dan . > sehingga)); julat(0; 10; 3)´
sifar
=> 0, 3, 6, 9

jq ´def while(cond; update): def _while: if cond then ., (kemas kini | _while) else kosong hujung; _sementara; [semasa(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

MATH


jq pada masa ini hanya mempunyai sokongan nombor titik terapung berketepatan ganda IEEE754 (64-bit).

Selain operator aritmetik mudah seperti +, jq juga mempunyai kebanyakan fungsi matematik standard
daripada perpustakaan matematik C. Fungsi matematik C yang mengambil argumen input tunggal (cth, dosa())
tersedia sebagai fungsi jq hujah sifar. C fungsi matematik yang mengambil dua input
hujah (cth, pow()) tersedia sebagai fungsi jq dua argumen yang mengabaikan ..

Ketersediaan fungsi matematik standard bergantung pada ketersediaan fungsi yang sepadan
fungsi matematik dalam sistem pengendalian anda dan perpustakaan matematik C. Fungsi matematik tidak tersedia
akan ditakrifkan tetapi akan menimbulkan ralat.

I / O


Pada masa ini jq mempunyai sokongan minimum untuk I/O, kebanyakannya dalam bentuk kawalan ke atas bila
input dibaca. Dua fungsi terbina disediakan untuk ini, input and input, yang dibaca
daripada sumber yang sama (cth, stdin, fail dinamakan pada baris arahan) sebagai jq sendiri. Ini
dua binaan, dan tindakan membaca jq sendiri, boleh dijalin antara satu sama lain.

Satu binaan menyediakan keupayaan keluaran yang minimum, debug. (Ingat bahawa program jq
nilai output sentiasa dikeluarkan semasa teks JSON dihidupkan stdout.) Yang debug builtin boleh mempunyai
tingkah laku khusus aplikasi, seperti untuk boleh laku yang menggunakan API libjq C tetapi tidak
jq boleh laku itu sendiri.

input
Mengeluarkan satu input baharu.

input
Mengeluarkan semua baki input, satu demi satu.

Ini amat berguna untuk pengurangan ke atas input program.

debug
Menyebabkan mesej nyahpepijat berdasarkan nilai input yang akan dihasilkan. Pembalut boleh laku jq
nilai input dengan ["DEBUG:", ] dan mencetak itu dan baris baharu pada stderr,
padat. Ini mungkin berubah pada masa hadapan.

input_nama fail
Mengembalikan nama fail yang inputnya sedang ditapis. Perhatikan bahawa ini akan
tidak berfungsi dengan baik melainkan jq berjalan di tempat UTF-8.

masukan_nombor_baris
Mengembalikan nombor baris input yang sedang ditapis.

MENJALANKAN


Dengan --strim pilihan jq boleh menghuraikan teks input dalam fesyen penstriman, membenarkan jq
atur cara untuk mula memproses teks JSON yang besar serta-merta dan bukannya selepas penghuraian
selesai. Jika anda mempunyai satu teks JSON yang bersaiz 1GB, penstriman itu akan membolehkan anda
untuk memprosesnya dengan lebih cepat.

Walau bagaimanapun, penstriman tidak mudah untuk ditangani kerana program jq akan mempunyai [ ,
] (dan beberapa bentuk lain) sebagai input.

Beberapa binaan disediakan untuk memudahkan pengendalian aliran.

Contoh di bawah menggunakan bentuk yang distrim [0,[1]], Yang merupakan
[[0],0],[[1,0],1],[[1,0]],[[1]].

Borang penstriman termasuk [ , ] (untuk menunjukkan sebarang nilai skalar, tatasusunan kosong,
atau objek kosong), dan [ ] (untuk menunjukkan penghujung tatasusunan atau objek). masa depan
versi jq run with --strim and -seq boleh mengeluarkan borang tambahan seperti ["kesilapan
mesej"] apabila teks input gagal dihuraikan.

truncate_stream(stream_expression)
Menggunakan nombor sebagai input dan memotong bilangan elemen laluan yang sepadan daripada
sebelah kiri output ungkapan penstriman yang diberikan.

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

fromstream(stream_expression)
Nilai output yang sepadan dengan output ekspresi aliran.

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

tostream
. tostream builtin mengeluarkan bentuk aliran inputnya.

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

PENYERAHAN


Tugasan berfungsi sedikit berbeza dalam jq berbanding dalam kebanyakan bahasa pengaturcaraan. jq tidak
membezakan antara rujukan dan salinan sesuatu - dua objek atau tatasusunan adalah
sama ada sama atau tidak sama, tanpa sebarang tanggapan lanjut sebagai "objek yang sama" atau "bukan
objek yang sama".

Jika objek mempunyai dua medan iaitu tatasusunan, .foo and .Kafe, dan anda tambahkan sesuatu pada
.foo, Maka .Kafe tidak akan menjadi lebih besar. Walaupun anda baru menetapkan .Kafe = .foo. Jika anda digunakan
kepada pengaturcaraan dalam bahasa seperti Python, Java, Ruby, Javascript, dll. maka anda boleh berfikir
daripadanya seolah-olah jq melakukan salinan dalam penuh bagi setiap objek sebelum ia melakukan tugasan
(untuk prestasi, ia sebenarnya tidak melakukan itu, tetapi itulah idea umum).

Semua pengendali tugasan dalam jq mempunyai ungkapan laluan di sebelah kiri.

=
Penapis .foo = 1 akan mengambil sebagai input objek dan menghasilkan sebagai output objek dengan
medan "foo" ditetapkan kepada 1. Tiada tanggapan "mengubah suai" atau "mengubah" sesuatu dalam jq -
semua nilai jq tidak boleh diubah. Sebagai contoh,

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

tidak akan mempunyai kesan sampingan penetapan .bar.baz untuk ditetapkan kepada 1, kerana ia kelihatan serupa
program dalam Javascript, Python, Ruby atau bahasa lain akan. Tidak seperti bahasa ini (tetapi
seperti Haskell dan beberapa bahasa berfungsi lain), tidak ada tanggapan tentang dua tatasusunan atau
objek menjadi "tatasusunan yang sama" atau "objek yang sama". Mereka boleh sama, atau tidak sama, tetapi
jika kita menukar salah satu daripada mereka dalam keadaan tidak akan yang lain akan berubah di belakang kita.

Ini bermakna bahawa adalah mustahil untuk membina nilai bulat dalam jq (seperti tatasusunan yang
elemen pertama adalah dirinya sendiri). Ini agak disengajakan, dan memastikan bahawa apa-apa yang jq
program boleh menghasilkan boleh diwakili dalam JSON.

Ambil perhatian bahawa bahagian kiri ´=´ merujuk kepada nilai dalam .. Oleh itu $var.foo = 1 tidak akan berfungsi
seperti yang diharapkan ($var.foo bukan ungkapan laluan yang sah atau berguna dalam .); guna $var | .foo = 1
sebaliknya.

Jika sebelah kanan ´=´ menghasilkan berbilang nilai, maka bagi setiap nilai tersebut jq akan
tetapkan laluan di sebelah kiri kepada nilai dan kemudian ia akan mengeluarkan yang diubah suai ..
Sebagai contoh, (.a,.b)=pelbagai(2) output {"a":0,"b":0}, Maka {"a":1,"b":1}. "kemas kini"
borang tugasan (lihat di bawah) jangan lakukan ini.

Perhatikan juga bahawa .a,.b=0 tidak ditetapkan .a and .b, Tetapi (.a,.b)=0 menetapkan kedua-duanya.

|=
Serta pengendali tugasan ´=´, jq menyediakan pengendali "kemas kini" ´|=´, yang
mengambil penapis di sebelah kanan dan menghasilkan nilai baharu untuk sifat .
ditugaskan dengan menjalankan nilai lama melalui ungkapan ini. Contohnya, .foo |=
.+1 akan membina objek dengan medan "foo" yang ditetapkan kepada "foo" input tambah 1.

Contoh ini harus menunjukkan perbezaan antara ´=´ dan ´|=´:

Berikan input ´{"a": {"b": 10}, "b": 20}´ kepada program:

.a = .b .a |= .b

Yang pertama akan menetapkan medan "a" input kepada medan "b" input, dan menghasilkan
keluaran {"a": 20}. Yang terakhir akan menetapkan medan "a" input kepada medan "a".
medan "b", menghasilkan {"a": 10}.

Sebelah kiri boleh menjadi sebarang ungkapan laluan umum; lihat laluan().

Ambil perhatian bahawa bahagian kiri ´|=´ merujuk kepada nilai dalam .. Oleh itu $var.foo |= . + 1 tidak akan
bekerja seperti yang diharapkan ($var.foo bukan ungkapan laluan yang sah atau berguna dalam .); guna $var | .foo
|= . + 1 sebaliknya.

Jika sebelah kanan mengeluarkan berbilang nilai, hanya yang terakhir akan digunakan.

jq ´(..|select(type=="boolean")) |= if . kemudian 1 lagi 0 tamat´
[benar,salah,[5,benar,[benar,[salah]],salah]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, /=, %=, // =
jq mempunyai beberapa pengendali borang a op= b, yang semuanya bersamaan dengan a |= . op b. Jadi,
+= 1 boleh digunakan untuk menambah nilai.

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

Kompleks tugasan
Banyak lagi perkara dibenarkan di sebelah kiri tugasan jq berbanding kebanyakannya
bahasa. Kami telah melihat akses medan mudah di sebelah kiri, dan tidak
mengejutkan bahawa akses array berfungsi dengan baik:

.posts[0].title = "Manual JQ"

Apa yang mengejutkan ialah ungkapan di sebelah kiri mungkin menghasilkan berbilang
keputusan, merujuk kepada titik berbeza dalam dokumen input:

.posts[].komen |= . + ["ini bagus"]

Contoh itu menambahkan rentetan "ini bagus" pada tatasusunan "komen" setiap siaran masuk
input (di mana input adalah objek dengan medan "siaran" yang merupakan tatasusunan jawatan).

Apabila jq menemui tugasan seperti ´a = b´, ia merekodkan "laluan" yang diambil untuk memilih a
sebahagian daripada dokumen input semasa melaksanakan a. Laluan ini kemudiannya digunakan untuk mencari bahagian mana
input untuk diubah semasa melaksanakan tugasan. Mana-mana penapis boleh digunakan pada
sebelah kiri sama dengan - mana-mana laluan yang dipilih daripada input akan berada di mana
tugasan dilaksanakan.

Ini adalah operasi yang sangat berkuasa. Katakan kami ingin menambah ulasan pada catatan blog, menggunakan
input "blog" yang sama di atas. Kali ini, kami hanya ingin mengulas pada catatan yang ditulis oleh
"stedolan". Kami boleh mencari siaran tersebut menggunakan fungsi "pilih" yang diterangkan sebelum ini:

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

Laluan yang disediakan oleh operasi ini menghala ke setiap siaran yang "stedolan" tulis, dan
kita boleh mengulas setiap daripada mereka dengan cara yang sama seperti yang kita lakukan sebelum ini:

(.siaran[] | pilih(.pengarang == "stedolan") | .komen) |=
. + ["mengerikan."]

MODUL


jq mempunyai sistem perpustakaan/modul. Modul ialah fail yang namanya berakhir .jq.

Modul yang diimport oleh program dicari dalam laluan carian lalai (lihat di bawah). The
mengimport and termasuk arahan membenarkan pengimport mengubah laluan ini.

Laluan dalam laluan carian tertakluk kepada pelbagai penggantian.

Untuk laluan bermula dengan "~/", direktori rumah pengguna digantikan dengan "~".

Untuk laluan bermula dengan "$ORIGIN/", laluan jq boleh laku digantikan
"$ORIGIN".

Untuk laluan yang bermula dengan "./" atau laluan yang ".", laluan fail termasuk ialah
digantikan dengan ".". Untuk program peringkat atas yang diberikan pada baris arahan, arus
direktori digunakan.

Arahan import boleh secara pilihan menentukan laluan carian yang lalainya dilampirkan.

Laluan carian lalai ialah laluan carian yang diberikan kepada -L pilihan baris arahan, jika tidak
["~/.jq", "$ORIGIN/../lib/jq", "$ORIGIN/../ lib"].

Elemen laluan rentetan kosong dan kosong menamatkan pemprosesan laluan carian.

Kebergantungan dengan laluan relatif "foo/bar" akan dicari dalam "foo/bar.jq" dan
"foo/bar/bar.jq" dalam laluan carian yang diberikan. Ini bertujuan untuk membolehkan modul diletakkan
dalam direktori bersama-sama dengan, sebagai contoh, fail kawalan versi, fail README dan sebagainya,
tetapi juga untuk membenarkan modul fail tunggal.

Komponen berturut-turut dengan nama yang sama tidak dibenarkan untuk mengelakkan kekaburan (cth,
"foo/foo").

Sebagai contoh, dengan -L$HOME/.jq sebuah modul foo boleh didapati di $HOME/.jq/foo.jq and
$HOME/.jq/foo/foo.jq.

Jika "$HOME/.jq" ialah fail, ia disumberkan ke dalam program utama.

mengimport RelativePathString as NAMA [ ];
Mengimport modul yang ditemui pada laluan yang diberikan berbanding dengan direktori dalam laluan carian. A ".jq"
akhiran akan ditambahkan pada rentetan laluan relatif. Simbol modul diawali dengan
"NAMA::".

Metadata pilihan mestilah ungkapan jq tetap. Ia sepatutnya objek dengan kunci
seperti "laman utama" dan sebagainya. Pada masa ini jq hanya menggunakan kunci/nilai "carian" bagi
metadata. Metadata juga disediakan kepada pengguna melalui modulemeta terbina dalam.

Kunci "carian" dalam metadata, jika ada, harus mempunyai rentetan atau nilai tatasusunan (array
daripada rentetan); ini ialah laluan carian yang akan diberi awalan ke laluan carian peringkat atas.

termasuk RelativePathString [ ];
Mengimport modul yang ditemui pada laluan yang diberikan berbanding dengan direktori dalam laluan carian seolah-olah ia
telah dimasukkan di tempat. Akhiran ".jq" akan ditambahkan pada rentetan laluan relatif. The
simbol modul diimport ke ruang nama pemanggil seolah-olah kandungan modul ada
dimasukkan secara langsung.

Metadata pilihan mestilah ungkapan jq tetap. Ia sepatutnya objek dengan kunci
seperti "laman utama" dan sebagainya. Pada masa ini jq hanya menggunakan kunci/nilai "carian" bagi
metadata. Metadata juga disediakan kepada pengguna melalui modulemeta terbina dalam.

mengimport RelativePathString as $NAME [ ];
Mengimport fail JSON yang ditemui pada laluan yang diberikan berbanding dengan direktori dalam laluan carian. A
Akhiran ".json" akan ditambahkan pada rentetan laluan relatif. Data fail akan menjadi
tersedia sebagai $NAME::NAME.

Metadata pilihan mestilah ungkapan jq tetap. Ia sepatutnya objek dengan kunci
seperti "laman utama" dan sebagainya. Pada masa ini jq hanya menggunakan kunci/nilai "carian" bagi
metadata. Metadata juga disediakan kepada pengguna melalui modulemeta terbina dalam.

Kunci "carian" dalam metadata, jika ada, harus mempunyai rentetan atau nilai tatasusunan (array
daripada rentetan); ini ialah laluan carian yang akan diberi awalan ke laluan carian peringkat atas.

modul ;
Arahan ini adalah pilihan sepenuhnya. Ia tidak diperlukan untuk operasi yang betul. Ia berfungsi
hanya tujuan menyediakan metadata yang boleh dibaca dengan modulemeta terbina dalam.

Metadata mestilah ungkapan jq malar. Ia sepatutnya objek dengan kunci seperti
"laman utama". Pada masa ini jq tidak menggunakan metadata ini, tetapi ia disediakan kepada pengguna
melalui modulemeta terbina dalam.

modulemeta
Mengambil nama modul sebagai input dan mengeluarkan metadata modul sebagai objek, dengan
import modul (termasuk metadata) sebagai nilai tatasusunan untuk kunci "deps".

Program boleh menggunakan ini untuk menanyakan metadata modul, yang kemudiannya boleh digunakan untuk, untuk
contoh, cari, muat turun dan pasang kebergantungan yang hilang.

Gunakan jq dalam talian menggunakan perkhidmatan onworks.net


Pelayan & Stesen Kerja Percuma

Muat turun apl Windows & Linux

Arahan Linux

Ad