jq - Online di Awan

PROGRAM:

NAMA

jq - Prosesor JSON baris perintah

RINGKASAN

jq [Pilihan...] menyaring [arsip...]

jq dapat mengubah JSON dengan berbagai cara, dengan memilih, mengulangi, mengurangi, dan lainnya
mangling dokumen JSON. Misalnya, menjalankan perintah jq peta(.harga) | Menambahkan akan
ambil larik objek JSON sebagai input dan kembalikan jumlah bidang "harga" mereka.

jq dapat menerima input teks juga, tetapi secara default, jq membaca aliran entitas JSON
(termasuk angka dan literal lainnya) dari stdin. Spasi hanya diperlukan untuk memisahkan
entitas seperti 1 dan 2, dan benar dan salah. Satu atau lebih arsip dapat ditentukan, di mana
kasus jq akan membaca input dari mereka sebagai gantinya.

Grafik Pilihan dijelaskan dalam MEMINTA JQ bagian; mereka kebanyakan menyangkut input dan output
pemformatan. Itu menyaring ditulis dalam bahasa jq dan menentukan cara mengubah
memasukkan file atau dokumen.

FILTER

Program jq adalah "filter": ia mengambil input, dan menghasilkan output. Ada banyak
filter bawaan untuk mengekstrak bidang objek tertentu, atau mengonversi angka menjadi
string, atau berbagai tugas standar lainnya.

Filter dapat digabungkan dengan berbagai cara - Anda dapat menyalurkan output dari satu filter ke dalam
filter lain, atau kumpulkan output filter ke dalam array.

Beberapa filter menghasilkan beberapa hasil, misalnya ada satu yang menghasilkan semua
elemen array inputnya. Piping filter itu ke detik menjalankan filter kedua untuk
setiap elemen array. Umumnya, hal-hal yang akan dilakukan dengan loop dan iterasi
dalam bahasa lain hanya dilakukan dengan menempelkan filter bersama di jq.

Penting untuk diingat bahwa setiap filter memiliki input dan output. Bahkan literal
seperti "halo" atau 42 adalah filter - filter mengambil input tetapi selalu menghasilkan literal yang sama dengan
keluaran. Operasi yang menggabungkan dua filter, seperti penambahan, umumnya memberi masukan yang sama
untuk keduanya dan menggabungkan hasilnya. Jadi, Anda dapat menerapkan filter rata-rata sebagai menambahkan / panjangnya
- memberi makan array input keduanya ke menambahkan filter dan panjangnya menyaring dan kemudian melakukan
Divisi.

Tapi itu mendahului diri kita sendiri. :) Mari kita mulai dengan sesuatu yang lebih sederhana:

MEMINTA JQ

filter jq berjalan pada aliran data JSON. Input ke jq diuraikan sebagai urutan
nilai JSON yang dipisahkan spasi yang dilewatkan melalui filter yang disediakan satu per satu
waktu. Keluaran filter ditulis ke keluaran standar, lagi-lagi sebagai urutan dari
data JSON yang dipisahkan spasi.

Catatan: penting untuk memperhatikan aturan kutipan shell. Sebagai aturan umum, yang terbaik adalah
selalu mengutip (dengan karakter tanda kutip tunggal) program jq, karena terlalu banyak karakter dengan
arti khusus untuk jq juga merupakan karakter meta shell. Sebagai contoh, jq "foo" akan gagal pada
kebanyakan shell Unix karena itu akan sama dengan jq foo, yang umumnya akan gagal
karena foo is tidak didefinisikan. Saat menggunakan shell perintah Windows (cmd.exe) yang terbaik adalah
gunakan tanda kutip ganda di sekitar program jq Anda ketika diberikan pada baris perintah (alih-alih -f
berkas program option), tetapi kemudian tanda kutip ganda dalam program jq perlu melarikan diri dari garis miring terbalik.

Anda dapat memengaruhi cara jq membaca dan menulis input dan outputnya menggunakan beberapa baris perintah
pilihan:

· --Versi: kapan:

Keluarkan versi jq dan keluar dengan nol.

· --seq:

Gunakan aplikasi/json-seq Skema tipe MIME untuk memisahkan teks JSON dalam input jq
dan keluaran. Ini berarti karakter ASCII RS (pemisah rekaman) dicetak sebelumnya
setiap nilai pada output dan ASCII LF (line feed) dicetak setelah setiap output. Memasukkan
Teks JSON yang gagal diurai diabaikan (tetapi diperingatkan), membuang semua
input selanjutnya sampai RS berikutnya. Ini lebih juga mem-parsing output jq tanpa
--seq .

· --sungai kecil:

Parsing input dalam mode streaming, keluaran array jalur dan nilai daun
(skalar dan array 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 dengan
penyaringan dan menurunkan dan untuk setiap sintaks untuk mengurangi input besar secara bertahap.

· --mencucup/-s:

Alih-alih menjalankan filter untuk setiap objek JSON di input, baca seluruh input
streaming ke array besar dan jalankan filter sekali saja.

· --masukan mentah/-R:

Jangan mengurai input sebagai JSON. Sebagai gantinya, setiap baris teks diteruskan ke filter sebagai
rangkaian. Jika digabungkan dengan --mencucup, maka seluruh input dilewatkan ke filter sebagai
tali panjang tunggal.

· --masukan-null/-n:

Jangan membaca masukan sama sekali! Sebagai gantinya, filter dijalankan sekali menggunakan nol sebagai masukan.
Ini berguna saat menggunakan jq sebagai kalkulator sederhana atau untuk membuat data JSON dari
menggaruk.

· --keluaran kompak / -c:

Secara default, jq pretty-prints output JSON. Menggunakan opsi ini akan menghasilkan lebih banyak
keluaran ringkas dengan menempatkan setiap objek JSON pada satu baris.

· --tab:

Gunakan tab untuk setiap level indentasi alih-alih dua spasi.

· --indentasi n:

Gunakan jumlah spasi yang diberikan (tidak lebih dari 8) untuk indentasi.

· --warna-keluaran / -C dan --monokrom-keluaran / -M:

Secara default, jq mengeluarkan JSON berwarna jika menulis ke terminal. Anda bisa memaksanya untuk
menghasilkan warna bahkan jika menulis ke pipa atau file menggunakan -C, dan nonaktifkan warna dengan -M.

· --ascii-keluaran / -a:

jq biasanya mengeluarkan codepoint Unicode non-ASCII sebagai UTF-8, bahkan jika inputnya ditentukan
mereka sebagai urutan pelarian (seperti "\u03bc"). Dengan menggunakan opsi ini, Anda dapat memaksa jq untuk
menghasilkan output ASCII murni dengan setiap karakter non-ASCII diganti dengan yang setara
urutan pelarian.

· --tidak disangga

Siram output setelah setiap objek JSON dicetak (berguna jika Anda melakukan pemipaan dengan lambat
sumber data ke jq dan menyalurkan output jq di tempat lain).

· --sort-kunci / -S:

Keluarkan bidang setiap objek dengan kunci dalam urutan yang diurutkan.

· --output mentah / -r:

Dengan opsi ini, jika hasil filter berupa string maka akan langsung ditulis
ke output standar daripada diformat sebagai string JSON dengan tanda kutip. Ini bisa
berguna untuk membuat filter jq berbicara dengan sistem berbasis non-JSON.

· --bergabung-keluaran / -j:

Seperti -r tetapi jq tidak akan mencetak baris baru setelah setiap keluaran.

· -f nama file / --dari-file nama file:

Baca filter dari file alih-alih dari baris perintah, seperti opsi awk´s -f. Anda
juga dapat menggunakan #´ untuk membuat komentar.

· -Ldirektori / -L direktori:

tambahkan direktori ke daftar pencarian untuk modul. Jika opsi ini digunakan maka tidak
daftar pencarian bawaan digunakan. Lihat bagian modul di bawah ini.

· -e / --keluar-status:

Setel status keluar jq ke 0 jika nilai keluaran terakhir bukan keduanya palsu maupun nol,
1 jika nilai keluaran terakhir adalah baik palsu or nol, atau 4 jika tidak pernah ada hasil yang valid
diproduksi. Biasanya jq keluar dengan 2 jika ada masalah penggunaan atau kesalahan sistem, 3
jika ada kesalahan kompilasi program jq, atau 0 jika program jq berjalan.

· --argumen nama nilai:

Opsi ini meneruskan nilai ke program jq sebagai variabel yang telah ditentukan sebelumnya. Jika Anda menjalankan jq
dengan --argumen foo bar, kemudian $foo tersedia dalam program dan memiliki nilai "batang".
Perhatikan bahwa nilai akan diperlakukan sebagai string, jadi --argumen foo 123 akan mengikat $foo untuk "123".

· --argjson nama JSON-teks:

Opsi ini meneruskan nilai yang dikodekan JSON ke program jq sebagai variabel yang telah ditentukan sebelumnya. Jika
Anda menjalankan jq dengan --argjson foo 123, kemudian $foo tersedia dalam program dan memiliki
nilai 123.

· --slurpfile nama-variabel nama file:

Opsi ini membaca semua teks JSON dalam file bernama dan mengikat array dari
parsing nilai JSON ke variabel global yang diberikan. Jika Anda menjalankan jq dengan --argfile foo bar,
kemudian $foo tersedia dalam program dan memiliki larik yang elemennya sesuai dengan
teks dalam file bernama bar.

· --argfile nama-variabel nama file:

Jangan gunakan. Menggunakan --slurpfile sebagai gantinya.

(Pilihan ini seperti --slurpfile, tetapi ketika file hanya memiliki satu teks, maka itu adalah
digunakan, jika tidak, array teks digunakan seperti di --slurpfile.)

· --run-tes [nama file]:

Menjalankan tes dalam file yang diberikan atau input standar. Ini harus menjadi pilihan terakhir yang diberikan
dan tidak menghormati semua opsi sebelumnya. Input terdiri dari baris komentar, kosong
baris, dan baris program diikuti oleh satu baris input, sebanyak baris output
diharapkan (satu per output), dan baris kosong yang mengakhiri. Tes kegagalan kompilasi
mulai dengan baris yang hanya berisi "%%FAIL", lalu baris yang berisi program untuk
kompilasi, lalu baris yang berisi pesan kesalahan untuk dibandingkan dengan yang sebenarnya.

Berhati-hatilah bahwa opsi ini dapat berubah mundur-tidak kompatibel.

DASAR FILTER

.
Filter paling sederhana (dan paling tidak menarik) adalah .. Ini adalah filter yang mengambilnya
input dan menghasilkannya tidak berubah sebagai output.

Karena jq secara default mencetak semua keluaran, program sepele ini dapat menjadi cara yang berguna untuk
memformat output JSON dari, katakanlah, keriting.

jq .´
"Halo Dunia!"
=> "Halo, dunia!"

.foo, .foo.bar
Yang paling sederhana berguna filter adalah .foo. Ketika diberikan objek JSON (alias kamus atau hash) sebagai
input, itu menghasilkan nilai pada kunci "foo", atau nol jika tidak ada yang ada.

Jika kunci berisi karakter khusus, Anda harus mengapitnya dengan tanda kutip ganda seperti
ini: "ayo$".

Filter formulir .foo.bar adalah setara dengan .foo|.bar.

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

jq .foo´
{"notfoo": benar, "juganotfoo": salah}
=> nol

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

.foo?
Sama seperti .foo, tetapi tidak menampilkan bahkan kesalahan ketika . bukan array atau objek.

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

jq .foo?´
{"notfoo": benar, "juganotfoo": salah}
=> nol

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

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

.[ ], [2], [10:15]
Anda juga dapat mencari bidang objek menggunakan sintaks seperti .["aduh"] (.foo di atas adalah
versi singkat dari ini). Yang ini juga berfungsi untuk array, jika kuncinya adalah bilangan bulat.
Array berbasis nol (seperti javascript), jadi [2]. mengembalikan elemen ketiga dari array.

Grafik [10:15] sintaks dapat digunakan untuk mengembalikan subarray dari array atau substring dari string.
Array dikembalikan oleh [10:15] akan memiliki panjang 5, berisi elemen dari indeks 10
(inklusif) hingga indeks 15 (eksklusif). Salah satu indeks mungkin negatif (dalam hal ini dihitung
mundur dari akhir array), atau dihilangkan (dalam hal ini mengacu pada awal atau
akhir larik).

Grafik [2]. sintaks dapat digunakan untuk mengembalikan elemen pada indeks yang diberikan. Indeks negatif adalah
diperbolehkan, dengan -1 mengacu pada elemen terakhir, -2 mengacu pada elemen berikutnya ke terakhir,
dan seterusnya.

Grafik .foo sintaks hanya berfungsi untuk tombol sederhana yaitu kunci yang semuanya karakter alfanumerik.
.[ ] bekerja dengan tombol yang berisi karakter khusus seperti titik dua dan titik. Untuk
contoh .["foo::bar"] dan .["foo.bar"] bekerja sambil .foo::bar dan .foo.bar tidak akan.

Grafik ? "operator" juga dapat digunakan dengan operator irisan, seperti dalam [10:15]?, yang mengeluarkan
nilai di mana input dapat diiris.

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

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

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

.[]
Jika Anda menggunakan .[indeks] sintaks, tetapi hilangkan indeks sepenuhnya, itu akan kembali semua dari
elemen array. Berlari .[] dengan masukan [1,2,3] akan menghasilkan angka sebagai tiga
hasil yang terpisah, bukan sebagai array tunggal.

Anda juga dapat menggunakan ini pada objek, dan itu akan mengembalikan semua nilai objek.

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

jq .[]´
[]
=>

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

[]?
Seperti .[], tetapi tidak ada kesalahan yang akan dihasilkan jika . bukan array atau objek.

,
Jika dua filter dipisahkan dengan koma, maka input akan dimasukkan ke keduanya dan di sana
akan menjadi beberapa keluaran: pertama, semua keluaran yang dihasilkan oleh ekspresi kiri, dan
maka semua output yang dihasilkan oleh kanan. Misalnya, filter .foo, .batang, menghasilkan
baik bidang "foo" dan bidang "bar" sebagai output terpisah.

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

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

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

|
| operator menggabungkan dua filter dengan memasukkan output dari filter di sebelah kiri ke dalam
masukan dari yang di sebelah kanan. Ini hampir sama dengan pipa shell Unix, jika
Anda sudah terbiasa dengan itu.

Jika yang di sebelah kiri menghasilkan banyak hasil, yang di sebelah kanan akan dijalankan
masing-masing hasil tersebut. Jadi, ekspresi .[] | .foo mengambil bidang "foo" dari masing-masing
elemen larik masukan.

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

JENIS DAN NILAI

jq mendukung kumpulan tipe data yang sama dengan JSON - angka, string, boolean, array,
objek (yang dalam bahasa JSON adalah hash dengan hanya kunci string), dan "null".

Boolean, null, string dan angka ditulis dengan cara yang sama seperti pada javascript. Seperti
segala sesuatu yang lain di jq, nilai-nilai sederhana ini mengambil input dan menghasilkan output - 42 adalah
ekspresi jq valid yang mengambil input, mengabaikannya, dan mengembalikan 42 sebagai gantinya.

susunan konstruksi - []
Seperti di JSON, [] digunakan untuk membangun array, seperti pada [1,2,3]. Elemen array dapat
menjadi ekspresi jq apa pun. Semua hasil yang dihasilkan oleh semua ekspresi dikumpulkan
menjadi satu array besar. Anda dapat menggunakannya untuk membuat array dari jumlah nilai yang diketahui
(seperti dalam [.foo, .batang, .baz]) atau untuk "mengumpulkan" semua hasil filter ke dalam larik (sebagai
in [.item[].nama])

Setelah Anda memahami operator ",", Anda dapat melihat sintaks array jq dengan cara yang berbeda
cahaya: ekspresi [1,2,3] tidak menggunakan sintaks bawaan untuk larik yang dipisahkan koma,
tetapi sebaliknya menerapkan [] operator (mengumpulkan hasil) ke ekspresi 1,2,3 (yang
menghasilkan tiga hasil yang berbeda).

Jika Anda memiliki filter X yang menghasilkan empat hasil, maka ekspresi [X] akan menghasilkan
hasil tunggal, array empat elemen.

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

benda - {}
Seperti JSON, {} adalah untuk membangun objek (alias kamus atau hash), seperti pada: {"A": 42,
"B": 17/XNUMX/XNUMX}.

Jika kuncinya "masuk akal" (semua karakter alfabet), maka tanda kutip dapat ditinggalkan.
Nilainya dapat berupa ekspresi apa pun (walaupun Anda mungkin perlu membungkusnya dalam tanda kurung jika itusa
yang rumit), yang diterapkan ke input ekspresi {} (ingat, semua filter
memiliki masukan dan keluaran).

{foo: .bar}

akan menghasilkan objek JSON {"ayo": 42/XNUMX/XNUMX} jika diberikan objek JSON {"bar":42, "baz":43}.
Anda dapat menggunakan ini untuk memilih bidang tertentu dari suatu objek: jika inputnya adalah objek dengan
bidang "pengguna", "judul", "id", dan "konten" dan Anda hanya ingin "pengguna" dan "judul", Anda dapat
menulis

{pengguna: .pengguna, judul: .title}

Karena itu sangat umum, ada sintaks pintasan: {pengguna, judul}.

Jika salah satu ekspresi menghasilkan banyak hasil, beberapa kamus akan menjadi
diproduksi. Jika inputnya

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

kemudian ekspresi

{pengguna, judul: .titles[]}

akan menghasilkan dua output:

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

Menempatkan tanda kurung di sekitar kunci berarti itu akan dievaluasi sebagai ekspresi. Dengan
masukan yang sama seperti di atas,

{(.pengguna): .titles}

menghasilkan

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

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

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

DIBANGUN OPERATOR DAN FUNGSI

Beberapa operator jq (misalnya, +) melakukan hal-hal yang berbeda tergantung pada jenisnya
argumen (array, angka, dll.). Namun, jq tidak pernah melakukan konversi tipe implisit. Jika
Anda mencoba menambahkan string ke objek, Anda akan mendapatkan pesan kesalahan dan tidak ada hasil.

Tambahan - +
Operator + mengambil dua filter, menerapkan keduanya ke input yang sama, dan menambahkan
hasil bersama. Apa arti "menambahkan" tergantung pada jenis yang terlibat:

· Bilangan ditambahkan oleh aritmatika normal.

· Array ditambahkan dengan digabungkan menjadi array yang lebih besar.

· String ditambahkan dengan bergabung menjadi string yang lebih besar.

· benda ditambahkan dengan menggabungkan, yaitu memasukkan semua pasangan nilai kunci dari keduanya
objek menjadi satu objek gabungan. Jika kedua objek mengandung nilai yang sama
kunci, objek di sebelah kanan + menang. (Untuk penggabungan rekursif gunakan * operator.)

nol dapat ditambahkan ke nilai apa pun, dan mengembalikan nilai lainnya 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}´
nol
=> {"a": 42, "b": 2, "c": 3}

Pengurangan - -
Selain pengurangan aritmatika normal pada angka, - operator dapat digunakan pada array
untuk menghapus semua kemunculan elemen larik kedua dari larik pertama.

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

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

Perkalian, divisi, bentuk - *, /, dan %
Operator infiks ini berperilaku seperti yang diharapkan ketika diberikan dua angka. Pembagian dengan nol kenaikan
sebuah kesalahan. x % y menghitung x modulo y.

Mengalikan string dengan angka menghasilkan rangkaian string yang banyak
kali. "x" * 0 menghasilkan nol.

Membagi string dengan yang lain membagi yang pertama menggunakan yang kedua sebagai pemisah.

Mengalikan dua objek akan menggabungkannya secara rekursif: ini berfungsi seperti penambahan tetapi jika keduanya
objek berisi nilai untuk kunci yang sama, dan nilainya adalah objek, keduanya 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}}´
nol
=> {"k": {"a": 0, "b": 2, "c": 3}}

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

panjangnya
Fungsi bawaan panjangnya mendapatkan panjang berbagai jenis nilai:

· Panjang tali adalah jumlah titik kode Unicode yang dikandungnya (yang akan menjadi
sama dengan panjang yang dikodekan JSON dalam byte jika ASCII murni).

· Panjang susunan adalah jumlah elemen.

· Panjang obyek adalah jumlah pasangan nilai kunci.

· Panjang nol adalah nol.

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

kunci, kunci_tidak disortir
Fungsi bawaan kunci-kunci, ketika diberikan sebuah objek, mengembalikan kuncinya dalam sebuah array.

Kunci diurutkan "berdasarkan abjad", menurut urutan codepoint unicode. Ini bukan perintah
itu masuk akal dalam bahasa tertentu, tetapi Anda dapat mengandalkannya sebagai
sama untuk dua objek dengan set kunci yang sama, terlepas dari pengaturan lokal.

Ketika kunci-kunci diberikan sebuah array, ia mengembalikan indeks yang valid untuk array itu: bilangan bulat
dari 0 hingga panjang-1.

Grafik kunci_tidak disortir fungsinya seperti kunci-kunci, tetapi jika inputnya adalah objek, maka kuncinya
tidak akan diurutkan, alih-alih kuncinya secara kasar akan berada dalam urutan penyisipan.

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

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

memiliki (kunci)
Fungsi bawaan memiliki mengembalikan apakah objek input memiliki kunci yang diberikan, atau input
array memiliki elemen pada indeks yang diberikan.

memiliki($kunci) memiliki efek yang sama dengan memeriksa apakah $kunci adalah anggota dari array yang dikembalikan
by kunci-kunci, Meskipun memiliki akan lebih cepat.

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

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

in
Fungsi bawaan in mengembalikan kunci input ada di objek yang diberikan, atau indeks input
sesuai dengan elemen dalam array yang diberikan. Pada dasarnya, ini adalah versi terbalik dari
memiliki.

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

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

jalur(ekspresi_jalur)
Menampilkan representasi array dari ekspresi jalur yang diberikan dalam .. Outputnya adalah array dari
string (kunci dalam objek0 dan/atau angka (indeks array.

Ekspresi jalur adalah ekspresi jq seperti .a, Tetapi juga .[]. Ada dua jenis jalan
ekspresi: ekspresi yang bisa sama persis, dan ekspresi yang tidak bisa. Sebagai contoh, .abc adalah
ekspresi jalur pencocokan tepat, sementara .a[].b tidak.

jalur (exact_path_expression) akan menghasilkan representasi array dari ekspresi jalur
bahkan jika itu tidak ada di ., Jika . is nol atau array atau objek.

jalan (pola) akan menghasilkan representasi array dari jalur yang cocok belt hold jika
jalan ada di ..

Perhatikan bahwa ekspresi jalur tidak berbeda dari ekspresi normal. Ekspresi
path(..|select(type=="boolean")) menampilkan semua jalur ke nilai boolean di ., dan hanya
jalan-jalan itu.

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

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

del(ekspresi_jalur)
Fungsi bawaan itu menghapus kunci dan nilai yang sesuai dari suatu objek.

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

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

ke_entri, dari_entri, dengan_entries
Fungsi-fungsi ini mengonversi antara objek dan larik pasangan nilai kunci. Jika ke_entri
dilewatkan sebuah objek, maka untuk setiap k: v entri di input, array output termasuk
{"kunci": k, "nilai": v}.

dari_entri melakukan konversi yang berlawanan, dan dengan_entries(foo) adalah singkatan dari
ke_entri | peta (foo) | dari_entri, berguna untuk melakukan beberapa operasi ke semua tombol dan
nilai dari sebuah objek. dari_entri menerima kunci, Kunci, Nama, nilai dan Nilai sebagai kunci.

jq to_entries´
{"a": 1, "b": 2}
=> [{"kunci":"a", "nilai":1}, {"kunci":"b", "nilai":2}]

jq from_entries´
[{"kunci":"a", "nilai":1}, {"kunci":"b", "nilai":2}]
=> {"a": 1, "b": 2}

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

pilih(boolean_expression)
Fungsi pilih (foo) menghasilkan inputnya tidak berubah jika foo mengembalikan true untuk input itu,
dan tidak menghasilkan output sebaliknya.

Ini berguna untuk memfilter daftar: [1,2,3] | peta (pilih (. >= 2)) akan memberimu [2,3].

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

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

array, benda, dapat diubah, boolean, angka, normal, terbatas, string, nol, nilai-nilai,
skalar
Built-in ini hanya memilih input yang berupa array, objek, iterable (array atau
objek), boolean, angka, angka normal, angka hingga, string, null, non-null
nilai, dan non-iterable, masing-masing.

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

kosong
kosong tidak mengembalikan hasil. Tidak sama sekali. Bahkan tidak nol.

Ini berguna pada kesempatan. Anda akan tahu jika Anda membutuhkannya :)

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

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

kesalahan(Post)
Menghasilkan kesalahan, seperti .a diterapkan ke nilai selain null dan objek akan, tapi
dengan pesan yang diberikan sebagai nilai kesalahan.

$__lokasi__
Menghasilkan objek dengan kunci "file" dan kunci "baris", dengan nama file dan nomor baris
dimana $__lokasi__ terjadi, sebagai nilai.

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

peta (x), nilai_peta(x)
Untuk filter apa pun x, peta (x) akan menjalankan filter itu untuk setiap elemen array input, dan
menghasilkan output array baru. peta(.+1) akan menambah setiap elemen dari array
angka.

Demikian pula, nilai_peta(x) akan menjalankan filter itu untuk setiap elemen, tetapi itu akan mengembalikan
objek ketika sebuah objek dilewatkan.

peta (x) adalah setara dengan [.[] | x]. Sebenarnya, ini adalah bagaimana itu didefinisikan. Demikian pula,
nilai_peta(x) didefinisikan 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}

jalan, jalur (node_filter), jalur_daun
jalan menampilkan jalur ke semua elemen dalam inputnya (kecuali tidak menampilkan
daftar kosong, mewakili . diri).

jalur (f) menampilkan jalur ke nilai apa pun yang f adalah benar. Itu adalah, jalur (angka)
menampilkan jalur ke semua nilai numerik.

jalur_daun adalah alias dari jalur (skalar); jalur_daun is usang dan akan dihapus di
rilis besar berikutnya.

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

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

menambahkan
Filter menambahkan mengambil sebagai input array, dan menghasilkan sebagai output elemen array
ditambahkan bersama. Ini mungkin berarti dijumlahkan, digabungkan, atau digabungkan tergantung pada jenis
elemen array input - aturannya sama dengan aturan untuk + operator
(dijelaskan di atas).

Jika inputnya adalah array kosong, menambahkan Pengembalian nol.

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

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

jq tambah
[]
=> nol

setiap, apapun (kondisi), apapun (pembangkit; kondisi)
Filter Apa pun mengambil sebagai input array nilai boolean, dan menghasilkan benar sebagai keluaran jika
salah satu elemen array adalah benar.

Jika inputnya adalah array kosong, Apa pun Pengembalian palsu.

Grafik apapun (kondisi) form menerapkan kondisi yang diberikan ke elemen array input.

Grafik apapun (pembangkit; kondisi) form menerapkan kondisi yang diberikan untuk semua output dari
pembangkit yang diberikan.

jq any´
[benar salah]
=> benar

jq any´
[salah, salah]
=> salah

jq any´
[]
=> salah

semua, semua (kondisi), semua (pembangkit; kondisi)
Filter semua mengambil sebagai input array nilai boolean, dan menghasilkan benar sebagai keluaran jika
semua elemen array adalah benar.

Grafik semua (kondisi) form menerapkan kondisi yang diberikan ke elemen array input.

Grafik semua (pembangkit; kondisi) form menerapkan kondisi yang diberikan untuk semua output dari
pembangkit yang diberikan.

Jika inputnya adalah array kosong, semua Pengembalian benar.

jq all´
[benar salah]
=> salah

jq all´
[betul betul]
=> benar

jq all´
[]
=> benar

[Memerlukan 1.5] meratakan, meratakan (kedalaman)
Filter meratakan mengambil sebagai input array array bersarang, dan menghasilkan array datar di
dimana semua larik di dalam larik asli telah diganti secara rekursif dengan nilainya.
Anda dapat meneruskan argumen ke sana untuk menentukan berapa banyak tingkat bersarang yang akan diratakan.

meratakan(2) adalah seperti meratakan, tetapi hanya naik hingga dua tingkat.

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

jqmeratakan(1)'
[1, [2], [[3]]]
=> [1, 2, [3]]

jq meratakan´
[[]]
=> []

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

kisaran (hingga), rentang (dari; hingga) rentang (dari; hingga; oleh)
Grafik jarak fungsi menghasilkan rentang angka. rentang (4;10) menghasilkan 6 angka, dari 4
(inklusif) hingga 10 (eksklusif). Angka-angka diproduksi sebagai output terpisah. Menggunakan
[kisaran(4;10)] untuk mendapatkan rentang sebagai array.

Bentuk satu argumen menghasilkan angka dari 0 ke angka yang diberikan, dengan kenaikan
1.

Bentuk dua argumen menghasilkan angka dari dari untuk upto dengan kenaikan 1.

Bentuk tiga argumen menghasilkan angka dari untuk upto dengan kenaikan sebesar by.

jq rentang(2;4)´
nol
=> 2, 3

jq [rentang(2;4)]´
nol
=> [2,3]

jq [jarak(4)]'
nol
=> [0,1,2,3]

jq [rentang(0;10;3)]´
nol
=> [0,3,6,9]

jq [rentang(0;10;-1)]´
nol
=> []

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

lantai
Grafik lantai fungsi mengembalikan lantai input numeriknya.

jq lantai´
3.14159
=> 3

persegi
Grafik persegi fungsi mengembalikan akar kuadrat dari input numeriknya.

jq sqrt´
9
=> 3

nomor
Grafik nomor fungsi mem-parsing inputnya sebagai angka. Ini akan mengonversi dengan format yang benar
string ke padanan numeriknya, biarkan angka saja, dan berikan kesalahan pada yang lainnya
memasukkan.

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

mengikat
Grafik mengikat fungsi mencetak inputnya sebagai string. String dibiarkan tidak berubah, dan semua
nilai lainnya dikodekan JSON.

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

mengetik
Grafik mengetik fungsi mengembalikan jenis argumennya sebagai string, yang merupakan salah satu dari nol,
boolean, angka, string, array atau objek.

jq peta(tipe)´
[0, salah, [], {}, nol, "halo"]
=> ["angka", "boolean", "array", "objek", "null", "string"]

tak terbatas, nan, tidak terbatas, isnan, tidak terbatas, tidak normal
Beberapa operasi aritmatika dapat menghasilkan nilai tak terhingga dan "bukan angka" (NaN). NS
tak terbatas pengembalian bawaan benar jika inputnya tidak terbatas. NS isnan pengembalian bawaan benar
jika inputnya adalah NaN. NS tak terbatas builtin mengembalikan nilai tak terbatas positif. NS nan
builtin mengembalikan NaN. NS tidak normal builtin mengembalikan true jika inputnya adalah angka normal.

Perhatikan bahwa pembagian dengan nol menimbulkan kesalahan.

Saat ini sebagian besar operasi aritmatika yang beroperasi pada tak terhingga, NaN, dan sub-normal tidak
meningkatkan kesalahan.

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

jq tak terbatas, nan | Tipe
nol
=> "angka", "angka"

menyortir, sort_by(jalan_ekspresi)
Grafik jenis fungsi mengurutkan inputnya, yang harus berupa array. Nilai diurutkan dalam
urutan berikut:

· nol

· palsu

· benar

· angka

· string, dalam urutan abjad (berdasarkan nilai codepoint unicode)

· array, dalam urutan leksikal

· objek

Urutan untuk objek sedikit rumit: pertama mereka dibandingkan dengan membandingkannya
set kunci (sebagai array dalam urutan yang diurutkan), dan jika kuncinya sama maka nilainya adalah
dibandingkan kunci demi kunci.

jenis dapat digunakan untuk mengurutkan berdasarkan bidang tertentu dari suatu objek, atau dengan menerapkan filter jq.

urutkan_menurut(foo) membandingkan dua elemen dengan membandingkan hasil dari foo pada setiap elemen.

jq sort
[8,3,nol,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(ekspresi_jalur)
grup_oleh(.foo) mengambil sebagai input array, mengelompokkan elemen yang memiliki hal yang sama .foo bidang
ke dalam larik terpisah, dan menghasilkan semua larik ini sebagai elemen larik yang lebih besar,
diurutkan berdasarkan nilai .foo lapangan.

Ekspresi jq apa pun, bukan hanya akses bidang, dapat digunakan sebagai pengganti .foo. Penyortiran
pesanan sama seperti yang dijelaskan di jenis fungsi di atas.

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 maks, min_by(jalur_exp), max_by(jalur_exp)
Temukan elemen minimum atau maksimum dari array input.

Grafik min_by(jalur_exp) dan max_by(jalur_exp) fungsi memungkinkan Anda untuk menentukan tertentu
bidang atau properti untuk diperiksa, misalnya min_by(.foo) menemukan objek dengan yang terkecil foo
lapangan.

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

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

unik, unik_oleh(jalur_exp)
Grafik unik fungsi mengambil sebagai input array dan menghasilkan array dari elemen yang sama, di
diurutkan, dengan duplikat dihapus.

Grafik unik_oleh(jalur_exp) fungsi akan menyimpan hanya satu elemen untuk setiap nilai yang diperoleh oleh
menerapkan argumen. Anggap saja seperti membuat array dengan mengambil satu elemen dari setiap
grup yang diproduksi oleh kelompok.

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 unique_by(panjang)´
["gemuk", "daging", "anak kucing", "jangkrik", "asparagus"]
=> ["daging", "kental", "asparagus"]

membalikkan
Fungsi ini membalikkan array.

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

mengandung (elemen)
Filter berisi (b) akan menghasilkan true jika b sepenuhnya terkandung dalam input. A
string B terkandung dalam string A jika B adalah substring dari A. Sebuah array B terkandung dalam
sebuah array A jika semua elemen di B terdapat dalam sembarang elemen di A. Sebuah objek B adalah
terkandung dalam objek A jika semua nilai di B terkandung dalam nilai di A dengan
kunci yang sama. Semua jenis lain diasumsikan terkandung satu sama lain jika mereka sama.

jq berisi("bar")´
"foobar"
=> benar

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

jq berisi(["bazzzzz", "bar"])´
["foobar", "foobaz", "blarp"]
=> salah

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

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

indeks
Menampilkan array yang berisi indeks dalam . dimana s terjadi. Inputnya bisa berupa array, di
kasus apa jika s adalah array maka output indeks akan menjadi yang di mana semua elemen masuk .
cocok dengan mereka s.

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

jqindeks(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
Menampilkan indeks yang pertama (indeks) atau terakhir (rindex) terjadinya s di masukan.

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

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

dalam
Filter di dalam (b) akan menghasilkan true jika input benar-benar terkandung dalam b. Dia
pada dasarnya adalah versi terbalik dari mengandung.

jq inside("foobar")´
"batang"
=> benar

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

jq inside(["foobar", "foobaz", "blarp"])´
["bazzzzzz", "bar"]
=> salah

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

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

dimulai dengan(str)
Output benar jika . dimulai dengan argumen string yang diberikan.

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

berakhir dengan(str)
Output benar jika . diakhiri dengan argumen string yang diberikan.

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

kombinasi, kombinasi (n)
Menampilkan semua kombinasi elemen array dalam array input. Jika diberikan
argumen n, itu menampilkan semua kombinasi dari n pengulangan dari array input.

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

jqkombinasi(2)'
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]

ltrimstr(str)
Keluarkan inputnya dengan string awalan yang diberikan dihapus, jika dimulai dengan itu.

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

rtrimstr(str)
Keluarkan inputnya dengan string sufiks yang diberikan dihapus, jika diakhiri dengan itu.

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

meledak
Mengonversi string input menjadi array nomor codepoint string.

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

meledak
Kebalikan dari meledak.

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

membagi
Membagi string input pada argumen pemisah.

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

bergabung (str)
Bergabung dengan array elemen yang diberikan sebagai input, menggunakan argumen sebagai pemisah. Ini adalah
kebalikan dari membagi: yaitu, berlari split("foo") | bergabung ("foo") atas string input apa pun
mengembalikan string input tersebut.

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

ascii_downcase, ascii_upcase
Keluarkan salinan string input dengan karakter alfabetnya (az dan AZ) yang dikonversi ke
kasus yang ditentukan.

sementara (lanjutan; memperbarui)
Grafik sementara (lanjutan; memperbarui) fungsi memungkinkan Anda untuk berulang kali menerapkan pembaruan ke . sampai cond
itu salah.

Perhatikan bahwa sementara (lanjutan; memperbarui) didefinisikan secara internal sebagai fungsi jq rekursif. Rekursif
panggilan dalam sementara tidak akan menggunakan memori tambahan jika memperbarui menghasilkan paling banyak satu
keluaran untuk setiap masukan. Lihat topik lanjutan di bawah.

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

sampai (lanjutan; lanjut)
Grafik sampai (lanjutan; lanjut) fungsi memungkinkan Anda untuk berulang kali menerapkan ekspresi berikutnya,
awalnya untuk . kemudian ke outputnya sendiri, sampai cond adalah benar. Misalnya, ini dapat digunakan
untuk mengimplementasikan fungsi faktorial (lihat di bawah).

Perhatikan bahwa sampai (lanjutan; lanjut) didefinisikan secara internal sebagai fungsi jq rekursif. Rekursif
panggilan dalam sampai() tidak akan menggunakan memori tambahan jika berikutnya menghasilkan paling banyak satu
keluaran untuk setiap masukan. Lihat topik lanjutan di bawah.

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

berulang (f), berulang, berulang(f; kondisi), recurse_down
Grafik berulang (f) fungsi memungkinkan Anda untuk mencari melalui struktur rekursif, dan mengekstrak
data menarik dari semua tingkatan. Misalkan input Anda mewakili sistem file:

{"nama": "/", "anak-anak": [
{"nama": "/tempat sampah", "anak-anak": [
{"nama": "/bin/ls", "anak-anak": []},
{"nama": "/ Bin / sh", "anak-anak": []}]},
{"nama": "/ Home", "anak-anak": [
{"name": "/home/stephen", "anak-anak": [
{"name": "/home/stephen/jq", "anak-anak": []}]}]}]}

Sekarang anggaplah Anda ingin mengekstrak semua nama file yang ada. Anda perlu mengambil kembali . Nama,
.anak[].nama, .anak[].anak[].nama, dan seterusnya. Anda dapat melakukannya dengan:

berulang(.anak[]) | .nama

Saat dipanggil tanpa argumen, kambuh adalah setara dengan berulang (.[]?).

berulang (f) identik dengan berulang(f; . != batal) dan dapat digunakan tanpa khawatir tentang
kedalaman rekursi.

berulang(f; kondisi) adalah generator yang dimulai dengan memancarkan. dan kemudian memancarkan pada gilirannya
.|f, .|f|f, .|f|f|f, ... selama nilai yang dihitung memenuhi kondisi. Untuk
contoh, untuk menghasilkan semua bilangan bulat, setidaknya pada prinsipnya, seseorang dapat menulis berulang(.+1;
benar).

Untuk alasan warisan, recurse_down ada sebagai alias untuk memanggil kambuh tanpa argumen.
Alias ​​​​ini dianggap usang dan akan dihapus dalam rilis besar berikutnya.

Panggilan rekursif di kambuh tidak akan mengkonsumsi memori tambahan kapan pun f menghasilkan di
sebagian besar output 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

..
Singkatan untuk kambuh tanpa argumen. Ini dimaksudkan untuk menyerupai XPath //
operator. Perhatikan bahwa ..A tidak bekerja; menggunakan ..|a sebagai gantinya. Dalam contoh di bawah ini kami menggunakan
..|.a? untuk menemukan semua nilai kunci objek "a" di objek apa pun yang ditemukan "di bawah" ..

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

env
Menampilkan objek yang mewakili lingkungan jq.

jq env.PAGER´
nol
=> "kurang"

mengubah urutan
Transpose matriks yang mungkin bergerigi (array array). Baris diisi dengan nol sehingga
hasilnya selalu persegi panjang.

jq transpos
[[1], [2,3]]
=> [[1,2],[null,3]]

pencarian(x)
bsearch(x) melakukan pencarian biner untuk x dalam array input. Jika input diurutkan dan
berisi x, maka bsearch(x) akan mengembalikan indeksnya dalam array; jika tidak, jika array adalah
diurutkan, ia akan mengembalikan (-1 - ix) di mana ix adalah titik penyisipan sedemikian rupa sehingga array akan
masih diurutkan setelah penyisipan x pada ix. Jika array tidak diurutkan, bsearch(x)
akan mengembalikan bilangan bulat yang mungkin tidak menarik.

jqcari(0)'
[0,1]
=> 0

jqcari(0)'
[1,2,3]
=> -1

jqcari(4) sebagai $ix | jika $ix < 0 maka .[-(1+$ix)] = 4 else . akhir
[1,2,3]
=> [1,2,3,4]

Tali interpolasi - \(aduh)
Di dalam string, Anda dapat meletakkan ekspresi di dalam parens setelah garis miring terbalik. Apapun itu
pengembalian ekspresi akan diinterpolasi ke dalam string.

jq "Inputnya adalah \(.), yang kurang dari \(.+1)"´
42
=> "Inputnya adalah 42, yang berarti satu kurang dari 43"

mengubah untuk dari JSON
Grafik tojson dan darijson builtin membuang nilai sebagai teks JSON atau mengurai teks JSON ke dalam
nilai, masing-masing. Tojson bawaan berbeda dari tostring dalam pengembalian tostring
string tidak dimodifikasi, sementara tojson mengkodekan string sebagai string 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"]]

dibentuk string dan melarikan diri
Grafik @foo sintaks digunakan untuk memformat dan melepaskan string, yang berguna untuk membangun URL,
dokumen dalam bahasa seperti HTML atau XML, dan sebagainya. @foo dapat digunakan sebagai filter pada
sendiri, kemungkinan pelarian adalah:

@teks:

Panggilan mengikat, lihat fungsi tersebut untuk detailnya.

@json:

Membuat serial input sebagai JSON.

@html:

Menerapkan pelolosan HTML/XML, dengan memetakan karakter <>&´" ke entitas mereka
setara <, >, &, ', ".

@uri:

Menerapkan penyandian persen, dengan memetakan semua karakter URI yang dicadangkan ke a %XX urutan.

@csv:

Input harus berupa array, dan dirender sebagai CSV dengan tanda kutip ganda untuk
string, dan kutipan lolos dengan pengulangan.

@tsv:

Input harus berupa array, dan dirender sebagai TSV (nilai yang dipisahkan tab). Setiap
array input akan dicetak sebagai satu baris. Bidang dipisahkan oleh satu tab
(ascii 0x09). Masukan karakter baris-umpan (ascii 0x0a), kereta-kembali (ascii
0x0d), tab (ascii 0x09) dan garis miring terbalik (ascii 0x5c) akan ditampilkan sebagai pelarian
urutan \n, \r, \t, \\ masing.

@NS:

Input diloloskan cocok untuk digunakan dalam baris perintah untuk shell POSIX. jika
input adalah array, output akan menjadi serangkaian string yang dipisahkan oleh spasi.

@base64:

Input dikonversi ke base64 seperti yang ditentukan oleh RFC 4648.

Sintaks ini dapat dikombinasikan dengan interpolasi string dengan cara yang bermanfaat. Anda dapat mengikuti
@foo token dengan string literal. Isi dari string literal akan tidak melarikan diri.
Namun, semua interpolasi yang dibuat di dalam literal string itu akan diloloskan. Contohnya,

@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"

Perhatikan bahwa garis miring, tanda tanya, dll. di URL tidak diloloskan, karena merupakan bagian
dari string literal.

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

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

Tanggal
jq menyediakan beberapa fungsi penanganan tanggal dasar, dengan beberapa level tinggi dan level rendah
bawaan. Dalam semua kasus, bawaan ini secara eksklusif berurusan dengan waktu di UTC.

Grafik daridateiso8601 builtin mem-parsing datetimes dalam format ISO 8601 ke beberapa detik
sejak zaman Unix (1970-01-01T00:00:00Z). NS hari iniiso8601 builtin melakukan kebalikannya.

Grafik dari tanggal builtin mem-parsing string datetime. Saat ini dari tanggal hanya mendukung ISO 8601
string datetime, tetapi di masa depan ia akan mencoba mengurai string datetime lebih banyak
format.

Grafik hingga saat ini builtin adalah alias untuk hari iniiso8601.

Grafik sekarang builtin menampilkan waktu saat ini, dalam detik sejak zaman Unix.

Antarmuka jq tingkat rendah ke fungsi waktu C-library juga disediakan: waktu strp,
waktu luang, waktu mk, dan waktu malam. Lihat dokumentasi sistem operasi host Anda untuk
format string yang digunakan oleh waktu strp dan waktu luang. Catatan: ini belum tentu stabil
antarmuka di jq, terutama untuk fungsi lokalisasi mereka.

Grafik waktu malam builtin mengkonsumsi beberapa detik sejak zaman Unix dan menghasilkan "rusak
waktu henti" representasi waktu sebagai larik angka yang mewakili (dalam urutan ini): the
tahun, bulan (berbasis nol), hari dalam sebulan, jam dalam sehari, menit dari
jam, detik dari menit, hari dalam seminggu, dan hari dalam setahun -- semua
berbasis satu kecuali dinyatakan lain.

Grafik waktu mk builtin mengkonsumsi representasi "waktu rusak" dari output waktu oleh waktu malam
dan waktu strp.

Grafik waktu strp(fmt) builtin mem-parsing string input yang cocok dengan fmt argumen. Keluarannya ada di
representasi "waktu rusak" yang dikonsumsi oleh waktu malam dan keluaran oleh waktu mk.

Grafik waktu-waktu(fmt) builtin memformat waktu dengan format yang diberikan.

String format untuk waktu strp dan waktu luang dijelaskan dalam pustaka C biasa
dokumentasi. String format untuk datetime ISO 8601 adalah "%Y-%m-%dT%H:%M:%SZ".

jq mungkin tidak mendukung beberapa atau semua fungsi tanggal ini pada beberapa sistem.

jq dari tanggal´
"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

PERSYARATAN DAN PERBANDINGAN

==, !=
Ekspresi a == b´ akan menghasilkan benar jika hasil dari a dan b sama (yaitu,
jika mereka mewakili dokumen JSON yang setara) dan 'salah' jika tidak. Secara khusus, string
tidak pernah dianggap sama dengan angka. Jika Anda berasal dari Javascript, jq´s == seperti
Javascript´s === - mempertimbangkan nilai yang sama hanya ketika mereka memiliki tipe yang sama dan juga
nilai yang sama.

!= adalah "tidak sama", dan a != b´ mengembalikan nilai kebalikan dari a == b´

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

jika-maka-lagi
if A kemudian B lain C akhir akan bertindak sama seperti B if A menghasilkan nilai selain false or
null, tetapi bertindak sama seperti C jika tidak.

Memeriksa false atau null adalah gagasan "kebenaran" yang lebih sederhana daripada yang ditemukan di Javascript
atau Python, tetapi itu berarti Anda terkadang harus lebih eksplisit tentang kondisinya
yang Anda inginkan: Anda tidak dapat menguji apakah, misalnya string kosong menggunakan if . Nama kemudian A lain B akhir,
Anda akan membutuhkan sesuatu yang lebih seperti if (.nama | panjangnya) > 0 kemudian A lain B akhir sebagai gantinya.

Jika kondisi A menghasilkan beberapa hasil, itu dianggap "benar" jika salah satu dari mereka
hasilnya tidak salah atau nol. Jika menghasilkan hasil nol, itu dianggap salah.

Lebih banyak kasus dapat ditambahkan ke if menggunakan elif A kemudian B sintaks.

jq jika . == 0 maka

elif "nol". == 1 lalu "satu" yang lain "banyak" akhir´ 2 => "banyak"

>, >=, <=, <
Operator pembanding >, >=, <=, < kembali apakah argumen kiri mereka lebih besar dari,
lebih besar dari atau sama dengan, kurang dari atau sama dengan atau kurang dari argumen kanan mereka
(masing-masing).

Urutannya sama dengan yang dijelaskan untuk jenisdi atas.

jq . < 5´
2
=> benar

dan/atau/tidak
jq mendukung operator Boolean normal dan/atau/tidak. Mereka memiliki standar kebenaran yang sama
seolah-olah ekspresi - false dan null dianggap sebagai "nilai salah", dan yang lainnya adalah a
"nilai asli".

Jika operan dari salah satu operator ini menghasilkan banyak hasil, operator itu sendiri
akan menghasilkan hasil untuk setiap input.

tidak sebenarnya adalah fungsi bawaan daripada operator, sehingga disebut sebagai filter untuk
hal-hal mana yang dapat disalurkan daripada dengan sintaks khusus, seperti pada .foo dan .batang | tidak.

Ketiganya hanya menghasilkan nilai "benar" dan "salah", dan hanya berguna untuk yang asli
Operasi Boolean, bukan idiom Perl/Python/Ruby yang umum dari
"value_that_may_be_null atau default". Jika Anda ingin menggunakan bentuk "atau" ini, pilih di antara
dua nilai daripada mengevaluasi suatu kondisi, lihat operator "//" di bawah.

jq 42 dan "string"´
nol
=> benar

jq (benar, salah) atau salah´
nol
=> benar, salah

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

jq [benar, salah | bukan
nol
=> [salah, benar]

Alternatif operator - //
Filter formulir a // b menghasilkan hasil yang sama dengan a, Jika a menghasilkan hasil lainnya
dari palsu dan nol. Jika tidak, a // b menghasilkan hasil yang sama dengan b.

Ini berguna untuk memberikan default: .foo // 1 akan mengevaluasi untuk 1 jika tidak ada .foo
elemen dalam masukan. Ini mirip dengan caranya or kadang-kadang digunakan dalam Python (jq´s or operator
dicadangkan untuk operasi Boolean yang ketat).

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

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

coba tangkap
Kesalahan dapat ditangkap dengan menggunakan mencoba EXP menangkap EXP. Ekspresi pertama dieksekusi, dan jika
gagal maka yang kedua dijalankan dengan pesan kesalahan. Output dari handler, jika
any, adalah output seolah-olah itu adalah output dari ekspresi untuk dicoba.

Grafik mencoba EXP penggunaan formulir kosong sebagai penangan pengecualian.

jq try .a catch ". bukan objek"´
benar
=> ".bukan objek"

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

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

Melanggar di luar of kontrol struktur
Penggunaan try/catch yang mudah adalah untuk keluar dari struktur kontrol seperti menurunkan, untuk setiap,
sementara, Dan sebagainya.

Sebagai contoh:

# Ulangi ekspresi hingga memunculkan "break" sebagai
# kesalahan, lalu berhenti mengulangi tanpa memunculkan kembali kesalahan.
# Namun jika error yang tertangkap tidak "break" maka naikkan kembali.
coba repeat(exp) catch .=="break" lalu kosongkan lagi error;

jq memiliki sintaks untuk label leksikal bernama "break" atau "go (back) to":

label $keluar | ... pecahkan $ keluar ...

Grafik istirahat $label_nama ekspresi akan menyebabkan program bertindak seolah-olah yang terdekat
(ke kiri) label $label_nama diproduksi kosong.

Hubungan antara istirahat dan sesuai label adalah leksikal: labelnya harus
"terlihat" dari istirahat.

Untuk keluar dari menurunkan, Misalnya:

label $keluar | kurangi .[] sebagai $item (null; if .==false lalu pecahkan $out else ... end)

Program jq berikut menghasilkan kesalahan sintaks:

istirahat $out

karena tidak ada label $keluar terlihat.

? operator
Grafik ? operator, digunakan sebagai pengalaman?, adalah singkatan dari mencoba EXP.

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

REGULER EKSPRESI (PCRE)

jq menggunakan perpustakaan ekspresi reguler Oniguruma, seperti halnya php, ruby, TextMate, Sublime Text,
dll, jadi deskripsi di sini akan fokus pada spesifik jq.

Filter jq regex didefinisikan sehingga dapat digunakan menggunakan salah satu pola berikut:

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

dimana: * STRING, REGEX dan FLAGS adalah string jq dan tunduk pada interpolasi string jq; *
REGEX, setelah interpolasi string, harus berupa regex PCRE yang valid; *FILTER adalah salah satunya uji,
pertandingan, atau menangkap, seperti dijelaskan di bawah ini.

FLAGS adalah string yang terdiri dari salah satu dari beberapa flag yang didukung:

· g - Pencarian global (temukan semua kecocokan, bukan hanya yang pertama)

· i - Pencarian tidak peka huruf besar-kecil

· m - Mode multi baris (´.´ akan cocok dengan baris baru)

· n - Abaikan korek api kosong

· p - Mode s dan m diaktifkan

· s - Mode satu baris (´^´ -> \A´, $´ -> \Z´)

· l - Temukan kecocokan terpanjang yang mungkin

· x - Format regex yang diperluas (abaikan spasi dan komentar)

Untuk mencocokkan spasi putih dalam pola x gunakan pelarian seperti \s, mis

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

Perhatikan bahwa flag tertentu juga dapat ditentukan dalam REGEX, mis

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

dievaluasi menjadi: benar, benar, salah, salah.

[Memerlukan 1.5] tes (val), tes(regex; bendera)
Seperti pertandingan, tetapi tidak mengembalikan objek yang cocok, hanya benar or palsu untuk apakah atau tidak
regex cocok dengan input.

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

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

[Memerlukan 1.5] pertandingan (val), cocok (regex; bendera)
pertandingan menampilkan objek untuk setiap kecocokan yang ditemukannya. Pertandingan memiliki bidang berikut:

· mengimbangi - offset di titik kode UTF-8 dari awal input

· panjangnya - panjang dalam codepoint UTF-8 pertandingan

· tali - string yang cocok

· menangkap - array objek yang mewakili grup penangkap.

Menangkap objek grup memiliki bidang berikut:

· mengimbangi - offset di titik kode UTF-8 dari awal input

· panjangnya - panjang dalam titik kode UTF-8 dari grup penangkap ini

· tali - tali yang ditangkap

· nama - nama grup penangkap (atau nol jika tidak disebutkan namanya)

Menangkap grup yang tidak cocok dengan apa pun 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, "panjang": 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("ayo (? batang)? 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, "nama": "bar123"}]}

jq [ pertandingan("."; "g")] | panjang
"abc"
=> 3

[Memerlukan 1.5] tangkap (val), tangkap (regex; bendera)
Mengumpulkan tangkapan bernama dalam objek JSON, dengan nama setiap tangkapan sebagai kuncinya,
dan string yang cocok sebagai nilai yang sesuai.

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

[Memerlukan 1.5] pindai (regex), pindai (regex; bendera)
Keluarkan aliran substring input yang tidak tumpang tindih yang cocok dengan regex di
sesuai dengan bendera, jika ada yang telah ditentukan. Jika tidak ada kecocokan, alirannya adalah
kosong. Untuk menangkap semua kecocokan untuk setiap string input, gunakan idiom [ cepat ], misalnya [
pindai (regex) ].

pisahkan (regex; bendera)
Untuk kompatibilitas mundur, membagi membagi pada string, bukan regex.

[Memerlukan 1.5] perpecahan (regex), perpecahan (regex; bendera)
Ini memberikan hasil yang sama dengan mereka membagi rekan-rekan, tetapi sebagai aliran, bukan sebagai
Himpunan.

[Memerlukan 1.5] sub(regex; tali) sub(regex; rangkaian; bendera)
Keluarkan string yang diperoleh dengan mengganti kecocokan pertama regex dalam string input dengan
mengikat, setelah interpolasi. mengikat harus berupa string jq, dan mungkin berisi referensi
untuk menangkap bernama. Tangkapan bernama, pada dasarnya, disajikan sebagai objek JSON (sebagai
dibangun oleh menangkap) ke mengikat, jadi referensi ke variabel yang ditangkap bernama "x" akan
ambil formulir: "(.x)".

[Memerlukan 1.5] gsub(regex; rangkaian), gsub(regex; rangkaian; bendera)
gsub adalah seperti di bawah tetapi semua kemunculan regex yang tidak tumpang tindih digantikan oleh
string, setelah interpolasi.

ADVANCED FITUR

Variabel adalah kebutuhan mutlak di sebagian besar bahasa pemrograman, tetapi mereka diturunkan
ke "fitur lanjutan" di jq.

Dalam kebanyakan bahasa, variabel adalah satu-satunya cara untuk menyebarkan data. Jika Anda menghitung
nilai, dan Anda ingin menggunakannya lebih dari sekali, Anda harus menyimpannya dalam sebuah variabel. Ke
meneruskan nilai ke bagian lain dari program, Anda memerlukan bagian program itu untuk
mendefinisikan variabel (sebagai parameter fungsi, anggota objek, atau apa pun) di mana untuk menempatkan
data.

Dimungkinkan juga untuk mendefinisikan fungsi dalam jq, meskipun ini adalah fitur yang terbesar
gunakan mendefinisikan perpustakaan standar jq (banyak fungsi jq seperti peta dan menemukan sebenarnya
ditulis dalam jq).

jq memiliki operator reduksi, yang sangat kuat tetapi agak rumit. Sekali lagi, ini adalah
sebagian besar digunakan secara internal, untuk mendefinisikan beberapa bit yang berguna dari perpustakaan standar jq.

Ini mungkin tidak jelas pada awalnya, tetapi jq adalah semua tentang generator (ya, seperti yang sering ditemukan di
bahasa lainnya). Beberapa utilitas disediakan untuk membantu menangani generator.

Beberapa dukungan I/O minimal (selain membaca JSON dari input standar, dan menulis JSON ke
keluaran standar) tersedia.

Terakhir, ada modul/sistem perpustakaan.

Variabel
Di jq, semua filter memiliki input dan output, sehingga pemipaan manual tidak perlu
meneruskan nilai dari satu bagian program ke bagian berikutnya. Banyak ekspresi, misalnya a + b,
meneruskan input mereka ke dua subekspresi yang berbeda (di sini a dan b keduanya lulus sama
input), jadi variabel biasanya tidak diperlukan untuk menggunakan nilai dua kali.

Misalnya, menghitung nilai rata-rata dari sebuah array angka membutuhkan beberapa
variabel di sebagian besar bahasa - setidaknya satu untuk menampung array, mungkin satu untuk setiap elemen
atau untuk penghitung loop. Dalam jq, itu sederhana menambahkan / panjangnya - Yang menambahkan ekspresi diberikan
array dan menghasilkan jumlah, dan panjangnya ekspresi diberikan array dan menghasilkan
panjangnya.

Jadi, umumnya ada cara yang lebih bersih untuk menyelesaikan sebagian besar masalah di jq daripada mendefinisikan variabel.
Namun, terkadang mereka membuat segalanya lebih mudah, jadi jq memungkinkan Anda mendefinisikan variabel menggunakan
ekspresi as $variabel. Semua nama variabel dimulai dengan $. Ini versi yang sedikit lebih jelek
dari contoh rata-rata array:

panjang sebagai $array_length | tambahkan / $array_length

Kita akan membutuhkan masalah yang lebih rumit untuk menemukan situasi di mana sebenarnya menggunakan variabel
membuat hidup kita lebih mudah.

Misalkan kita memiliki array posting blog, dengan bidang "penulis" dan "judul", dan lainnya
objek yang digunakan untuk memetakan nama pengguna penulis ke nama asli. Masukan kami terlihat seperti:

{"posts": [{"title": "Pertama psot", "penulis": "anon"},
{"title": "Artikel yang ditulis dengan baik", "penulis": "person1"}],
"nama asli": {"anon": "Pengecut Anonim",
"person1": "Person McPherson"}}

Kami ingin menghasilkan posting dengan bidang penulis yang berisi nama asli, seperti pada:

{"title": "Pertama psot", "penulis": "Pengecut Anonim"}
{"title": "Artikel yang ditulis dengan baik", "penulis": "Person McPherson"}

Kami menggunakan variabel, $names, untuk menyimpan objek realnames, sehingga kami dapat merujuknya nanti
saat mencari nama pengguna penulis:

.nama asli sebagai $nama | .posting[] | {judul, penulis: $names[.author]}

Ekspresi exp as $x | ... artinya: untuk setiap nilai ekspresi exp, jalankan sisanya
pipa dengan seluruh input asli, dan dengan $x ditetapkan ke nilai itu. Dengan demikian as
berfungsi sebagai sesuatu dari loop foreach.

Sama seperti {foo} adalah cara menulis yang praktis {untuk: .foo}, sehingga {$foo} adalah cara menulis yang praktis
{foo:$foo}.

Beberapa variabel dapat dideklarasikan menggunakan satu as ekspresi dengan memberikan pola
yang cocok dengan struktur input (ini dikenal sebagai "penghancuran"):

. sebagai {nama asli: $nama, kiriman: [$pertama, $kedua]} | ...

Deklarasi variabel dalam pola array (misalnya, . as [$pertama, $detik]) terikat pada
elemen array masuk dari elemen pada indeks nol ke atas, secara berurutan. Ketika tidak ada
nilai pada indeks untuk elemen pola array, nol terikat pada variabel itu.

Variabel dicakup di seluruh ekspresi yang mendefinisikannya, jadi

.nama asli sebagai $nama | (.posts[] | {judul, penulis: $names[.author]})

akan bekerja, tapi

(.realnames sebagai $names | .posts[]) | {judul, penulis: $names[.author]}

biasa.

Untuk ahli teori bahasa pemrograman, lebih akurat untuk mengatakan bahwa variabel jq adalah
binding dengan cakupan leksikal. Khususnya tidak ada cara untuk mengubah nilai dari suatu ikatan;
seseorang hanya dapat mengatur pengikatan baru dengan nama yang sama, tetapi yang tidak akan terlihat 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}

Mendefinisikan Fungsi
Anda dapat memberi nama filter menggunakan sintaks "def":

kenaikan def: . + 1;

Sejak saat itu, kenaikan dapat digunakan sebagai filter seperti fungsi bawaan (sebenarnya, ini
adalah bagaimana beberapa bawaan didefinisikan). Suatu fungsi dapat mengambil argumen:

def peta(p): [.[] | F];

Argumen dilewatkan sebagai filter, bukan sebagai nilai. Argumen yang sama dapat dirujuk
beberapa kali dengan input yang berbeda (di sini f dijalankan untuk setiap elemen dari array input).
Argumen ke suatu fungsi bekerja lebih seperti panggilan balik daripada argumen nilai seperti. Ini adalah
penting untuk dipahami. Mempertimbangkan:

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

Hasilnya akan menjadi 20 karena f is .*2, dan selama pemanggilan pertama dari f . akan menjadi 5,
dan yang kedua adalah 10 (5 * 2), jadi hasilnya adalah 20. Argumen fungsi
adalah filter, dan filter mengharapkan input saat dipanggil.

Jika Anda ingin perilaku argumen nilai untuk mendefinisikan fungsi sederhana, Anda bisa menggunakan a
variabel:

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

Atau gunakan tangan pendek:

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

Dengan kedua definisi tersebut, nilai tambah(.foo) akan menambahkan input saat inis .foo lapangan untuk masing-masing
elemen larik.

Beberapa definisi menggunakan nama fungsi yang sama diperbolehkan. Setiap definisi ulang menggantikan
yang sebelumnya untuk jumlah argumen fungsi yang sama, tetapi hanya untuk referensi dari
fungsi (atau program utama) setelah definisi ulang.

jq def nilai tambah(f): . + [p]; 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]]

Menurunkan
Grafik menurunkan sintaks di jq memungkinkan Anda untuk menggabungkan semua hasil ekspresi dengan
mengumpulkannya menjadi satu jawaban. Sebagai contoh, kita akan melewati [3,2,1] untuk ini
ekspresi:

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

Untuk setiap hasil yang .[] menghasilkan, . + $barang dijalankan untuk mengumpulkan total berjalan,
mulai dari 0. Dalam contoh ini, .[] menghasilkan hasil 3, 2, dan 1, jadi efeknya adalah
mirip dengan menjalankan sesuatu seperti ini:

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

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

batas (n; pengalaman)
Grafik membatasi fungsi mengekstrak hingga n keluaran dari exp.

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

pertama (expr), terakhir (expr), ke-n(n; ekspr)
Grafik pertama (expr) dan terakhir (kedaluwarsa) fungsi mengekstrak nilai pertama dan terakhir dari cepat,
masing.

Grafik ke-n(n; ekspr) fungsi mengekstrak keluaran nilai ke-n dengan cepat. Ini dapat didefinisikan sebagai
def ke-n(n; ekspr): terakhir(batas(n + 1; ekspr));. Catat itu ke-n(n; ekspr) tidak mendukung
nilai negatif dari n.

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

pertama, terakhir, ke-n(n)
Grafik pertama dan terakhir fungsi mengekstrak nilai pertama dan terakhir dari array apa pun di ..

Grafik ke-n(n) fungsi mengekstrak nilai ke-n dari array apa pun di ..

jq [rentang(.)]|[pertama, terakhir, n(5)]'
10
=> [0,9,5]

untuk setiap
Grafik untuk setiap sintaksnya mirip dengan menurunkan, tetapi dimaksudkan untuk memungkinkan pembangunan membatasi
dan reduksi yang menghasilkan hasil antara (lihat contoh).

Bentuknya adalah untuk setiap EXP as $var (INIT; MEMPERBARUI; EKSTRAK). Seperti menurunkan, INIT dievaluasi
sekali untuk menghasilkan nilai keadaan, maka setiap keluaran EXP terikat pada $var, UPDATE is
dievaluasi untuk setiap keluaran dari EXP dengan keadaan saat ini dan dengan $var bisa dilihat. Setiap nilai
keluaran oleh UPDATE menggantikan keadaan sebelumnya. Akhirnya, EKSTRAK dievaluasi untuk setiap yang baru
negara untuk mengekstrak output dari untuk setiap.

Ini sebagian besar hanya berguna untuk membangun menurunkan- Dan membatasi-seperti fungsi. Tapi itu
jauh lebih umum, karena memungkinkan pengurangan sebagian (lihat contoh di bawah).

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

Rekursi
Seperti dijelaskan di atas, kambuh menggunakan rekursi, dan fungsi jq apa pun bisa rekursif. NS
sementara builtin juga diimplementasikan dalam hal rekursi.

Panggilan ekor dioptimalkan setiap kali ekspresi di sebelah kiri keluaran panggilan rekursif
nilai terakhirnya. Dalam praktiknya ini berarti bahwa ekspresi di sebelah kiri rekursif
panggilan tidak boleh menghasilkan lebih dari satu output untuk setiap input.

Sebagai contoh:

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

def while(cond; perbarui):
def _sementara:
jika cond maka ., (perbarui | _ while) else ujung kosong;
_ketika;

def ulangi (exp):
def _ulangi:
exp, _ulangi;
_mengulang;

generator dan iterator
Beberapa operator dan fungsi jq sebenarnya adalah generator karena mereka dapat menghasilkan nol,
satu, atau lebih nilai untuk setiap input, seperti yang diharapkan dalam pemrograman lain
bahasa yang memiliki generator. Sebagai contoh, .[] menghasilkan semua nilai dalam inputnya
(yang harus berupa array atau objek), kisaran (0; 10) menghasilkan bilangan bulat antara 0 dan
10, dan seterusnya.

Bahkan operator koma adalah generator, yang pertama-tama menghasilkan nilai yang dihasilkan oleh
ekspresi di sebelah kiri koma, lalu untuk masing-masingnya, nilai yang dihasilkan oleh
ekspresi di sebelah kanan koma.

Grafik kosong builtin adalah generator yang menghasilkan output nol. NS kosong builtin
mundur ke ekspresi generator sebelumnya.

Semua fungsi jq bisa menjadi generator hanya dengan menggunakan generator bawaan. Itu juga mungkin
untuk mendefinisikan generator baru hanya menggunakan rekursi dan operator koma. Jika rekursif
call(s) is(are) "dalam posisi ekor" maka generator akan efisien. Dalam contoh
di bawah panggilan rekursif oleh _jangkauan untuk dirinya sendiri dalam posisi ekor. Contoh pamer
tiga topik lanjutan: rekursi ekor, konstruksi generator, dan sub-fungsi.

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

jq def while(cond; update): def _ while: if cond then ., (update | _ while) else ujung kosong; _ketika; [sementara(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

MATH

jq saat ini hanya memiliki dukungan angka floating point presisi ganda (754-bit) IEEE64.

Selain operator aritmatika sederhana seperti +, jq juga memiliki sebagian besar fungsi matematika standar
dari perpustakaan matematika C. Fungsi matematika C yang mengambil argumen input tunggal (mis. dosa())
tersedia sebagai fungsi jq argumen nol. Fungsi matematika C yang membutuhkan dua input
argumen (misalnya, kekuatan()) tersedia sebagai fungsi jq dua argumen yang mengabaikan ..

Ketersediaan fungsi matematika standar tergantung pada ketersediaan yang sesuai
fungsi matematika di sistem operasi Anda dan perpustakaan matematika C. Fungsi matematika tidak tersedia
akan didefinisikan tetapi akan menimbulkan kesalahan.

I / O

Saat ini jq memiliki dukungan minimal untuk I/O, sebagian besar dalam bentuk kontrol atas kapan
input dibaca. Dua fungsi bawaan disediakan untuk ini, memasukkan dan input, yang membaca
dari sumber yang sama (mis. stdin, file bernama pada baris perintah) sebagai jq itu sendiri. Ini
dua bawaan, dan tindakan membaca jq sendiri, dapat disisipkan satu sama lain.

Satu builtin menyediakan kemampuan output minimal, men-debug. (Ingat bahwa program jq´s
nilai output selalu ditampilkan sebagai teks JSON aktif stdout.) The men-debug bawaan dapat memiliki
perilaku khusus aplikasi, seperti untuk executable yang menggunakan libjq C API tetapi tidak
jq yang dapat dieksekusi itu sendiri.

memasukkan
Mengeluarkan satu masukan baru.

input
Keluarkan semua masukan yang tersisa, satu per satu.

Hal ini terutama berguna untuk pengurangan input program.

men-debug
Menyebabkan pesan debug berdasarkan nilai input yang akan dihasilkan. Pembungkus jq yang dapat dieksekusi
nilai masukan dengan ["DEBUG:", ] dan mencetak itu dan baris baru di stderr,
kompak. Ini mungkin berubah di masa depan.

masukan_namafile
Mengembalikan nama file yang inputnya sedang difilter. Perhatikan bahwa ini akan
tidak berfungsi dengan baik kecuali jq berjalan di lokal UTF-8.

masukan_baris_nomor
Mengembalikan nomor baris dari input yang sedang difilter.

MENGALIR

Dengan --sungai kecil opsi jq dapat mengurai teks input dalam mode streaming, memungkinkan jq
program untuk mulai memproses teks JSON besar segera daripada setelah parse
selesai. Jika Anda memiliki satu teks JSON berukuran 1GB, streaming akan memungkinkan Anda
untuk memprosesnya lebih cepat.

Namun, streaming tidak mudah ditangani karena program jq akan melakukannya [ ,
] (dan beberapa bentuk lainnya) sebagai input.

Beberapa bawaan disediakan untuk memudahkan penanganan aliran.

Contoh di bawah ini menggunakan bentuk streaming dari [0,[1]], Yang
[[0],0],[[1,0],1],[[1,0]],[[1]].

Formulir streaming termasuk: [ , ] (untuk menunjukkan nilai skalar, array kosong,
atau objek kosong), dan [ ] (untuk menunjukkan akhir dari array atau objek). Masa depan
versi jq dijalankan dengan --sungai kecil dan -seq dapat menampilkan formulir tambahan seperti: ["kesalahan
pesan"] ketika teks input gagal diurai.

truncate_stream(aliran_ekspresi)
Mengkonsumsi angka sebagai input dan memotong jumlah elemen jalur yang sesuai dari
di sebelah kiri output dari ekspresi streaming yang diberikan.

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

daristream(stream_expression)
Nilai keluaran yang sesuai dengan keluaran ekspresi aliran.

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

ke arus
Grafik ke arus builtin mengeluarkan bentuk streaming dari inputnya.

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

PENUGASAN

Tugas bekerja sedikit berbeda di jq daripada di kebanyakan bahasa pemrograman. jq tidak
membedakan antara referensi dan salinan sesuatu - dua objek atau array adalah
baik sama atau tidak sama, tanpa gagasan lebih lanjut tentang menjadi "objek yang sama" atau "tidak"
objek yang sama".

Jika suatu objek memiliki dua bidang yang merupakan array, .foo dan .batang, dan Anda menambahkan sesuatu ke
.foo, kemudian .batang tidak akan bertambah besar. Bahkan jika Anda baru saja mengatur .batang = .foo. Jika Anda sudah terbiasa
untuk pemrograman dalam bahasa seperti Python, Java, Ruby, Javascript, dll. maka Anda dapat berpikir
seolah-olah jq melakukan salinan mendalam penuh dari setiap objek sebelum melakukan tugas
(untuk kinerja, sebenarnya tidak melakukan itu, tapi itu ide umumnya).

Semua operator penugasan di jq memiliki ekspresi jalur di sisi kiri.

=
Filter .foo = 1 akan mengambil sebagai input objek dan menghasilkan sebagai output objek dengan
bidang "foo" disetel ke 1. Tidak ada gagasan tentang "memodifikasi" atau "mengubah" sesuatu di jq -
semua nilai jq tidak dapat diubah. Contohnya,

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

tidak akan memiliki efek samping dari pengaturan .bar.baz untuk disetel ke 1, karena terlihat serupa
program dalam Javascript, Python, Ruby atau bahasa lain akan. Tidak seperti bahasa-bahasa ini (tetapi
seperti Haskell dan beberapa bahasa fungsional lainnya), tidak ada gagasan tentang dua array atau
objek menjadi "array yang sama" atau "objek yang sama". Mereka bisa sama, atau tidak sama, tapi
jika kita mengubah salah satunya dalam keadaan apa pun, yang lain tidak akan berubah di belakang kita.

Ini berarti bahwa tidak mungkin untuk membangun nilai melingkar di jq (seperti array yang
elemen pertama adalah dirinya sendiri). Ini cukup disengaja, dan memastikan bahwa apa pun yang jq
program dapat menghasilkan dapat direpresentasikan dalam JSON.

Perhatikan bahwa ruas kiri =´ mengacu pada nilai dalam .. Jadi $var.foo = 1 tidak akan bekerja
seperti yang diharapkan ($var.foo bukan ekspresi jalur yang valid atau berguna dalam .); menggunakan $var | .foo = 1
sebagai gantinya.

Jika ruas kanan =´ menghasilkan banyak nilai, maka untuk setiap nilai tersebut jq akan
atur jalur di sisi kiri ke nilai dan kemudian akan menampilkan yang dimodifikasi ..
Sebagai contoh, (.a,.b)=jarak(2) output {"a":0,"b":0}, kemudian {"a":1,"b":1}. "pembaruan"
formulir tugas (lihat di bawah) jangan lakukan ini.

Perhatikan juga itu .a,.b=0 tidak mengatur .a dan .b, tapi (.a,.b)=0 menetapkan keduanya.

|=
Selain operator penugasan =´, jq menyediakan operator "pembaruan" ´|=´, yang
mengambil filter di sisi kanan dan menghitung nilai baru untuk properti dari .
ditugaskan dengan menjalankan nilai lama melalui ekspresi ini. Misalnya, .foo |=
.+1 akan membuat objek dengan bidang "foo" disetel ke input "foo" plus 1.

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

Berikan masukan {"a": {"b": 10}, "b": 20}´ ke program:

.a = .b .a |= .b

Yang pertama akan mengatur bidang "a" dari input ke bidang "b" dari input, dan menghasilkan
keluaran {"a": 20}. Yang terakhir akan mengatur bidang "a" dari input ke bidang "a"s
bidang "b", menghasilkan {"a": 10}.

Sisi kiri dapat berupa ekspresi jalur umum apa pun; Lihat jalur().

Perhatikan bahwa ruas kiri |=´ mengacu pada nilai dalam .. Jadi $var.foo |= . + 1 biasa
bekerja sesuai harapan ($var.foo bukan ekspresi jalur yang valid atau berguna dalam .); menggunakan $var | .foo
|= . + 1 sebagai gantinya.

Jika sisi kanan menghasilkan banyak nilai, hanya nilai terakhir yang akan digunakan.

jq (..|select(type=="boolean")) |= jika . lalu 1 lagi 0 berakhir´
[benar,salah,[5,benar,[benar,[salah]],salah]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, /=, %=, // =
jq memiliki beberapa operator bentuk a op= b, yang semuanya setara dengan a |= . op b. Begitu,
+= 1 dapat digunakan untuk menambah nilai.

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

Kompleks tugas
Lebih banyak hal yang diizinkan di sisi kiri tugas jq daripada di sebagian besar
bahasa. Kami telah melihat akses lapangan sederhana di sisi kiri, dan itu tidak
mengejutkan bahwa akses array berfungsi dengan baik:

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

Apa yang mungkin mengejutkan adalah bahwa ekspresi di sebelah kiri dapat menghasilkan banyak
hasil, mengacu pada poin yang berbeda dalam dokumen input:

.postingan[].komentar |= . + ["ini bagus"]

Contoh itu menambahkan string "ini bagus" ke larik "komentar" dari setiap posting di
input (di mana inputnya adalah objek dengan bidang "postingan" yang merupakan larik posting).

Ketika jq menemukan tugas seperti a = b´, ia mencatat "jalur" yang diambil untuk memilih a
bagian dari dokumen input saat menjalankan a. Jalur ini kemudian digunakan untuk menemukan bagian mana dari
input untuk diubah saat menjalankan tugas. Filter apa pun dapat digunakan pada
sisi kiri persamaan - jalur mana pun yang dipilihnya dari input akan berada di tempat
penugasan dilakukan.

Ini adalah operasi yang sangat kuat. Misalkan kita ingin menambahkan komentar ke posting blog, menggunakan
masukan "blog" yang sama di atas. Kali ini, kami hanya ingin mengomentari postingan yang ditulis oleh
"stedolan". Kami dapat menemukan posting tersebut menggunakan fungsi "pilih" yang dijelaskan sebelumnya:

.posting[] | pilih(.penulis == "stedolan")

Jalur yang disediakan oleh operasi ini menunjuk ke setiap pos yang ditulis "stedolan", dan
kita dapat mengomentari masing-masing dari mereka dengan cara yang sama seperti yang kita lakukan sebelumnya:

(.posts[] | pilih(.penulis == "stedolan") | .comments) |=
. + ["mengerikan."]

MODUL

jq memiliki sistem perpustakaan/modul. Modul adalah file yang namanya diakhiri dengan .jq.

Modul yang diimpor oleh program dicari di jalur pencarian default (lihat di bawah). NS
mengimpor dan memasukkan arahan memungkinkan importir untuk mengubah jalur ini.

Jalur di jalur pencarian tunduk pada berbagai substitusi.

Untuk jalur yang dimulai dengan "~/", direktori home pengguna diganti dengan "~".

Untuk jalur yang dimulai dengan "$ORIGIN/", jalur dari jq yang dapat dieksekusi diganti dengan
"$ASAL".

Untuk jalur yang dimulai dengan "./" atau jalur yang ".", jalur file yang disertakan adalah
diganti dengan ".". Untuk program tingkat atas yang diberikan pada baris perintah, arus
direktori digunakan.

Arahan impor dapat secara opsional menentukan jalur pencarian yang defaultnya ditambahkan.

Jalur pencarian default adalah jalur pencarian yang diberikan kepada -L opsi baris perintah, yang lain
["~/.jq", "$ASAL/../lib/jq", "$ASAL/../ lib"].

Elemen jalur string kosong dan kosong menghentikan pemrosesan jalur pencarian.

Ketergantungan dengan jalur relatif "foo/bar" akan dicari di "foo/bar.jq" dan
"foo/bar/bar.jq" di jalur pencarian yang diberikan. Ini dimaksudkan agar modul dapat ditempatkan
dalam direktori bersama dengan, misalnya, file kontrol versi, file README, dan sebagainya,
tetapi juga untuk memungkinkan modul file tunggal.

Komponen berurutan dengan nama yang sama tidak diperbolehkan untuk menghindari ambiguitas (mis.
"foo/foo").

Misalnya dengan -L$HOME/.jq sebuah modul foo dapat ditemukan di $HOME/.jq/foo.jq dan
$HOME/.jq/foo/foo.jq.

Jika "$HOME/.jq" adalah sebuah file, itu bersumber dari program utama.

mengimpor RelatifPathString as NAMA [ ];
Mengimpor modul yang ditemukan di jalur yang diberikan relatif ke direktori di jalur pencarian. Sebuah ".jq"
akhiran akan ditambahkan ke string jalur relatif. Simbol modul diawali dengan
"NAMA::".

Metadata opsional harus berupa ekspresi jq konstan. Itu harus menjadi objek dengan kunci
seperti "beranda" dan sebagainya. Saat ini jq hanya menggunakan kunci/nilai "pencarian" dari
metadata. Metadata juga tersedia untuk pengguna melalui modulmeta bawaan

Kunci "pencarian" dalam metadata, jika ada, harus memiliki nilai string atau larik (array
dari string); ini adalah jalur pencarian yang akan diawali dengan jalur pencarian tingkat atas.

memasukkan RelatifPathString [ ];
Mengimpor modul yang ditemukan di jalur yang diberikan relatif ke direktori di jalur pencarian seolah-olah itu
dimasukkan ke tempatnya. Sufiks ".jq" akan ditambahkan ke string jalur relatif. NS
simbol modul diimpor ke ruang nama pemanggil seolah-olah konten modul memiliki
telah dimasukkan secara langsung.

Metadata opsional harus berupa ekspresi jq konstan. Itu harus menjadi objek dengan kunci
seperti "beranda" dan sebagainya. Saat ini jq hanya menggunakan kunci/nilai "pencarian" dari
metadata. Metadata juga tersedia untuk pengguna melalui modulmeta bawaan

mengimpor RelatifPathString as $NAMA [ ];
Mengimpor file JSON yang ditemukan di jalur yang diberikan relatif ke direktori di jalur pencarian. A
Akhiran ".json" akan ditambahkan ke string jalur relatif. Data file akan menjadi
tersedia sebagai $NAMA::NAMA.

Metadata opsional harus berupa ekspresi jq konstan. Itu harus menjadi objek dengan kunci
seperti "beranda" dan sebagainya. Saat ini jq hanya menggunakan kunci/nilai "pencarian" dari
metadata. Metadata juga tersedia untuk pengguna melalui modulmeta bawaan

Kunci "pencarian" dalam metadata, jika ada, harus memiliki nilai string atau larik (array
dari string); ini adalah jalur pencarian yang akan diawali dengan jalur pencarian tingkat atas.

modul ;
Arahan ini sepenuhnya opsional. Ini tidak diperlukan untuk pengoperasian yang benar. Itu melayani
hanya bertujuan untuk menyediakan metadata yang dapat dibaca dengan modulmeta bawaan

Metadata harus berupa ekspresi jq yang konstan. Itu harus menjadi objek dengan kunci seperti
"halaman muka". Saat ini jq tidak menggunakan metadata ini, tetapi tersedia untuk pengguna
melalui modulmeta bawaan

modulmeta
Mengambil nama modul sebagai input dan mengeluarkan metadata modul sebagai objek, dengan
impor modul (termasuk metadata) sebagai nilai larik untuk kunci "deps".

Program dapat menggunakan ini untuk menanyakan metadata modul, yang kemudian dapat mereka gunakan untuk, untuk
misalnya, mencari, mengunduh, dan menginstal dependensi yang hilang.

Gunakan jq online menggunakan layanan onworks.net