jq - ອອນລາຍໃນຄລາວ

ໂຄງການ:

NAME

jq - ໂປເຊດເຊີ JSON ແຖວຄໍາສັ່ງ

ສະຫຼຸບສັງລວມ

jq [ທາງເລືອກໃນການ... ] ການກັ່ນຕອງ [ໄຟ... ]

jq ສາມາດປ່ຽນ JSON ໃນຫຼາຍວິທີ, ໂດຍການເລືອກ, ການເຮັດຊ້ຳ, ຫຼຸດ ແລະ ອື່ນໆ
ຈັດການເອກະສານ JSON. ສໍາລັບຕົວຢ່າງ, ແລ່ນຄໍາສັ່ງ jq ແຜນທີ່ (ລາຄາ) | ເພີ່ມ' ຈະ
ເອົາ array ຂອງ JSON object ເປັນ input ແລະສົ່ງຄືນຜົນລວມຂອງຊ່ອງ "ລາຄາ" ຂອງເຂົາເຈົ້າ.

jq ສາມາດຍອມຮັບການປ້ອນຂໍ້ຄວາມເຊັ່ນດຽວກັນ, ແຕ່ໂດຍຄ່າເລີ່ມຕົ້ນ, jq ອ່ານການຖ່າຍທອດຂອງ JSON
(ລວມທັງຕົວເລກແລະຕົວຫນັງສືອື່ນໆ) ຈາກ stdin. Whitespace ແມ່ນພຽງແຕ່ຕ້ອງການເພື່ອແຍກ
ນິຕິບຸກຄົນເຊັ່ນ: 1 ແລະ 2, ແລະຄວາມຈິງແລະຜິດ. ໜຶ່ງ ຫຼືຫຼາຍກວ່ານັ້ນ ໄຟ ອາດຈະຖືກກໍານົດ, ໃນນັ້ນ
ກໍລະນີ jq ຈະອ່ານການປ້ອນຂໍ້ມູນຈາກເຫຼົ່ານັ້ນແທນ.

ໄດ້ ທາງເລືອກໃນການ ໄດ້ຖືກອະທິບາຍຢູ່ໃນ ຮຽກຮ້ອງ JQ ພາກ; ພວກເຂົາສ່ວນຫຼາຍແມ່ນກ່ຽວຂ້ອງກັບການປ້ອນຂໍ້ມູນແລະຜົນຜະລິດ
ການຈັດຮູບແບບ. ທ ການກັ່ນຕອງ ຖືກຂຽນໄວ້ໃນພາສາ jq ແລະກໍານົດວິທີການຫັນປ່ຽນ
ປ້ອນເອກະສານ ຫຼືເອກະສານ.

FILTERS

ໂຄງການ jq ແມ່ນ "ການກັ່ນຕອງ": ມັນໃຊ້ເວລາການປ້ອນຂໍ້ມູນ, ແລະຜະລິດຜົນຜະລິດ. ມີຫຼາຍ
ຕົວກອງ builtin ສໍາລັບການສະກັດພາກສະຫນາມສະເພາະໃດຫນຶ່ງຂອງວັດຖຸ, ຫຼືການແປງຕົວເລກເປັນ
ຊ່ອຍແນ່, ຫຼືວຽກງານມາດຕະຖານອື່ນໆ.

ການກັ່ນຕອງສາມາດຖືກລວມເຂົ້າກັນໃນຫຼາຍວິທີ - ທ່ານສາມາດທໍ່ຜົນຜະລິດຂອງການກັ່ນຕອງຫນຶ່ງເຂົ້າໄປໃນ
ການກັ່ນຕອງອື່ນ, ຫຼືເກັບກໍາຜົນຜະລິດຂອງການກັ່ນຕອງເຂົ້າໄປໃນ array.

ບາງຕົວກອງຜະລິດຜົນໄດ້ຮັບຫຼາຍຢ່າງ, ຕົວຢ່າງເຊັ່ນມີອັນທີ່ຜະລິດທັງຫມົດ
ອົງປະກອບຂອງ array ການປ້ອນຂໍ້ມູນຂອງມັນ. ທໍ່ການກັ່ນຕອງເຂົ້າໄປໃນວິນາທີແລ່ນການກັ່ນຕອງທີສອງສໍາລັບ
ແຕ່ລະອົງປະກອບຂອງ array. ໂດຍທົ່ວໄປແລ້ວ, ສິ່ງທີ່ຕ້ອງເຮັດດ້ວຍ loops ແລະ iteration
ໃນພາສາອື່ນແມ່ນເຮັດໄດ້ໂດຍການຕິດຕົວກອງເຂົ້າກັນໃນ jq.

ມັນເປັນສິ່ງ ສຳ ຄັນທີ່ຈະຕ້ອງຈື່ໄວ້ວ່າທຸກໆຕົວກອງມີວັດສະດຸປ້ອນແລະຜົນຜະລິດ. ເຖິງແມ່ນວ່າຕົວຫນັງສື
ເຊັ່ນ "ສະບາຍດີ" ຫຼື 42 ແມ່ນຕົວກອງ - ພວກເຂົາເອົາການປ້ອນຂໍ້ມູນແຕ່ສະເຫມີຜະລິດຕົວຫນັງສືດຽວກັນກັບ
ຜົນຜະລິດ. ການດໍາເນີນງານທີ່ປະສົມປະສານສອງຕົວກອງ, ເຊັ່ນ: ການເພີ່ມເຕີມ, ໂດຍທົ່ວໄປແລ້ວຈະປ້ອນຂໍ້ມູນເຂົ້າດຽວກັນ
ທັງສອງແລະສົມທົບຜົນໄດ້ຮັບ. ດັ່ງນັ້ນ, ທ່ານສາມາດປະຕິບັດການກັ່ນຕອງສະເລ່ຍເປັນ ເພີ່ມ / ຄວາມຍາວ
- ການ​ໃຫ້​ອາ​ຫານ​ອາ​ເຣ​ການ​ປ້ອນ​ຂໍ້​ມູນ​ທັງ​ສອງ​ເພື່ອ​ ເພີ່ມ ການກັ່ນຕອງແລະ ຄວາມຍາວ ການກັ່ນຕອງແລະຫຼັງຈາກນັ້ນປະຕິບັດ
ພະແນກ.

ແຕ່ນັ້ນແມ່ນກ້າວໄປຂ້າງໜ້າຕົວເຮົາເອງ. :) ເລີ່ມຕົ້ນດ້ວຍສິ່ງທີ່ງ່າຍກວ່າ:

ຮຽກຮ້ອງ JQ

jq filters ແລ່ນຢູ່ໃນກະແສຂໍ້ມູນ JSON. ການປ້ອນຂໍ້ມູນໃສ່ jq ຖືກແຍກເປັນລຳດັບ
whitespace-separated ຄ່າ JSON ທີ່ສົ່ງຜ່ານການກັ່ນຕອງທີ່ສະຫນອງໃຫ້ຫນຶ່ງຢູ່ທີ່ a
ເວລາ. ຜົນຜະລິດຂອງການກັ່ນຕອງໄດ້ຖືກຂຽນເປັນມາດຕະຖານອອກ, ອີກເທື່ອຫນຶ່ງເປັນລໍາດັບຂອງ
ຂໍ້ມູນ JSON ແຍກຊ່ອງຫວ່າງ.

ຫມາຍເຫດ: ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະຄິດເຖິງກົດລະບຽບການອ້າງອີງຂອງແກະ. ຕາມກົດລະບຽບ, ມັນດີທີ່ສຸດທີ່ຈະ
ອ້າງອີງສະເໝີ (ດ້ວຍຕົວອັກສອນດຽວ) ໂປຣແກຣມ jq, ເປັນຕົວອັກສອນຫຼາຍເກີນໄປ
ຄວາມຫມາຍພິເສດຂອງ jq ຍັງເປັນຕົວລະຄອນ meta- shell. ຍົກ​ຕົວ​ຢ່າງ, jq "ຟູ" ຈະລົ້ມເຫລວໃນ
ຫອຍ Unix ສ່ວນໃຫຍ່ເພາະວ່າມັນຈະຄືກັນກັບ jq ຟູ, ເຊິ່ງໂດຍທົ່ວໄປຈະລົ້ມເຫລວ
ເນື່ອງຈາກວ່າ ຟູ is ບໍ່ ກໍານົດໄວ້. ໃນ​ເວ​ລາ​ທີ່​ການ​ນໍາ​ໃຊ້ Windows ຄໍາ​ສັ່ງ shell (cmd.exe​) ມັນ​ເປັນ​ການ​ດີ​ທີ່​ສຸດ​ທີ່​ຈະ​
ໃຊ້ວົງຢືມສອງເທົ່າປະມານໂຄງການ jq ຂອງເຈົ້າເມື່ອໃຫ້ຢູ່ໃນເສັ້ນຄໍາສັ່ງ (ແທນທີ່ຈະເປັນ -f
program-file ທາງເລືອກ), ແຕ່ຫຼັງຈາກນັ້ນ double-quotes ໃນໂຄງການ jq ຕ້ອງການ backslash escaping.

ທ່ານສາມາດສົ່ງຜົນກະທົບຕໍ່ວິທີທີ່ jq ອ່ານແລະຂຽນການປ້ອນຂໍ້ມູນແລະຜົນຜະລິດຂອງມັນໂດຍໃຊ້ບາງເສັ້ນຄໍາສັ່ງ
ຕົວເລືອກ:

· - ການປ່ຽນແປງ:

ສົ່ງເວີຊັນ jq ແລະອອກດ້ວຍສູນ.

· --seq:

ການນໍາໃຊ້ application/json-seq ໂຄງການປະເພດ MIME ສໍາລັບການແຍກຂໍ້ຄວາມ JSON ໃນການປ້ອນຂໍ້ມູນຂອງ jq
ແລະຜົນຜະລິດ. ນີ້ຫມາຍຄວາມວ່າຕົວອັກສອນ ASCII RS (ຕົວແຍກບັນທຶກ) ຖືກພິມອອກກ່ອນ
ແຕ່​ລະ​ຄ່າ​ຂອງ​ຜົນ​ຜະ​ລິດ​ແລະ ASCII LF (ການ​ປ້ອນ​ເສັ້ນ​) ຖືກ​ພິມ​ອອກ​ຫຼັງ​ຈາກ​ການ​ຜະ​ລິດ​ຕະ​ພັນ​ທຸກ​ຄັ້ງ​. ປ້ອນຂໍ້ມູນ
ຂໍ້ຄວາມ JSON ທີ່ບໍ່ສາມາດແຍກວິເຄາະຖືກລະເລີຍ (ແຕ່ເຕືອນກ່ຽວກັບ), ຍົກເລີກທັງໝົດ
ການປ້ອນຂໍ້ມູນຕໍ່ມາຈົນກ່ວາ RS ຕໍ່ໄປ. ນີ້ເພີ່ມເຕີມຍັງວິເຄາະຜົນຜະລິດຂອງ jq ໂດຍບໍ່ມີການ
--seq ທາງເລືອກ.

· -- ກະແສ:

ວິເຄາະການປ້ອນຂໍ້ມູນໃນແຟຊັ່ນການຖ່າຍທອດ, ການສະແດງຜົນອາເຣຂອງເສັ້ນທາງ ແລະຄ່າໃບ
(scalars ແລະ arrays ເປົ່າຫຼືວັດຖຸເປົ່າ). ຍົກ​ຕົວ​ຢ່າງ, "ກ" ກາຍເປັນ [[],"a"], ແລະ
[[],"a",["b"]] ກາຍເປັນ [[0],[]], [[1​] "a"], ແລະ [[1,0],"b"].

ນີ້ແມ່ນເປັນປະໂຫຍດສໍາລັບການປຸງແຕ່ງວັດສະດຸປ້ອນຂະຫນາດໃຫຍ່ຫຼາຍ. ໃຊ້ນີ້ໂດຍສົມທົບກັບ
ການກັ່ນຕອງແລະ ຫຼຸດຜ່ອນ ແລະ foreach syntax ເພື່ອຫຼຸດຜ່ອນການປ້ອນຂໍ້ມູນຂະຫນາດໃຫຍ່ເພີ່ມຂຶ້ນ.

· --slurp/-s:

ແທນທີ່ຈະແລ່ນການກັ່ນຕອງສໍາລັບແຕ່ລະວັດຖຸ JSON ໃນການປ້ອນຂໍ້ມູນ, ອ່ານການປ້ອນຂໍ້ມູນທັງຫມົດ
ຖ່າຍທອດເຂົ້າໄປໃນ array ຂະຫນາດໃຫຍ່ແລະແລ່ນການກັ່ນຕອງພຽງແຕ່ຄັ້ງດຽວ.

· --raw-input/-R:

ຢ່າວິເຄາະການປ້ອນຂໍ້ມູນເປັນ JSON. ແທນທີ່ຈະ, ແຕ່ລະແຖວຂອງຂໍ້ຄວາມຖືກສົ່ງກັບການກັ່ນຕອງເປັນ a
ສາຍ. ຖ້າລວມກັບ --slurp, ຫຼັງຈາກນັ້ນການປ້ອນຂໍ້ມູນທັງຫມົດຖືກສົ່ງກັບການກັ່ນຕອງເປັນ a
ສາຍດ່ຽວຍາວ.

· --ການປ້ອນຂໍ້ມູນ null/-n:

ບໍ່​ໄດ້​ອ່ານ​ຂໍ້​ມູນ​ໃດໆ​ທັງ​ຫມົດ​! ແທນທີ່ຈະ, ການກັ່ນຕອງແມ່ນດໍາເນີນການຄັ້ງດຽວ null ເປັນວັດສະດຸປ້ອນ.
ອັນນີ້ເປັນປະໂຫຍດເມື່ອໃຊ້ jq ເປັນເຄື່ອງຄິດເລກແບບງ່າຍໆ ຫຼືສ້າງຂໍ້ມູນ JSON ຈາກ
ຮອຍຂີດຂ່ວນ.

· --compact-output / -c:

ໂດຍຄ່າເລີ່ມຕົ້ນ, jq pretty-prints JSON output. ການນໍາໃຊ້ທາງເລືອກນີ້ຈະສົ່ງຜົນໃຫ້ຫຼາຍຂຶ້ນ
ຜົນຜະລິດທີ່ຫນາແຫນ້ນໂດຍການວາງແຕ່ລະ JSON ຢູ່ໃນເສັ້ນດຽວ.

· -- ແຖບ:

ໃຊ້ແຖບສຳລັບແຕ່ລະລະດັບການຫຍໍ້ໜ້າແທນທີ່ຈະເປັນສອງຍະຫວ່າງ.

· --ຫຍໍ້ໜ້າ n:

ໃຊ້ຈຳນວນຍະຫວ່າງທີ່ກຳນົດ (ບໍ່ເກີນ 8) ສຳລັບການຫຍໍ້ໜ້າ.

· --color-output / -C ແລະ --monochrome-output / -M:

ໂດຍຄ່າເລີ່ມຕົ້ນ, jq ສົ່ງອອກສີ JSON ຖ້າຂຽນໃສ່ເຄື່ອງຈ່າຍເງິນ. ທ່ານສາມາດບັງຄັບມັນ
ຜະລິດສີເຖິງແມ່ນວ່າການຂຽນໃສ່ທໍ່ຫຼືໄຟລ໌ໂດຍໃຊ້ -C, ແລະປິດການໃຊ້ງານສີດ້ວຍ -M.

· --ascii-ຜົນຜະລິດ / -a:

jq ປົກກະຕິແລ້ວອອກຈຸດລະຫັດທີ່ບໍ່ແມ່ນ ASCII Unicode ເປັນ UTF-8, ເຖິງແມ່ນວ່າການປ້ອນຂໍ້ມູນລະບຸໄວ້.
ພວກມັນເປັນລໍາດັບການຫລົບຫນີ (ເຊັ່ນ "\u03bc"). ການນໍາໃຊ້ທາງເລືອກນີ້, ທ່ານສາມາດບັງຄັບ jq ກັບ
ຜະລິດຜົນ ASCII ອັນບໍລິສຸດດ້ວຍທຸກຕົວລະຄອນທີ່ບໍ່ແມ່ນ ASCII ແທນທີ່ດ້ວຍຄ່າທຽບເທົ່າ
ລໍາດັບການຫລົບຫນີ.

· -- unbuffered

ລ້າງອອກຫຼັງຈາກແຕ່ລະວັດຖຸ JSON ຖືກພິມອອກ (ເປັນປະໂຫຍດຖ້າຫາກວ່າທ່ານກໍາລັງທໍ່ຊ້າ
ແຫຼ່ງຂໍ້ມູນເຂົ້າໄປໃນ jq ແລະທໍ່ຜົນຜະລິດ jq ຂອງບ່ອນອື່ນ).

· --sort-keys / -S:

ສົ່ງຂໍ້ມູນທົ່ງນາຂອງແຕ່ລະວັດຖຸດ້ວຍກະແຈໃນການຈັດຮຽງ.

· --raw-output / -r:

ດ້ວຍຕົວເລືອກນີ້, ຖ້າຜົນໄດ້ຮັບຂອງການກັ່ນຕອງແມ່ນສະຕຣິງ, ມັນຈະຖືກຂຽນໂດຍກົງ
ກັບຜົນຜະລິດມາດຕະຖານແທນທີ່ຈະຖືກຈັດຮູບແບບເປັນ JSON string ທີ່ມີວົງຢືມ. ນີ້ສາມາດ
ເປັນປະໂຫຍດສໍາລັບການເຮັດໃຫ້ການກັ່ນຕອງ jq ສົນທະນາກັບລະບົບທີ່ບໍ່ແມ່ນ JSON.

· -- ຜົນ​ຜະ​ລິດ​ເຂົ້າ​ຮ່ວມ​ / -j:

ຄື -r ແຕ່ jq ຈະບໍ່ພິມເສັ້ນໃຫມ່ຫຼັງຈາກແຕ່ລະຜົນຜະລິດ.

· -f ຊື່​ເອ​ກະ​ສານ / --ຈາກໄຟລ໌ ຊື່​ເອ​ກະ​ສານ:

ອ່ານຕົວກອງຈາກໄຟລ໌ແທນທີ່ຈະມາຈາກເສັ້ນຄໍາສັ່ງ, ເຊັ່ນ: ທາງເລືອກ awk's -f. ເຈົ້າ
ຍັງສາມາດໃຊ້ '#' ເພື່ອສ້າງຄຳເຫັນ.

· -Ldirectory / -L ລະບົບ:

ລ່ວງໜ້າ ລະບົບ ໄປຫາລາຍການຄົ້ນຫາສໍາລັບໂມດູນ. ຖ້າຕົວເລືອກນີ້ຖືກນໍາໃຊ້ແລ້ວບໍ່ມີ
ບັນຊີລາຍຊື່ການຊອກຫາທີ່ສ້າງຂຶ້ນແມ່ນຖືກນໍາໃຊ້. ເບິ່ງພາກສ່ວນກ່ຽວກັບໂມດູນຂ້າງລຸ່ມນີ້.

· -e / --ອອກຈາກສະຖານະ:

ຕັ້ງສະຖານະອອກຂອງ jq ເປັນ 0 ຖ້າຄ່າຜົນໄດ້ຮັບສຸດທ້າຍບໍ່ແມ່ນທັງສອງ ທີ່ບໍ່ຖືກຕ້ອງ neither null,
1 ຖ້າຄ່າຜົນຜະລິດສຸດທ້າຍແມ່ນຄືກັນ ທີ່ບໍ່ຖືກຕ້ອງ or null, ຫຼື 4 ຖ້າບໍ່ມີຜົນໄດ້ຮັບທີ່ຖືກຕ້ອງ
ຜະລິດ. ປົກກະຕິ jq ອອກຈາກ 2 ຖ້າມີບັນຫາການນໍາໃຊ້ຫຼືລະບົບຜິດພາດ, 3
ຖ້າມີຂໍ້ຜິດພາດໃນການລວບລວມໂປຼແກຼມ jq, ຫຼື 0 ຖ້າໂຄງການ jq ແລ່ນ.

· --arg ຊື່ ມູນຄ່າ:

ຕົວເລືອກນີ້ສົ່ງຄ່າໄປຫາໂຄງການ jq ເປັນຕົວແປທີ່ກໍານົດໄວ້ກ່ອນ. ຖ້າທ່ານແລ່ນ jq
ກັບ --arg ຟູ ພາທະນາຍຄວາມ, ຫຼັງຈາກນັ້ນ $foo ແມ່ນມີຢູ່ໃນໂຄງການແລະມີມູນຄ່າ "ບາ".
ໃຫ້ສັງເກດວ່າ ມູນຄ່າ ຈະຖືກປະຕິບັດເປັນສາຍເຊືອກ, ດັ່ງນັ້ນ --arg ຟູ 123 ຈະຜູກມັດ $foo to "123".

· --argjson ຊື່ JSON-text:

ຕົວເລືອກນີ້ສົ່ງຄ່າ JSON-ເຂົ້າລະຫັດໄປຫາໂຄງການ jq ເປັນຕົວແປທີ່ກໍານົດໄວ້ກ່ອນ. ຖ້າ
ເຈົ້າແລ່ນ jq ກັບ --argjson ຟູ 123, ຫຼັງຈາກນັ້ນ $foo ມີຢູ່ໃນໂຄງການແລະມີ
ມູນຄ່າ 123.

· --slurpfile variable-name ຊື່​ເອ​ກະ​ສານ:

ຕົວເລືອກນີ້ອ່ານຂໍ້ຄວາມ JSON ທັງໝົດໃນໄຟລ໌ທີ່ມີຊື່ ແລະຜູກມັດອາເຣຂອງ
ແຍກຄ່າ JSON ເປັນຕົວແປທົ່ວໂລກທີ່ໃຫ້ໄວ້. ຖ້າທ່ານແລ່ນ jq ກັບ --argfile ຟູ ພາທະນາຍຄວາມ,
ຫຼັງຈາກນັ້ນ $foo ມີຢູ່ໃນໂຄງການແລະມີ array ທີ່ອົງປະກອບທີ່ສອດຄ້ອງກັນ
ບົດເລື່ອງໃນໄຟລ໌ທີ່ມີຊື່ ພາທະນາຍຄວາມ.

· --argfile variable-name ຊື່​ເອ​ກະ​ສານ:

ຢ່າໃຊ້. ໃຊ້ --slurpfile ແທນທີ່ຈະເປັນ.

(ທາງເລືອກນີ້ແມ່ນຄ້າຍຄື --slurpfile, ແຕ່ເມື່ອໄຟລ໌ມີພຽງແຕ່ຂໍ້ຄວາມຫນຶ່ງ, ຫຼັງຈາກນັ້ນນັ້ນແມ່ນ
ໃຊ້ແລ້ວ, ອື່ນ ໆ array ຂອງບົດເລື່ອງແມ່ນໃຊ້ໃນ --slurpfile.)

· -- ການທົດສອບແລ່ນ [ຊື່​ເອ​ກະ​ສານ]:

ແລ່ນການທົດສອບໃນໄຟລ໌ທີ່ໃຫ້ ຫຼືການປ້ອນຂໍ້ມູນມາດຕະຖານ. ອັນນີ້ຕ້ອງເປັນທາງເລືອກສຸດທ້າຍທີ່ໃຫ້ມາ
ແລະບໍ່ເຄົາລົບທາງເລືອກກ່ອນຫນ້າທັງຫມົດ. ການປ້ອນຂໍ້ມູນປະກອບດ້ວຍແຖວຄຳເຫັນ, ຫວ່າງເປົ່າ
ເສັ້ນ, ແລະເສັ້ນໂຄງການປະຕິບັດຕາມຫນຶ່ງເສັ້ນ input, ເປັນຫຼາຍເສັ້ນຂອງຜົນຜະລິດເປັນ
ຄາດ​ວ່າ​ຈະ (ຫນຶ່ງ​ຕໍ່​ຜົນ​ຜະ​ລິດ​)​, ແລະ​ການ​ສິ້ນ​ສຸດ​ເສັ້ນ​ຫວ່າງ​ເປົ່າ​. ການທົດສອບຄວາມລົ້ມເຫຼວຂອງການລວບລວມ
ເລີ່ມຕົ້ນດ້ວຍແຖວທີ່ມີພຽງແຕ່ "%%FAIL", ຈາກນັ້ນແຖວທີ່ມີໂປຣແກມໄປ
ລວບລວມ, ຫຼັງຈາກນັ້ນເສັ້ນທີ່ມີຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດເພື່ອປຽບທຽບກັບຕົວຈິງ.

ໄດ້ຮັບການເຕືອນວ່າທາງເລືອກນີ້ສາມາດປ່ຽນແປງກັບຫຼັງ - ບໍ່ເຂົ້າກັນໄດ້.

BASIC FILTERS

.
ການກັ່ນຕອງທີ່ງ່າຍດາຍທີ່ສຸດ (ແລະຫນ້າສົນໃຈຫນ້ອຍທີ່ສຸດ) ແມ່ນ .. ນີ້ແມ່ນຕົວກອງທີ່ໃຊ້ເວລາຂອງມັນ
input ແລະຜະລິດມັນບໍ່ປ່ຽນແປງເປັນຜົນຜະລິດ.

ເນື່ອງຈາກວ່າ jq ໂດຍຄ່າເລີ່ມຕົ້ນ pretty-prints ຜົນຜະລິດທັງຫມົດ, ໂຄງການ trivial ນີ້ສາມາດເປັນວິທີການທີ່ເປັນປະໂຫຍດ
ການຈັດຮູບແບບຜົນຜະລິດ JSON ຈາກ, ເວົ້າວ່າ, curl.

jq ´.´
"ສະ​ບາຍ​ດີ​ຊາວ​ໂລກ!"
=> "ສະບາຍດີ, ໂລກ!"

.foo, .foo.bar
ງ່າຍທີ່ສຸດ ທີ່ເປັນປະໂຫຍດ ການກັ່ນຕອງແມ່ນ .foo. ເມື່ອໃຫ້ວັດຖຸ JSON (ວັດຈະນານຸກົມ aka ຫຼື hash) ເປັນ
ການປ້ອນຂໍ້ມູນ, ມັນຜະລິດຄ່າຢູ່ທີ່ປຸ່ມ "foo", ຫຼື null ຖ້າບໍ່ມີປະຈຸບັນ.

ຖ້າກະແຈມີຕົວອັກສອນພິເສດ, ທ່ານຈໍາເປັນຕ້ອງອ້ອມຮອບມັນດ້ວຍວົງຢືມສອງເທົ່າເຊັ່ນ
ນີ້: "foo$".

ການກັ່ນຕອງຂອງແບບຟອມ .foo.bar ເທົ່າກັບ .foo|.bar.

jq '.foo'
{"foo": 42, "bar": "ຂໍ້ມູນທີ່ຫນ້າສົນໃຈຫນ້ອຍ"}
=> 42

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

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

.foo?
ຄືກັນ .foo, ແຕ່ບໍ່ໄດ້ອອກເຖິງແມ່ນວ່າຄວາມຜິດພາດໃນເວລາທີ່ . ບໍ່ແມ່ນ array ຫຼືວັດຖຸ.

jq ´.foo?´
{"foo": 42, "bar": "ຂໍ້ມູນທີ່ຫນ້າສົນໃຈຫນ້ອຍ"}
=> 42

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

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

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

.[ ], .[2], [10:15]
ທ່ານຍັງສາມາດຊອກຫາຊ່ອງຂໍ້ມູນຂອງວັດຖຸໂດຍໃຊ້ syntax ເຊັ່ນ ["foo"] (.foo ຂ້າງເທິງແມ່ນ a
ສະບັບຫຍໍ້ຂອງເລື່ອງນີ້). ອັນນີ້ເຮັດວຽກສໍາລັບ arrays ເຊັ່ນກັນ, ຖ້າ key ເປັນຈໍານວນເຕັມ.
Arrays ແມ່ນເປັນສູນ (ເຊັ່ນ javascript), ດັ່ງນັ້ນ [2] ຕອບອົງປະກອບທີສາມຂອງອາເຣ.

ໄດ້ [10:15] syntax ສາມາດຖືກໃຊ້ເພື່ອສົ່ງຄືນ subarray ຂອງ array ຫຼື substring ຂອງ string.
array ກັບຄືນມາໂດຍ [10:15] ຈະມີຄວາມຍາວ 5, ປະກອບດ້ວຍອົງປະກອບຈາກດັດຊະນີ 10
(ລວມ) ກັບດັດຊະນີ 15 (ສະເພາະ). ດັດຊະນີທັງສອງອາດຈະເປັນລົບ (ໃນກໍລະນີໃດທີ່ມັນນັບ
ຖອຍຫຼັງຈາກທ້າຍຂອງອາເຣ), ຫຼືຖືກລະເວັ້ນ (ໃນກໍລະນີມັນຫມາຍເຖິງການເລີ່ມຕົ້ນ ຫຼື
ທ້າຍຂອງອາເຣ).

ໄດ້ [2] syntax ສາມາດໃຊ້ເພື່ອສົ່ງຄືນອົງປະກອບຢູ່ໃນດັດຊະນີທີ່ໃຫ້. ດັດຊະນີທາງລົບແມ່ນ
ອະ​ນຸ​ຍາດ​ໃຫ້​, ມີ -1 ອ້າງ​ອີງ​ເຖິງ​ອົງ​ປະ​ກອບ​ສຸດ​ທ້າຍ​, -2 ອ້າງ​ອີງ​ເຖິງ​ຕໍ່​ໄປ​ຫາ​ອົງ​ປະ​ກອບ​ສຸດ​ທ້າຍ​,
ແລະ​ອື່ນໆ.

ໄດ້ .foo syntax ໃຊ້ໄດ້ສະເພາະກັບປຸ່ມຕ່າງໆເຊັ່ນ: ກະແຈທີ່ເປັນຕົວອັກສອນທີ່ເປັນຕົວເລກ ແລະ ຕົວໜັງສືທັງໝົດ.
.[ ] ເຮັດວຽກກັບກະແຈທີ່ມີຕົວອັກສອນພິເສດເຊັ່ນ: ຈໍ້າສອງເມັດ ແລະຈຸດ. ສໍາລັບ
ຍົກຕົວຢ່າງ ["foo::bar"] ແລະ .["foo.bar"] ເຮັດວຽກໃນຂະນະທີ່ .foo::bar ແລະ .foo.bar ຈະບໍ່.

ໄດ້ ? "operator" ຍັງສາມາດຖືກນໍາໃຊ້ກັບຕົວປະຕິບັດການ slice, ໃນ [10:15]?, ເຊິ່ງຜົນໄດ້ຮັບ
ຄ່າທີ່ວັດສະດຸປ້ອນເຂົ້າສາມາດແຍກໄດ້.

jq ´.[0]´
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> {"name":"JSON", "ດີ":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

.[]
ຖ້າທ່ານໃຊ້ [index] syntax, ແຕ່ຍົກເວັ້ນດັດຊະນີທັງຫມົດ, ມັນຈະກັບຄືນມາ ທັງຫມົດ ຂອງ
ອົງປະກອບຂອງອາເຣ. ແລ່ນ .[] ດ້ວຍການປ້ອນຂໍ້ມູນ [1,2,3] ຈະຜະລິດຕົວເລກເປັນສາມ
ຜົນໄດ້ຮັບແຍກຕ່າງຫາກ, ແທນທີ່ຈະເປັນອາເຣດຽວ.

ທ່ານຍັງສາມາດໃຊ້ມັນຢູ່ໃນວັດຖຸ, ແລະມັນຈະສົ່ງຄືນຄ່າທັງຫມົດຂອງວັດຖຸ.

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

.[]?
ຄື .[], ແຕ່ບໍ່ມີຂໍ້ຜິດພາດຈະອອກມາຖ້າ . ບໍ່ແມ່ນ array ຫຼືວັດຖຸ.

,
ຖ້າສອງຕົວກອງຖືກແຍກອອກດ້ວຍເຄື່ອງໝາຍຈຸດ, ຫຼັງຈາກນັ້ນການປ້ອນຂໍ້ມູນຈະຖືກປ້ອນໃສ່ທັງສອງອັນ
ຈະເປັນຜົນຜະລິດຫຼາຍ: ທໍາອິດ, ທັງຫມົດຂອງຜົນຜະລິດທີ່ຜະລິດໂດຍການສະແດງອອກຊ້າຍ, ແລະ
ຫຼັງຈາກນັ້ນ, ຜົນຜະລິດທັງຫມົດທີ່ຜະລິດໂດຍສິດທິ. ສໍາລັບຕົວຢ່າງ, ການກັ່ນຕອງ .foo, . ຄາເຟ, ຜະລິດ
ທັງພາກສະຫນາມ "foo" ແລະ "bar" ພາກສະຫນາມເປັນຜົນຜະລິດແຍກຕ່າງຫາກ.

jq ´.foo, .bar´
{"foo": 42, "bar": "ອັນອື່ນ", "baz": true}
=> 42, "ອັນອື່ນ"

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

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

|
ການ | ຜູ້ປະຕິບັດການສົມທົບສອງຕົວກອງໂດຍການປ້ອນຜົນຜະລິດຂອງຫນຶ່ງທີ່ຢູ່ເບື້ອງຊ້າຍເຂົ້າໄປໃນ
ການປ້ອນຂໍ້ມູນຂອງອັນນຶ່ງຢູ່ເບື້ອງຂວາ. ມັນຂ້ອນຂ້າງຄືກັນກັບທໍ່ຂອງ Unix shell, ຖ້າ
ເຈົ້າຄຸ້ນເຄີຍກັບສິ່ງນັ້ນ.

ຖ້າອັນໜຶ່ງຢູ່ທາງຊ້າຍສ້າງຜົນໄດ້ຫຼາຍອັນ, ອັນໜຶ່ງຢູ່ເບື້ອງຂວາຈະຖືກດຳເນີນໄປ
ແຕ່ລະຜົນໄດ້ຮັບເຫຼົ່ານັ້ນ. ດັ່ງນັ້ນ, ການສະແດງອອກ .[] | .foo ດຶງຂໍ້ມູນ "foo" ພາກສະຫນາມຂອງແຕ່ລະຄົນ
ອົງປະກອບຂອງ array ການປ້ອນຂໍ້ມູນ.

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

TYPES ແລະ VALUES

jq ຮອງຮັບຊຸດຂໍ້ມູນປະເພດດຽວກັນກັບ JSON - ຕົວເລກ, ສະຕຣິງ, ບູລີນ, ອາເຣ,
ວັດຖຸ (ຊຶ່ງໃນ JSON-speak ແມ່ນ hashes ມີພຽງແຕ່ string keys), ແລະ "null".

Booleans, null, strings ແລະຕົວເລກຖືກຂຽນແບບດຽວກັນກັບ javascript. ຄືກັນກັບ
ທຸກສິ່ງທຸກຢ່າງອື່ນໃນ jq, ຄ່າທີ່ງ່າຍດາຍເຫຼົ່ານີ້ໃຊ້ເວລາການປ້ອນຂໍ້ມູນແລະຜະລິດຜົນຜະລິດ - 42 ເປັນ
ການສະແດງອອກ jq ທີ່ຖືກຕ້ອງທີ່ເອົາການປ້ອນຂໍ້ມູນ, ບໍ່ສົນໃຈມັນ, ແລະສົ່ງຄືນ 42 ແທນ.

Array ການກໍ່ສ້າງ - []
ເຊັ່ນດຽວກັນກັບ JSON, [] ຖືກນໍາໃຊ້ເພື່ອສ້າງ arrays, ເຊັ່ນໃນ [1,2,3]. ອົງປະກອບຂອງ array ສາມາດ
be any jq expression. ຜົນໄດ້ຮັບທັງຫມົດຂອງການສະແດງອອກທັງຫມົດແມ່ນເກັບກໍາ
ເຂົ້າໄປໃນອາເຣໃຫຍ່ອັນນຶ່ງ. ທ່ານສາມາດນໍາໃຊ້ມັນເພື່ອສ້າງ array ອອກຈາກປະລິມານທີ່ຮູ້ຈັກຂອງມູນຄ່າ
(as in [.foo, .bar, .baz]) ຫຼື "ເກັບກໍາ" ຜົນໄດ້ຮັບທັງຫມົດຂອງການກັ່ນຕອງເຂົ້າໄປໃນ array (ເປັນ
in [.items[].name])

ເມື່ອທ່ານເຂົ້າໃຈຕົວປະຕິບັດການ "," ທ່ານສາມາດເບິ່ງ syntax array ຂອງ jq ໃນທີ່ແຕກຕ່າງກັນ
ແສງສະຫວ່າງ: ການສະແດງອອກ [1,2,3] ບໍ່ໄດ້ໃຊ້ syntax ໃນຕົວສໍາລັບ arrays ທີ່ແຍກດ້ວຍເຄື່ອງໝາຍຈຸດ,
ແຕ່ແທນທີ່ຈະໃຊ້ [] operator (ເກັບກຳຜົນໄດ້ຮັບ) ໄປຫາ expression 1,2,3 (ເຊິ່ງ
ຜະລິດສາມຜົນໄດ້ຮັບທີ່ແຕກຕ່າງກັນ).

ຖ້າທ່ານມີຕົວກອງ X ທີ່ຜະລິດສີ່ຜົນໄດ້ຮັບ, ຫຼັງຈາກນັ້ນການສະແດງອອກ [X] ຈະຜະລິດເປັນ
ຜົນໄດ້ຮັບດຽວ, array ຂອງສີ່ອົງປະກອບ.

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

ຈຸດປະສົງ - {}
ເຊັ່ນດຽວກັນກັບ JSON, {} ແມ່ນ​ສໍາ​ລັບ​ການ​ກໍ່​ສ້າງ​ວັດ​ຖຸ (aka ຈະ​ນາ​ນຸ​ກົມ​ຫຼື hashes​)​, ເຊັ່ນ​ດຽວ​ກັນ​ກັບ​: {"a": 42,
"b": ສິບສາມ}.

ຖ້າກະແຈແມ່ນ "sensible" (ຕົວອັກສອນທັງຫມົດ), ຫຼັງຈາກນັ້ນວົງຢືມສາມາດຖືກປະໄວ້.
ຄ່າສາມາດເປັນຕົວສະແດງໃດກໍໄດ້ (ເຖິງແມ່ນວ່າທ່ານອາດຈະຈໍາເປັນຕ້ອງໄດ້ຫໍ່ມັນຢູ່ໃນວົງເລັບຖ້າມັນເປັນ
ອັນທີ່ສັບສົນ), ເຊິ່ງຖືກນຳໃຊ້ກັບການປ້ອນຂໍ້ມູນຂອງ {} expression (ຈື່ໄວ້ວ່າຕົວກອງທັງໝົດ
ມີ input ແລະ output).

{foo: .bar}

ຈະຜະລິດວັດຖຸ JSON {"foo": ສິບສາມ} ຖ້າໃຫ້ວັດຖຸ JSON {"bar":42, "baz":43}.
ທ່ານ​ສາ​ມາດ​ນໍາ​ໃຊ້​ນີ້​ເພື່ອ​ຄັດ​ເລືອກ​ເອົາ​ຊ່ອງ​ຂໍ້​ມູນ​ສະ​ເພາະ​ຂອງ​ວັດ​ຖຸ​: ຖ້າ​ຫາກ​ວ່າ​ການ​ປ້ອນ​ຂໍ້​ມູນ​ແມ່ນ​ວັດ​ຖຸ​ທີ່​ມີ​
ຊ່ອງຂໍ້ມູນ "ຜູ້ໃຊ້", "ຫົວຂໍ້", "id", ແລະ "ເນື້ອໃນ" ແລະທ່ານພຽງແຕ່ຕ້ອງການ "ຜູ້ໃຊ້" ແລະ "ຫົວຂໍ້", ທ່ານສາມາດເຮັດໄດ້
ຂຽນ

{user: .user, title: .title}

ເນື່ອງຈາກວ່າມັນເປັນເລື່ອງທໍາມະດາ, ມີ syntax ທາງລັດ: {ຜູ້ໃຊ້, ຫົວຂໍ້}.

ຖ້າຫນຶ່ງໃນສໍານວນສ້າງຜົນໄດ້ຮັບຫຼາຍ, ວັດຈະນານຸກົມຫຼາຍຈະເປັນ
ຜະລິດ. ຖ້າ​ຫາກ​ວ່າ​ການ​ປ້ອນ​ຂໍ້​ມູນ​

{"user":"stedolan","titles":["JQ Primer", "JQ ເພີ່ມເຕີມ"]}

ຫຼັງຈາກນັ້ນ, ການສະແດງອອກ

{ຜູ້ໃຊ້, ຫົວຂໍ້: .titles[]}

ຈະ​ຜະ​ລິດ​ສອງ​ຜົນ​ຜະ​ລິດ​:

{"user":"stedolan", "title": "JQ Primer"}
{"user":"stedolan", "title": "JQ ເພີ່ມເຕີມ"}

ການວາງວົງເລັບອ້ອມກະແຈຫມາຍຄວາມວ່າມັນຈະຖືກປະເມີນເປັນການສະແດງຜົນ. ກັບ
ການ​ປ້ອນ​ຂໍ້​ມູນ​ດຽວ​ກັນ​ກັບ​ຂ້າງ​ເທິງ​,

{.user): .titles}

ຜະລິດ

{"stedolan": ["JQ Primer", "JQ ເພີ່ມເຕີມ"]}

jq ´{ຜູ້ໃຊ້, ຫົວຂໍ້: .titles[]}´
{"user":"stedolan","titles":["JQ Primer", "JQ ເພີ່ມເຕີມ"]}
=> {"user":"stedolan", "title": "JQ Primer"}, {"user":"stedolan", "title": "JQ ເພີ່ມເຕີມ"}

jq ´{.ຜູ້ໃຊ້): .titles}´
{"user":"stedolan","titles":["JQ Primer", "JQ ເພີ່ມເຕີມ"]}
=> {"stedolan": ["JQ Primer", "JQ ເພີ່ມເຕີມ"]}

ອາຄານ ຜູ້ປະກອບການ ແລະ FUNCTIONS

ບາງຕົວປະຕິບັດການ jq (ຕົວຢ່າງ, +) ເຮັດສິ່ງທີ່ແຕກຕ່າງກັນຂຶ້ນກັບປະເພດຂອງຂອງເຂົາເຈົ້າ
arguments (arrays, ຕົວເລກ, ແລະອື່ນໆ). ຢ່າງໃດກໍຕາມ, jq ບໍ່ເຄີຍເຮັດການແປງປະເພດ implicit. ຖ້າ
ທ່ານພະຍາຍາມເພີ່ມສະຕຣິງໃສ່ວັດຖຸທີ່ເຈົ້າຈະໄດ້ຮັບຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດ ແລະບໍ່ມີຜົນໄດ້ຮັບ.

ນອກຈາກນັ້ນ - +
ຜູ້ປະຕິບັດການ + ໃຊ້ຕົວກອງສອງອັນ, ນຳໃຊ້ພວກມັນທັງສອງເຂົ້າໃນການປ້ອນຂໍ້ມູນດຽວກັນ, ແລະເພີ່ມ
ຜົນໄດ້ຮັບຮ່ວມກັນ. ສິ່ງທີ່ "ເພີ່ມ" ຫມາຍຄວາມວ່າແມ່ນຂຶ້ນກັບປະເພດທີ່ກ່ຽວຂ້ອງ:

· ຈໍານວນ ຖືກເພີ່ມໂດຍເລກຄະນິດສາດປົກກະຕິ.

· ອາເລ ໄດ້ຖືກເພີ່ມໂດຍການປະກອບເຂົ້າໃນອາເຣທີ່ໃຫຍ່ກວ່າ.

· Strings ໄດ້ຖືກເພີ່ມໂດຍການເຂົ້າຮ່ວມເຂົ້າໄປໃນສາຍທີ່ໃຫຍ່ກວ່າ.

· ຈຸດປະສົງ ຖືກເພີ່ມໂດຍການລວມເຂົ້າກັນ, ນັ້ນແມ່ນ, ໃສ່ຄູ່ຄີ-ຄ່າທັງໝົດຈາກທັງສອງ
ວັດຖຸເຂົ້າໄປໃນວັດຖຸລວມດຽວ. ຖ້າທັງສອງວັດຖຸມີຄ່າດຽວກັນ
ທີ່ສໍາຄັນ, ວັດຖຸຢູ່ເບື້ອງຂວາຂອງ + ຊະນະ. (ສໍາ​ລັບ​ການ​ລວມ recursive ໃຊ້​ * ຜູ້ປະກອບການ.)

null ສາມາດຖືກເພີ່ມໃສ່ຄ່າໃດນຶ່ງ, ແລະສົ່ງຄືນຄ່າອື່ນທີ່ບໍ່ປ່ຽນແປງ.

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

ການຫັກລົບ - -
ເຊັ່ນດຽວກັນກັບການລົບເລກຄະນິດສາດປົກກະຕິກ່ຽວກັບຕົວເລກ, the - operator ສາມາດໃຊ້ໃນ arrays
ເພື່ອເອົາການປະກົດຕົວທັງໝົດຂອງອົງປະກອບຂອງອາເຣທີສອງອອກຈາກ array ທໍາອິດ.

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

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

ການຄູນ, ພະແນກ, ໂມດູນ - *, /, ແລະ %
ຕົວປະຕິບັດການ infix ເຫຼົ່ານີ້ປະຕິບັດຕົວຕາມທີ່ຄາດໄວ້ເມື່ອມີສອງຕົວເລກ. ແບ່ງໂດຍສູນຍົກ
ຄວາມ​ຜິດ​ພາດ​. x % y ຄິດໄລ່ x ໂມດູໂລ y.

ການຄູນສະຕຣິງດ້ວຍຕົວເລກເຮັດໃຫ້ການລວມຕົວຂອງສະຕຣິງນັ້ນຫຼາຍ
ເວລາ. "x" * 0 ຜະລິດ null.

ການແບ່ງສະຕຣິງໂດຍອີກອັນໜຶ່ງແບ່ງຕົວທຳອິດໂດຍໃຊ້ຕົວທີສອງເປັນຕົວແຍກ.

ການຄູນສອງວັດຖຸຈະຮວມພວກມັນຊ້ຳກັນ: ອັນນີ້ເຮັດວຽກຄືກັບການບວກ ແຕ່ຖ້າທັງສອງ
ວັດຖຸມີຄ່າສໍາລັບລະຫັດດຽວກັນ, ແລະຄ່າແມ່ນວັດຖຸ, ທັງສອງຖືກລວມເຂົ້າກັນ
ກັບຍຸດທະສາດດຽວກັນ.

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

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

ຄວາມຍາວ
ຟັງຊັນ builtin ຄວາມຍາວ ໄດ້​ຮັບ​ຄວາມ​ຍາວ​ຂອງ​ປະ​ເພດ​ທີ່​ແຕກ​ຕ່າງ​ກັນ​ຂອງ​ຄ່າ​:

· ຄວາມ​ຍາວ​ຂອງ a string ແມ່ນຕົວເລກຂອງລະຫັດ Unicode ທີ່ມັນມີ (ເຊິ່ງຈະເປັນ
ຄືກັນກັບຄວາມຍາວທີ່ເຂົ້າລະຫັດ JSON ເປັນໄບຕ໌ ຖ້າມັນເປັນ ASCII ອັນບໍລິສຸດ).

· ຄວາມ​ຍາວ​ຂອງ​ການ​ array ແມ່ນຈໍານວນຂອງອົງປະກອບ.

· ຄວາມ​ຍາວ​ຂອງ​ການ​ ຈຸດ​ປະ​ສົງ ແມ່ນຈໍານວນຄູ່ຄີ-ຄ່າ.

· ຄວາມຍາວຂອງ null ແມ່ນສູນ.

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

ກະແຈ, keys_unsorted
ຟັງຊັນ builtin ໃຊ້, ເມື່ອໃຫ້ວັດຖຸໃດໜຶ່ງ, ສົ່ງຄືນກະແຈຂອງມັນໃນອາເຣ.

ກະແຈຖືກຈັດຮຽງ "ຕາມຕົວອັກສອນ", ໂດຍຄໍາສັ່ງຂອງລະຫັດ unicode. ນີ້ບໍ່ແມ່ນຄໍາສັ່ງ
ທີ່ເຮັດໃຫ້ຄວາມຮູ້ສຶກໂດຍສະເພາະໃນພາສາໃດນຶ່ງ, ແຕ່ວ່າທ່ານສາມາດນັບໄດ້ວ່າມັນເປັນ
ດຽວກັນກັບວັດຖຸສອງອັນທີ່ມີກະແຈຊຸດດຽວກັນ, ໂດຍບໍ່ຄໍານຶງເຖິງການຕັ້ງຄ່າທ້ອງຖິ່ນ.

ເມື່ອ​ໃດ​ ໃຊ້ ແມ່ນໃຫ້ array, ມັນຈະສົ່ງຄ່າ indices ທີ່ຖືກຕ້ອງສໍາລັບ array ນັ້ນ: integers
ຈາກ 0 ຫາ ຍາວ-1.

ໄດ້ keys_unsorted ຫນ້າ​ທີ່​ແມ່ນ​ຄື​ກັນ​ ໃຊ້, ແຕ່ຖ້າຫາກວ່າການປ້ອນຂໍ້ມູນເປັນວັດຖຸຫຼັງຈາກນັ້ນຄີ
ຈະບໍ່ຖືກຈັດຮຽງ, ແທນທີ່ຈະກະແຈປະມານປະມານຢູ່ໃນລໍາດັບແຊກ.

jq 'ກະແຈ'
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Foo", "abc", "abcd"]

jq 'ກະແຈ'
[42,3,35]
=> [0,1,2]

ມີ(ກະແຈ)
ຟັງຊັນ builtin ມີ ຕອບວ່າວັດຖຸປ້ອນເຂົ້າມີລະຫັດທີ່ໃຫ້, ຫຼືວັດສະດຸປ້ອນ
array ມີອົງປະກອບຢູ່ໃນດັດຊະນີທີ່ໃຫ້.

ມີ($key) ມີຜົນກະທົບຄືກັນກັບການກວດສອບວ່າ $key ແມ່ນສະມາຊິກຂອງ array ທີ່ສົ່ງຄືນ
by ໃຊ້, ເຖິງແມ່ນວ່າ ມີ ຈະໄວຂຶ້ນ.

jq ´map(has("foo"))´
[{"foo": 42}, {}]
=> [ຈິງ, ຜິດ]

jq 'ແຜນທີ່(ມີ(2)).
[[0,1], ["a","b","c"]]
=> [ບໍ່ຖືກຕ້ອງ, ຄວາມຈິງ]

in
ຟັງຊັນ builtin in ສົ່ງຄືນລະຫັດການປ້ອນຂໍ້ມູນຢູ່ໃນວັດຖຸທີ່ໃຫ້, ຫຼືດັດຊະນີການປ້ອນຂໍ້ມູນ
ສອດຄ້ອງກັບອົງປະກອບໃນອາເຣທີ່ໃຫ້. ມັນເປັນສິ່ງຈໍາເປັນ, ເປັນສະບັບປີ້ນກັບກັນຂອງ
ມີ.

jq ´.[] | in({"foo": 42})´
["foo", "ບາ"]
=> ຖືກ, ຜິດ

jq ´map(in([0,1]))´
[2, 0]
=> [ບໍ່ຖືກຕ້ອງ, ຄວາມຈິງ]

ເສັ້ນທາງ(path_expression)
ຜົນໄດ້ຮັບການເປັນຕົວແທນ array ຂອງ expression ເສັ້ນທາງທີ່ໃຫ້ຢູ່ໃນ .. ຜົນໄດ້ຮັບແມ່ນ array ຂອງ
ສະຕຣິງ (ກະແຈໃນວັດຖຸ 0 ແລະ/ຫຼືຕົວເລກ (ຕົວຊີ້ວັດອາເຣ.

ການສະແດງອອກທາງແມ່ນ jq ສະແດງອອກເຊັ່ນ .a, ແຕ່ຍັງ .[]. ມີສອງປະເພດຂອງເສັ້ນທາງ
ການສະແດງອອກ: ອັນທີ່ກົງກັນແທ້, ແລະອັນທີ່ບໍ່ສາມາດ. ຍົກ​ຕົວ​ຢ່າງ, .abc ເປັນ
ການສະແດງອອກເສັ້ນທາງກົງກັນທີ່ແນ່ນອນ, ໃນຂະນະທີ່ .a[].ຂ ບໍ່​ແມ່ນ.

ເສັ້ນທາງ(exact_path_expression) ຈະຜະລິດການເປັນຕົວແທນ array ຂອງການສະແດງອອກເສັ້ນທາງ
ເຖິງແມ່ນວ່າມັນບໍ່ມີຢູ່ໃນ ., ຖ້າ . is null ຫຼື array ຫຼືວັດຖຸ.

ເສັ້ນ​ທາງ ຈະຜະລິດການສະແດງ array ຂອງເສັ້ນທາງທີ່ກົງກັນ ຮູບແບບ ຖ້າຫາກວ່າ
ເສັ້ນທາງມີຢູ່ໃນ ..

ໃຫ້ສັງເກດວ່າການສະແດງອອກຂອງເສັ້ນທາງບໍ່ແຕກຕ່າງຈາກການສະແດງອອກປົກກະຕິ. ການສະແດງອອກ
ເສັ້ນທາງ (..|ເລືອກ(type=="boolean")) ສົ່ງອອກທຸກເສັ້ນທາງໄປຫາຄ່າ boolean ໃນ ., ແລະເທົ່ານັ້ນ
ເສັ້ນທາງເຫຼົ່ານັ້ນ.

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

jq ´[ເສັ້ນທາງ (..)]´
{"a":[{"b":1}]}
=> [[],["a"],["a",0],["a",0,"b"]]

del(path_expression)
ຟັງຊັນ builtin ໄດ້ ເອົາລະຫັດແລະຄ່າທີ່ສອດຄ້ອງກັນຂອງມັນອອກຈາກວັດຖຸ.

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

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

to_entries, from_entries, with_entries
ຟັງຊັນເຫຼົ່ານີ້ປ່ຽນລະຫວ່າງວັດຖຸ ແລະອາເຣຂອງຄູ່ຄີ-ຄ່າ. ຖ້າ to_entries
ແມ່ນຜ່ານວັດຖຸ, ຫຼັງຈາກນັ້ນສໍາລັບແຕ່ລະຄົນ k: v ການ​ເຂົ້າ​ໃນ​ການ​ປ້ອນ​ຂໍ້​ມູນ​, array ຜົນ​ຜະ​ລິດ​ປະ​ກອບ​ມີ​
{"ກະແຈ": k, "ຄຸນຄ່າ": v}.

ຈາກ_ລາຍການ ເຮັດການປ່ຽນໃຈເຫລື້ອມໃສກົງກັນຂ້າມ, ແລະ with_entries(foo) ແມ່ນສັ້ນ ສຳ ລັບ
to_entries | ແຜນທີ່(foo) | ຈາກ_ລາຍການ, ເປັນປະໂຫຍດສໍາລັບການດໍາເນີນການບາງຢ່າງກັບທຸກຄີແລະ
ຄຸນຄ່າຂອງວັດຖຸ. ຈາກ_ລາຍການ ຍອມຮັບລະຫັດ, ລະຫັດ, ຊື່, ມູນຄ່າແລະມູນຄ່າເປັນກະແຈ.

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

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

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

ເລືອກ(boolean_expression)
ຟັງຊັນ ເລືອກ(foo) ຜະລິດວັດສະດຸປ້ອນຂອງມັນບໍ່ປ່ຽນແປງຖ້າ ຟູ ກັບ​ຄືນ​ມາ​ເປັນ​ຄວາມ​ຈິງ​ສໍາ​ລັບ​ການ​ປ້ອນ​ຂໍ້​ມູນ​ນັ້ນ​,
ແລະບໍ່ມີຜົນຜະລິດໃດໆ.

ມັນເປັນປະໂຫຍດສໍາລັບການກັ່ນຕອງລາຍຊື່: [1,2,3] | ແຜນທີ່(ເລືອກ(. >= 2))) ຈະໃຫ້ທ່ານ [2,3].

jq ´map(ເລືອກ(>= 2))´
[1,5,3,0,7]
=> [5,3,7]

jq ´.[] | ເລືອກ.id == "ວິນາທີ")´
[{"id": "first", "val":1}, {"id":"second", "val":2}]
=> {"id": "ວິນາທີ", "val": 2}

arrays, ວັດຖຸ, ເປັນ​ໄປ​ໄດ້​, ບູລີນ, ຕົວເລກ, ປົກ​ກະ​ຕິ​, ຈຳກັດ, ສາຍ, nulls, ຄຸນຄ່າ,
ເກັດ
built-ins ເຫຼົ່ານີ້ເລືອກພຽງແຕ່ inputs ທີ່ເປັນ array, object, iterables (arrays ຫຼື.
objects), booleans, ຕົວເລກ, ຕົວເລກປົກກະຕິ, ຕົວເລກຈໍາກັດ, strings, null, non-null
ຄ່າ, ແລະ non-iteables, ຕາມລໍາດັບ.

jq ´.[]|ຕົວເລກ´
[[],{},1,foo",null,ຈິງ,false]
=> 1

ຫວ່າງເປົ່າ
ຫວ່າງເປົ່າ ບໍ່ມີຜົນຕອບແທນ. ບໍ່ມີເລີຍ. ບໍ່ແມ່ນແຕ່ null.

ມັນເປັນປະໂຫຍດໃນໂອກາດ. ເຈົ້າ​ຈະ​ຮູ້​ວ່າ​ທ່ານ​ຕ້ອງ​ການ​ມັນ :)

jq ´1, ຫວ່າງ, 2´
null
=> 1, 2

jq ´[1,2,ເປົ່າ,3]´
null
=> [1,2,3]

ຄວາມຜິດພາດ(ຂໍ້ຄວາມ)
ຜະລິດຄວາມຜິດພາດ, ຄືກັນກັບ .a ໃຊ້ກັບຄ່າອື່ນທີ່ບໍ່ແມ່ນ null ແລະວັດຖຸຈະ, ແຕ່
ດ້ວຍຂໍ້ຄວາມທີ່ໃຫ້ມາເປັນຄ່າຂອງຂໍ້ຜິດພາດ.

$__loc__
ຜະລິດວັດຖຸທີ່ມີປຸ່ມ "ໄຟລ໌" ແລະປຸ່ມ "ເສັ້ນ", ດ້ວຍຊື່ໄຟລ໌ແລະເລກແຖວ
ບ່ອນທີ່ $__loc__ ເກີດຂຶ້ນ, ເປັນຄ່າ.

jq ´ try error("\($__loc__)") ຈັບ ​​.´
null
=> "{\"file\":\" \",\"ເສັ້ນ\":1}"

ແຜນທີ່(x), map_values(x)
ສໍາລັບການກັ່ນຕອງໃດໆ x, ແຜນທີ່(x) ຈະແລ່ນຕົວກອງນັ້ນສໍາລັບແຕ່ລະອົງປະກອບຂອງ array input, ແລະ
ຜະລິດຜົນອອກມາເປັນອາເຣໃໝ່. ແຜນທີ່ (+1) ຈະເພີ່ມແຕ່ລະອົງປະກອບຂອງ array ຂອງ
ຈໍານວນ.

ເຊັ່ນດຽວກັນ, map_values(x) ຈະແລ່ນການກັ່ນຕອງນັ້ນສໍາລັບແຕ່ລະອົງປະກອບ, ແຕ່ມັນຈະສົ່ງຄືນ
ວັດຖຸເມື່ອວັດຖຸຖືກຜ່ານ.

ແຜນທີ່(x) ເທົ່າກັບ [.[] | x]. ໃນຄວາມເປັນຈິງ, ນີ້ແມ່ນວິທີທີ່ມັນຖືກກໍານົດ. ເຊັ່ນດຽວກັນ,
map_values(x) ຖືກກໍານົດວ່າເປັນ .[] |= x.

jq 'ແຜນທີ່(+1)'
[1,2,3]
=> [2,3,4]

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

ເສັ້ນ​ທາງ​, ເສັ້ນທາງ(node_filter), ເສັ້ນທາງໃບ
ເສັ້ນທາງ outputs ເສັ້ນທາງໄປຫາອົງປະກອບທັງຫມົດໃນ input ຂອງມັນ (ຍົກເວັ້ນມັນບໍ່ output ໄດ້
ບັນຊີລາຍຊື່ເປົ່າ, ເປັນຕົວແທນ . ຕົວຂອງມັນເອງ).

ເສັ້ນທາງ(f) ສົ່ງຜົນໃຫ້ເສັ້ນທາງໄປຫາຄ່າໃດໆກໍຕາມ f ເປັນຄວາມຈິງ. ນັ້ນ​ແມ່ນ, ເສັ້ນທາງ (ຕົວເລກ)
ສົ່ງຜົນໃຫ້ເສັ້ນທາງໄປຫາຄ່າຕົວເລກທັງໝົດ.

ເສັ້ນທາງໃບ ເປັນນາມແຝງຂອງ ເສັ້ນ​ທາງ; ເສັ້ນທາງໃບ is ບໍ່ເຫັນແກ່ຕົວ ແລະ​ຈະ​ຖືກ​ລົບ​ອອກ​ໃນ
ການປ່ອຍທີ່ສໍາຄັນຕໍ່ໄປ.

jq ´[ເສັ້ນທາງ]´
[1,[[],{"a":2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]

jq ´[ເສັ້ນທາງ(ສະຖິຕິ)]´
[1,[[],{"a":2}]]
=> [[0],[1,1,"a"]]

ເພີ່ມ
ຕົວກອງ ເພີ່ມ ໃຊ້ເວລາເປັນ input array, ແລະຜະລິດເປັນ output ອົງປະກອບຂອງ array
ເພີ່ມເຂົ້າກັນ. ອັນນີ້ອາດຈະໝາຍເຖິງການລວມ, ລວມກັນ ຫຼື ຮວມກັນ ຂຶ້ນກັບປະເພດຂອງ
ອົງປະກອບຂອງ array ການປ້ອນຂໍ້ມູນ - ກົດລະບຽບແມ່ນຄືກັນກັບທີ່ສໍາລັບ + ປະຕິບັດການ
(ອະທິບາຍຂ້າງເທິງ).

ຖ້າ input ເປັນ array ຫວ່າງເປົ່າ, ເພີ່ມ ກັບຄືນມາ null.

jq 'ຕື່ມ'
["a","b","c"]
=> "abc"

jq 'ຕື່ມ'
[1, 2, 3]
=> 6

jq 'ຕື່ມ'
[]
=> null

ໃດ, ໃດ (ເງື່ອນ​ໄຂ​)​, ໃດໆ (ເຄື່ອງກໍາເນີດ; ເງື່ອນໄຂ)
ຕົວກອງ ໃດ ໃຊ້ເວລາເປັນ input array ຂອງຄ່າ boolean, ແລະຜະລິດ ທີ່ແທ້ຈິງ ເປັນຜົນຜະລິດຖ້າຫາກວ່າ
ອົງປະກອບໃດນຶ່ງຂອງອາເຣແມ່ນ ທີ່ແທ້ຈິງ.

ຖ້າ input ເປັນ array ຫວ່າງເປົ່າ, ໃດ ກັບຄືນມາ ທີ່ບໍ່ຖືກຕ້ອງ.

ໄດ້ ໃດໆ (ເງື່ອນໄຂ) ແບບຟອມໃຊ້ເງື່ອນໄຂທີ່ໃຫ້ກັບອົງປະກອບຂອງ array ການປ້ອນຂໍ້ມູນ.

ໄດ້ ໃດໆ (ເຄື່ອງກໍາເນີດ; ເງື່ອນໄຂ) ແບບຟອມໃຊ້ເງື່ອນໄຂທີ່ໃຫ້ກັບຜົນໄດ້ຮັບທັງຫມົດຂອງ
ເຄື່ອງກໍາເນີດໄຟຟ້າໃຫ້.

jq 'ໃດ'
[ຈິງ, ຜິດ]
=> ຄວາມຈິງ

jq 'ໃດ'
[ຜິດ, ຜິດ]
=> ບໍ່ຖືກຕ້ອງ

jq 'ໃດ'
[]
=> ບໍ່ຖືກຕ້ອງ

ທັງ ໝົດ, ທັງ​ຫມົດ (ເງື່ອນ​ໄຂ​)​, ທັງ​ຫມົດ (ເຄື່ອງ​ຜະ​ລິດ​; ເງື່ອນໄຂ)
ຕົວກອງ ທັງຫມົດ ໃຊ້ເວລາເປັນ input array ຂອງຄ່າ boolean, ແລະຜະລິດ ທີ່ແທ້ຈິງ ເປັນຜົນຜະລິດຖ້າຫາກວ່າ
ອົງປະກອບທັງຫມົດຂອງ array ແມ່ນ ທີ່ແທ້ຈິງ.

ໄດ້ ທັງໝົດ(ສະພາບ) ແບບຟອມໃຊ້ເງື່ອນໄຂທີ່ໃຫ້ກັບອົງປະກອບຂອງ array ການປ້ອນຂໍ້ມູນ.

ໄດ້ ທັງ​ຫມົດ (ເຄື່ອງ​ຜະ​ລິດ​; ເງື່ອນໄຂ) ແບບຟອມໃຊ້ເງື່ອນໄຂທີ່ໃຫ້ກັບຜົນໄດ້ຮັບທັງຫມົດຂອງ
ເຄື່ອງກໍາເນີດໄຟຟ້າໃຫ້.

ຖ້າ input ເປັນ array ຫວ່າງເປົ່າ, ທັງຫມົດ ກັບຄືນມາ ທີ່ແທ້ຈິງ.

jq 'ທັງໝົດ'
[ຈິງ, ຜິດ]
=> ບໍ່ຖືກຕ້ອງ

jq 'ທັງໝົດ'
[ຈິງ, ຈິງ]
=> ຄວາມຈິງ

jq 'ທັງໝົດ'
[]
=> ຄວາມຈິງ

[ຕ້ອງການ 1.5] ແປ, ແປ(ຄວາມເລິກ)
ຕົວກອງ ແບນ ໃຊ້​ເວ​ລາ​ເປັນ​ການ​ປ້ອນ​ຂໍ້​ມູນ​ອາ​ເຣ​ຂອງ​ອາ​ເຣ​ຕິດ​ຕັ້ງ​, ແລະ​ຜະ​ລິດ​ອາ​ເຣ​ແປ​ໃນ​
ເຊິ່ງທຸກ array ພາຍໃນ array ຕົ້ນສະບັບໄດ້ຖືກແທນທີ່ recursively ໂດຍຄ່າຂອງພວກມັນ.
ທ່ານສາມາດຜ່ານການໂຕ້ຖຽງກັບມັນເພື່ອກໍານົດວິທີການຫຼາຍລະດັບຂອງຮັງທີ່ຈະແປ.

ແບນ(2​) ແມ່ນຄ້າຍຄື ແບນ, ແຕ່ພຽງແຕ່ສູງເຖິງສອງລະດັບເລິກ.

jq 'ແປ'
[1, [2], [[3]]]
=> [1, 2, 3]

jq ´ແບນ(1)´
[1, [2], [[3]]]
=> [1, 2, [3]]

jq 'ແປ'
[[]]
=> []

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

ຊ່ວງ(ສູງສຸດ), ຊ່ວງ(ຈາກ;ເຖິງ) ຊ່ວງ(ຈາກ;ເຖິງ;ໂດຍ)
ໄດ້ ລະດັບ function ຜະລິດລະດັບຂອງຕົວເລກ. ໄລຍະ(4;10) ຜະລິດ 6 ຕົວເລກ, ຈາກ 4
(ລວມ) ເຖິງ 10 (ສະເພາະ). ຕົວເລກແມ່ນຜະລິດເປັນຜົນຜະລິດແຍກຕ່າງຫາກ. ໃຊ້
[ຊ່ວງ(4;10)] ເພື່ອໃຫ້ໄດ້ຮັບໄລຍະເປັນ array.

ແບບຟອມການໂຕ້ແຍ້ງອັນດຽວສ້າງຕົວເລກຈາກ 0 ໄປຫາຕົວເລກທີ່ໃຫ້, ດ້ວຍການເພີ່ມຂຶ້ນ
1.

ຮູບແບບການໂຕ້ຖຽງທັງສອງສ້າງຕົວເລກຈາກ ຈາກ to ເກີນ ດ້ວຍການເພີ່ມຂຶ້ນ 1.

ຮູບແບບການໂຕ້ຖຽງສາມສ້າງຕົວເລກ ຈາກ to ເກີນ ດ້ວຍ​ການ​ເພີ່ມ​ຂຶ້ນ​ຂອງ by.

jq ´range(2;4)´
null
=> 2, 3

jq ´[range(2;4)]´
null
=> [2,3]

jq '[ລະດັບ(4)]´
null
=> [0,1,2,3]

jq ´[range(0;10;3)]´
null
=> [0,3,6,9]

jq ´[range(0;10;-1)]´
null
=> []

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

ຊັ້ນ
ໄດ້ ຊັ້ນ ຟັງຊັນສົ່ງຄືນພື້ນຂອງການປ້ອນຂໍ້ມູນຕົວເລກຂອງມັນ.

jq 'ຊັ້ນ'
3.14159
=> 3

sqrt
ໄດ້ sqrt ຟັງຊັນສົ່ງຄືນຮາກທີ່ສອງຂອງການປ້ອນຂໍ້ມູນຕົວເລກຂອງມັນ.

jq 'sqrt'
9
=> 3

ໂຕເລກ
ໄດ້ ໂຕເລກ ຟັງຊັນ parses input ຂອງຕົນເປັນຕົວເລກ. ມັນຈະປ່ຽນຮູບແບບທີ່ຖືກຕ້ອງ
ສະຕຣິງກັບຕົວເລກທຽບເທົ່າຂອງພວກມັນ, ປ່ອຍໃຫ້ຕົວເລກຢູ່ຄົນດຽວ, ແລະໃຫ້ຂໍ້ຜິດພາດກັບອັນອື່ນທັງໝົດ.
input

jq ´.[] | ໝາຍເລກ
[1, "1"]
=> 1, 1

ເຊືອກຜູກ
ໄດ້ ເຊືອກຜູກ ຟັງຊັນພິມການປ້ອນຂໍ້ມູນຂອງມັນເປັນສະຕຣິງ. Strings ຖືກປະໄວ້ບໍ່ປ່ຽນແປງ, ແລະທັງຫມົດ
ຄ່າອື່ນແມ່ນ JSON-ເຂົ້າລະຫັດ.

jq ´.[] | ເຊືອກຜູກ'
[1, "1", [1]]
=> "1", "1", "[1]"

ປະເພດ
ໄດ້ ປະເພດ function ສົ່ງຄືນປະເພດຂອງ argument ຂອງມັນເປັນ string, ເຊິ່ງເປັນຫນຶ່ງໃນ null,
boolean, ຕົວເລກ, string, array ຫຼື object.

jq 'ແຜນທີ່(ປະເພດ)'
[0, false, [], {}, null, "ສະບາຍດີ"]
=> ["number", "boolean", "array", "object", "null", "string"]

ອັນ​ເປັນ​ນິດ​, ນານ, ບໍ່ມີຂອບເຂດ, ອິ​ສ​ນານ​, ແມ່ນ​ມີ​ກໍາ​ນົດ​, ຜິດປົກກະຕິ
ການປະຕິບັດເລກເລກບາງອັນສາມາດໃຫ້ຄ່າ infinity ແລະ "ບໍ່ແມ່ນຕົວເລກ" (NaN). ໄດ້
ບໍ່ມີຂອບເຂດ ຜົນຕອບແທນ builtin ທີ່ແທ້ຈິງ ຖ້າການປ້ອນຂໍ້ມູນຂອງມັນບໍ່ມີຂອບເຂດ. ໄດ້ ອິສນານ ຜົນຕອບແທນ builtin ທີ່ແທ້ຈິງ
ຖ້າການປ້ອນຂໍ້ມູນຂອງມັນແມ່ນ NaN. ໄດ້ infinite buildin ສົ່ງຄືນຄ່າທີ່ບໍ່ມີຂອບເຂດໃນທາງບວກ. ໄດ້ nan
buildin ສົ່ງຄືນ NaN. ໄດ້ ຜິດປົກກະຕິ buildin ກັບຄືນມາເປັນຄວາມຈິງຖ້າຫາກວ່າ input ຂອງມັນແມ່ນຕົວເລກປົກກະຕິ.

ໃຫ້ສັງເກດວ່າການແບ່ງໂດຍສູນເຮັດໃຫ້ເກີດຄວາມຜິດພາດ.

ໃນປັດຈຸບັນການດໍາເນີນການເລກຄະນິດສ່ວນໃຫຍ່ທີ່ດໍາເນີນຢູ່ໃນ infinity, NaNs, ແລະ sub-normals ບໍ່ມີ
ຍົກ​ສູງ​ຄວາມ​ຜິດ​ພາດ​.

jq ´.[] | (ບໍ່ມີຂອບເຂດ * .) < 0´
[-1, 1]
=> ຖືກ, ຜິດ

jq ´infinite, ນານ | ປະເພດ'
null
=> "ຈໍານວນ", "ຈໍານວນ"

ຈັດລຽງ, sort_by(path_expression)
ໄດ້ ການຈັດລຽງ ຟັງຊັນຈັດຮຽງການປ້ອນຂໍ້ມູນຂອງມັນ, ເຊິ່ງຈະຕ້ອງເປັນອາເຣ. ຄ່າຖືກຈັດຮຽງຢູ່ໃນ
ຄໍາສັ່ງຕໍ່ໄປນີ້:

· null

· ທີ່ບໍ່ຖືກຕ້ອງ

· ທີ່ແທ້ຈິງ

·ຕົວເລກ

· ຊ່ອຍ​ແນ່​, ໃນ​ລໍາ​ດັບ​ຕົວ​ອັກ​ສອນ (ໂດຍ​ຄ່າ unicode codepoint​)

· arrays, ໃນຄໍາສັ່ງ lexical

· ວັດຖຸ

ການຈັດລໍາດັບວັດຖຸແມ່ນສັບສົນເລັກນ້ອຍ: ທໍາອິດພວກເຂົາປຽບທຽບໂດຍການປຽບທຽບຂອງພວກເຂົາ
ຊຸດຂອງກະແຈ (ເປັນ arrays ໃນລໍາດັບ), ແລະຖ້າຫາກວ່າຄີຂອງເຂົາເຈົ້າມີຄວາມເທົ່າທຽມກັນ, ຄ່າແມ່ນ.
ປຽບທຽບໂດຍຄີ.

ການຈັດລຽງ ອາດຈະຖືກໃຊ້ເພື່ອຈັດຮຽງຕາມຊ່ອງຂໍ້ມູນສະເພາະຂອງວັດຖຸໃດໜຶ່ງ, ຫຼືໂດຍການໃຊ້ຕົວກອງ jq ໃດນຶ່ງ.

sort_by(foo) ປຽບທຽບສອງອົງປະກອບໂດຍການປຽບທຽບຜົນໄດ້ຮັບຂອງ ຟູ ໃນແຕ່ລະອົງປະກອບ.

jq 'ຄັດ'
[8,3, null,6]
=> [null,3,6,8]

jq ´sort_by.foo)´
[{"foo":4, "bar":10}, {"foo":3, "bar":100}, {"foo":2, "bar":1}]
=> [{"foo":2, "bar":1}, {"foo":3, "bar":100}, {"foo":4, "bar":10}]

group_by(path_expression)
group_by.foo ໃຊ້ເວລາເປັນ input array, ຈັດກຸ່ມອົງປະກອບທີ່ມີຄືກັນ .foo ພາກສະຫນາມ
ເຂົ້າໄປໃນ array ແຍກຕ່າງຫາກ, ແລະຜະລິດທັງຫມົດຂອງ array ເຫຼົ່ານີ້ເປັນອົງປະກອບຂອງ array ຂະຫນາດໃຫຍ່,
ຈັດຮຽງຕາມມູນຄ່າຂອງ .foo ພາກສະຫນາມ.

ທຸກການສະແດງອອກ jq, ບໍ່ພຽງແຕ່ການເຂົ້າເຖິງພາກສະຫນາມ, ອາດຈະຖືກນໍາໃຊ້ແທນ .foo. ການຈັດລຽງ
ຄໍາສັ່ງແມ່ນຄືກັນກັບທີ່ອະທິບາຍໄວ້ໃນ ການຈັດລຽງ ຟັງຊັນຂ້າງເທິງ.

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_by(path_exp), max_by(path_exp)
ຊອກຫາອົງປະກອບຕໍາ່ສຸດ ຫຼືສູງສຸດຂອງອາເຣຂາເຂົ້າ.

ໄດ້ min_by(path_exp) ແລະ max_by(path_exp) ຫນ້າທີ່ອະນຸຍາດໃຫ້ທ່ານສາມາດກໍານົດສະເພາະ
ພາກສະຫນາມຫຼືຊັບສິນທີ່ຈະກວດສອບ, eg min_by(foo) ຊອກຫາວັດຖຸທີ່ມີຂະຫນາດນ້ອຍສຸດ ຟູ
ພາກສະຫນາມ.

jq 'ນາທີ'
[5,4,2,7]
=> 2

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

ເປັນ​ເອ​ກະ​ລັກ​, unique_by(path_exp)
ໄດ້ ເປັນເອກະລັກ function ໃຊ້ເວລາເປັນ input array ແລະຜະລິດ array ຂອງອົງປະກອບດຽວກັນ, in
ຮຽງລຳດັບ, ດ້ວຍການລຶບສິ່ງທີ່ຊ້ຳກັນອອກ.

ໄດ້ unique_by(path_exp) ຟັງຊັນຈະຮັກສາພຽງແຕ່ຫນຶ່ງອົງປະກອບສໍາລັບແຕ່ລະຄ່າທີ່ໄດ້ຮັບໂດຍ
ການ​ນໍາ​ໃຊ້​ການ​ໂຕ້​ຖຽງ​. ຄິດວ່າມັນເປັນການສ້າງ array ໂດຍການເອົາອົງປະກອບຫນຶ່ງອອກຈາກທຸກໆ
ກຸ່ມຜະລິດໂດຍ ກຸ່ມ.

jq 'ເປັນເອກະລັກ'
[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(ຄວາມຍາວ)´
["chunky", "bacon", "kitten", "cicada", "ຫນໍ່ໄມ້ຝລັ່ງ"]
=> ["bacon", "chunky", "ຫນໍ່ໄມ້ຝລັ່ງ"]

ຍ້ອນກັບ
ຟັງຊັນນີ້ປີ້ນກັບອາເຣ.

jq 'ປີ້ນກັບ'
[1,2,3,4]
=> [4,3,2,1]

ມີ(ອົງປະກອບ)
ຕົວກອງ ປະ​ກອບ​ດ້ວຍ (b​) ຈະຜະລິດເປັນຈິງຖ້າ b ຖືກບັນຈຸຢູ່ໃນວັດສະດຸປ້ອນ. ກ
string B ແມ່ນບັນຈຸຢູ່ໃນສະຕຣິງ A ຖ້າ B ແມ່ນສາຍຍ່ອຍຂອງ A. array B ແມ່ນບັນຈຸຢູ່ໃນ
ອາເຣ A ຖ້າອົງປະກອບທັງໝົດໃນ B ແມ່ນບັນຈຸຢູ່ໃນອົງປະກອບໃດນຶ່ງໃນ A. ວັດຖຸ B ແມ່ນ
ບັນຈຸຢູ່ໃນວັດຖຸ A ຖ້າທຸກຄ່າໃນ B ຖືກບັນຈຸຢູ່ໃນຄ່າໃນ A ກັບ the
ກະແຈດຽວກັນ. ປະເພດອື່ນໆທັງຫມົດແມ່ນສົມມຸດວ່າບັນຈຸຢູ່ໃນກັນແລະກັນຖ້າພວກເຂົາມີຄວາມເທົ່າທຽມກັນ.

jq 'ປະກອບດ້ວຍ("ແຖບ")'
"foobar"
=> ຄວາມຈິງ

jq ´ປະກອບດ້ວຍ(["baz", "bar"])´
["foobar", "foobaz", "blarp"]
=> ຄວາມຈິງ

jq ´ປະກອບດ້ວຍ(["bazzzzz", "bar"])´
["foobar", "foobaz", "blarp"]
=> ບໍ່ຖືກຕ້ອງ

jq ´ປະກອບດ້ວຍ({foo: 12, bar: [{barp: 12}]})´
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> ຄວາມຈິງ

jq ´ປະກອບດ້ວຍ({foo: 12, bar: [{barp: 15}]})´
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> ບໍ່ຖືກຕ້ອງ

ດັດ​ຊະ​ນີ
ສົ່ງຜົນໃຫ້ອາເຣທີ່ມີດັດຊະນີຢູ່ໃນ . ບ່ອນທີ່ s ເກີດຂຶ້ນ. ການປ້ອນຂໍ້ມູນອາດຈະເປັນ array, in
ກໍລະນີໃດຖ້າ s ເປັນ array ຫຼັງຈາກນັ້ນ indices output ຈະເປັນບ່ອນທີ່ອົງປະກອບທັງຫມົດໃນ .
ກົງກັບຂອງ s.

jq 'ດັດຊະນີ(", ")'
"a,b, cd, efg, hijk"
=> [3,7,12]

jq ´ດັດສະນີ(1)´
[0,1,2,1,3,1,4]
=> [1,3,5]

jq 'ດັດຊະນີ([1,2])´
[0,1,2,3,1,4,2,5,1,2,6,7]
=> [1,8]

ດັດຊະນີ rindex(s)
ຜົນໄດ້ຮັບດັດສະນີຂອງທໍາອິດ (ດັດຊະນີ) ຫຼືສຸດທ້າຍ (rindex) ການ​ເກີດ​ຂຶ້ນ​ຂອງ​ s ໃນການປ້ອນຂໍ້ມູນ.

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

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

ພາຍໃນ
ຕົວກອງ ພາຍໃນ(ຂ) ຈະຜະລິດເປັນຈິງຖ້າການປ້ອນຂໍ້ມູນຖືກບັນຈຸຢູ່ໃນ b. ມັນ
ແມ່ນ, ທີ່ສໍາຄັນ, ເປັນສະບັບປີ້ນກັບກັນຂອງ ປະກອບດ້ວຍ.

jq 'inside("foobar")´
"ບາ"
=> ຄວາມຈິງ

jq 'ພາຍໃນ(["foobar", "foobaz", "blarp"])´
["baz", "ບາ"]
=> ຄວາມຈິງ

jq 'ພາຍໃນ(["foobar", "foobaz", "blarp"])´
["bazzzzz", "bar"]
=> ບໍ່ຖືກຕ້ອງ

jq 'inside({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"foo": 12, "bar": [{"barp": 12}]}
=> ຄວາມຈິງ

jq 'inside({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"foo": 12, "bar": [{"barp": 15}]}
=> ບໍ່ຖືກຕ້ອງ

ເລີ່ມຕົ້ນດ້ວຍ(str)
Outputs ທີ່ແທ້ຈິງ ຖ້າ . ເລີ່ມຕົ້ນດ້ວຍ string argument ທີ່ໄດ້ໃຫ້.

jq ´[.[]|ເລີ່ມຕົ້ນດ້ວຍ("foo")]´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [ຜິດ, ຖືກ, ຜິດ, ຖືກ, ຜິດ]

ສິ້ນສຸດດ້ວຍ(str)
Outputs ທີ່ແທ້ຈິງ ຖ້າ . ສິ້ນສຸດດ້ວຍ string argument ທີ່ໄດ້ໃຫ້.

jq ´[.[]|endswith("foo")]´
["foobar", "barfoo"]
=> [ບໍ່ຖືກຕ້ອງ, ຄວາມຈິງ]

ການ​ປະ​ສົມ​, ການປະສົມປະສານ(n)
ສົ່ງຜົນການປະສົມທັງໝົດຂອງອົງປະກອບຂອງອາເຣໃນອາເຣ input. ຖ້າໃຫ້
ການໂຕ້ຖຽງ n, ມັນ outputs ການປະສົມທັງຫມົດຂອງ n ການຊໍ້າຄືນຂອງອາເຣການປ້ອນຂໍ້ມູນ.

jq 'ການປະສົມ'
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]

jq ´ການປະສົມປະສານ(2)´
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]

ltimstr(str)
ສົ່ງຜົນການປ້ອນຂໍ້ມູນຂອງມັນດ້ວຍສາຍຄຳນຳໜ້າທີ່ໃຫ້ອອກ, ຖ້າມັນເລີ່ມຕົ້ນດ້ວຍມັນ.

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

rtrimstr(str)
ສົ່ງຜົນການປ້ອນຂໍ້ມູນຂອງມັນດ້ວຍສາຍຄຳຕໍ່ທ້າຍທີ່ໃຫ້ອອກ, ຖ້າມັນຈົບລົງດ້ວຍມັນ.

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

ລະເບີດ
ປ່ຽນສະຕຣິງປ້ອນເຂົ້າເປັນອາເຣຂອງເລກລະຫັດຂອງສະຕຣິງ.

jq 'ລະເບີດ'
"foobar"
=> [102,111,111,98,97,114]

implode
ກົງກັນຂ້າມຂອງການລະເບີດ.

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

ແບ່ງປັນ
ແຍກສະຕຣິງປ້ອນເຂົ້າຢູ່ໃນອາກິວເມັນຕົວແຍກ.

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

ເຂົ້າຮ່ວມ
ເຂົ້າຮ່ວມອາເຣຂອງອົງປະກອບທີ່ໃຫ້ເປັນການປ້ອນຂໍ້ມູນ, ໂດຍໃຊ້ອາກິວເມັນເປັນຕົວຂັ້ນ. ມັນແມ່ນ
ປີ້ນກັບ ແບ່ງປັນ: ນັ້ນແມ່ນ, ແລ່ນ ແຍກ("foo") | ເຂົ້າຮ່ວມ ("foo") ເໜືອສາຍການປ້ອນຂໍ້ມູນໃດໆ
ກັບຄືນເວົ້າວ່າ string ປ້ອນ.

jq 'ເຂົ້າຮ່ວມ(", ")'
["a","b,c,d","e"]
=> "a, b, c, d, e"

ascii_downcase, ascii_upcase
ປ່ອຍສຳເນົາຂອງສະຕຣິງການປ້ອນຂໍ້ມູນດ້ວຍຕົວໜັງສືຂອງມັນ (az ແລະ AZ) ປ່ຽນເປັນ
ກໍ​ລະ​ນີ​ທີ່​ລະ​ບຸ​ໄວ້​.

while(cond; ປັບປຸງ)
ໄດ້ while(cond; ປັບປຸງ) ຟັງຊັນອະນຸຍາດໃຫ້ທ່ານໃຊ້ການອັບເດດຫຼາຍຄັ້ງຕໍ່ . ຈົນກ່ວາ ຂົ້ນ
ແມ່ນບໍ່ຖືກຕ້ອງ.

ໃຫ້ສັງເກດວ່າ while(cond; ປັບປຸງ) ຖືກກໍານົດພາຍໃນເປັນຟັງຊັນ jq recursive. ຊໍ້າຄືນ
ໂທພາຍໃນ ໃນຂະນະທີ່ ຈະບໍ່ບໍລິໂພກຄວາມຊົງຈໍາເພີ່ມເຕີມຖ້າຫາກວ່າ ການປັບປຸງ ຜະ​ລິດ​ໄດ້​ຫຼາຍ​ທີ່​ສຸດ​ຫນຶ່ງ​
ຜົນຜະລິດສໍາລັບການປ້ອນຂໍ້ມູນແຕ່ລະຄົນ. ເບິ່ງຫົວຂໍ້ຂັ້ນສູງຂ້າງລຸ່ມນີ້.

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

ຈົນກ່ວາ (cond; ຕໍ່ໄປ)
ໄດ້ ຈົນກ່ວາ (cond; ຕໍ່ໄປ) ຟັງຊັນອະນຸຍາດໃຫ້ທ່ານໃຊ້ການສະແດງອອກເລື້ອຍໆ ຕໍ່ໄປ,
ໃນເບື້ອງຕົ້ນ . ຫຼັງຈາກນັ້ນ, ຜົນຜະລິດຂອງຕົນເອງ, ຈົນກ່ວາ ຂົ້ນ ເປັນຄວາມຈິງ. ສໍາລັບຕົວຢ່າງ, ນີ້ສາມາດຖືກນໍາໃຊ້
ເພື່ອປະຕິບັດຫນ້າທີ່ factorial (ເບິ່ງຂ້າງລຸ່ມນີ້).

ໃຫ້ສັງເກດວ່າ ຈົນກ່ວາ (cond; ຕໍ່ໄປ) ຖືກກໍານົດພາຍໃນເປັນຟັງຊັນ jq recursive. ຊໍ້າຄືນ
ໂທພາຍໃນ ຈົນກ່ວາ() ຈະບໍ່ບໍລິໂພກຄວາມຊົງຈໍາເພີ່ມເຕີມຖ້າຫາກວ່າ ຕໍ່ໄປ ຜະ​ລິດ​ໄດ້​ຫຼາຍ​ທີ່​ສຸດ​ຫນຶ່ງ​
ຜົນຜະລິດສໍາລັບການປ້ອນຂໍ້ມູນແຕ່ລະຄົນ. ເບິ່ງຫົວຂໍ້ຂັ້ນສູງຂ້າງລຸ່ມນີ້.

jq ´[.,1]|ຈົນກ່ວາ(.[0]< 1; [.[0] - 1,.[1] *.[0]])|.[1]´
4
=> 24

recurse(f), ຊໍ້າຄືນ, recurse(f; ສະພາບ), recurse_down
ໄດ້ ຊໍ້າຄືນ(f) function ອະນຸຍາດໃຫ້ທ່ານສາມາດຄົ້ນຫາໂດຍຜ່ານໂຄງສ້າງ recursive, ແລະສະກັດ
ຂໍ້ມູນທີ່ຫນ້າສົນໃຈຈາກທຸກລະດັບ. ສົມມຸດວ່າຂໍ້ມູນຂອງທ່ານເປັນຕົວແທນຂອງລະບົບໄຟລ໌:

{"name": "/", "ເດັກນ້ອຍ": [
{"ຊື່": "/ ຖັງ", "ເດັກນ້ອຍ": [
{"ຊື່": "/bin/ls" , " ເດັກນ້ອຍ ": []},
{"ຊື່": "/ ຖັງ / sh" , " ເດັກນ້ອຍ ": []}]},
{"ຊື່": "/ ເຮືອນ", "ເດັກນ້ອຍ": [
{"name": "/home/stephen", "ເດັກນ້ອຍ": [
{"name": "/home/stephen/jq", "ເດັກນ້ອຍ": []}]}]}]}

ຕອນນີ້ສົມມຸດວ່າທ່ານຕ້ອງການສະກັດຊື່ໄຟລ໌ທັງຫມົດທີ່ມີຢູ່. ທ່ານ​ຈໍາ​ເປັນ​ຕ້ອງ​ໄດ້​ຮັບ​ ຊື່,
.ເດັກນ້ອຍ[].ຊື່, .children[].children[].ຊື່, ແລະອື່ນໆ. ທ່ານສາມາດເຮັດໄດ້ດ້ວຍ:

recurse(ເດັກນ້ອຍ[]) | .ຊື່

ເມື່ອຖືກເອີ້ນໂດຍບໍ່ມີການໂຕ້ຖຽງ, ພະຍາບານ ເທົ່າກັບ ຊໍ້າຄືນ(.[]?).

ຊໍ້າຄືນ(f) ແມ່ນຄືກັນກັບ recurse(f; . != null) ແລະສາມາດນໍາໃຊ້ໄດ້ໂດຍບໍ່ມີການກັງວົນກ່ຽວກັບ
ຄວາມເລິກ recursion.

recurse(f; ເງື່ອນໄຂ) ແມ່ນເຄື່ອງປັ່ນໄຟທີ່ເລີ່ມຕົ້ນໂດຍການປ່ອຍອອກມາ. ແລະຫຼັງຈາກນັ້ນ emits ແລະເຮັດໃຫ້ການ
.|f, .|f|f, .|f|f|f, ... ຕາບໃດທີ່ຄ່າທີ່ຄຳນວນໄດ້ຕອບສະໜອງເງື່ອນໄຂ. ສໍາລັບ
ຕົວຢ່າງ, ເພື່ອສ້າງຈໍານວນຈໍານວນທັງຫມົດ, ຢ່າງຫນ້ອຍໃນຫຼັກການ, ຫນຶ່ງສາມາດຂຽນ recurse(+1;
ຈິງ).

ສໍາລັບເຫດຜົນດ້ານມໍລະດົກ, recurse_down ມີຢູ່ໃນນາມແຝງກັບການໂທ ພະຍາບານ ໂດຍບໍ່ມີການໂຕ້ຖຽງ.
ນາມແຝງນີ້ຖືກພິຈາລະນາ ບໍ່ເຫັນແກ່ຕົວ ແລະຈະຖືກໂຍກຍ້າຍອອກໃນການປ່ອຍທີ່ສໍາຄັນຕໍ່ໄປ.

ການໂທ recursive ໃນ ພະຍາບານ ຈະບໍ່ໃຊ້ຫນ່ວຍຄວາມຈໍາເພີ່ມເຕີມທຸກຄັ້ງ f ຜະລິດຢູ່
ຜົນຜະລິດດຽວສ່ວນໃຫຍ່ສໍາລັບແຕ່ລະວັດສະດຸປ້ອນ.

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

jq 'ຊ້ຳ'
{"a":0,b":[1]}
=> {"a":0,"b":[1]}, 0, [1], 1

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

..
ມືສັ້ນສໍາລັບ ພະຍາບານ ໂດຍບໍ່ມີການໂຕ້ຖຽງ. ນີ້ມີຈຸດປະສົງເພື່ອຄ້າຍຄືກັບ XPath //
ຜູ້ປະກອບການ. ໃຫ້ສັງເກດວ່າ ..ກ ບໍ່ເຮັດວຽກ; ໃຊ້ ..|ກ ແທນ. ໃນຕົວຢ່າງຂ້າງລຸ່ມນີ້ພວກເຮົາໃຊ້
..|.ກ? ເພື່ອຊອກຫາຄ່າທັງຫມົດຂອງປຸ່ມວັດຖຸ "a" ໃນວັດຖຸໃດໆທີ່ພົບເຫັນ "ຂ້າງລຸ່ມນີ້" ..

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

ປະມານ
ສົ່ງອອກວັດຖຸທີ່ເປັນຕົວແທນຂອງສະພາບແວດລ້ອມ jq.

jq 'env.PAGER'
null
=> "ຫນ້ອຍ"

ຫັນປ່ຽນ
Transpose a jagged matrix (ອາເຣຂອງ array). ແຖວແມ່ນ padded ກັບ nulls ດັ່ງນັ້ນ
ຜົນໄດ້ຮັບແມ່ນຮູບສີ່ຫລ່ຽມສະເຫມີ.

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

ຄົ້ນຫາ(x)
bsearch(x) ດໍາເນີນການຄົ້ນຫາຄູ່ສໍາລັບ x ໃນ array input. ຖ້າການປ້ອນຂໍ້ມູນຖືກຈັດຮຽງແລະ
ມີ x, ຫຼັງຈາກນັ້ນ bsearch(x) ຈະສົ່ງຄືນດັດຊະນີຂອງມັນຢູ່ໃນອາເຣ; ຖ້າບໍ່ດັ່ງນັ້ນ, ຖ້າ array ແມ່ນ
ຈັດຮຽງ, ມັນຈະກັບຄືນມາ (-1 - ix) ບ່ອນທີ່ ix ເປັນຈຸດແຊກທີ່ array ຈະ.
ຍັງຖືກຈັດຮຽງຫຼັງຈາກການແຊກຂອງ x ຢູ່ ix. ຖ້າ Array ບໍ່ໄດ້ຖືກຈັດຮຽງ, bsearch(x)
ຈະສົ່ງຄ່າຈຳນວນເຕັມທີ່ອາດຈະບໍ່ສົນໃຈ.

jq ´ຄົ້ນຫາ(0)´
[0,1]
=> 0

jq ´ຄົ້ນຫາ(0)´
[1,2,3]
=> -1

jq ´ຄົ້ນຫາ(4) ເປັນ $ix | ຖ້າ $ix < 0 ແລ້ວ .[-(1+$ix)] = 4 ອື່ນ . ຈົບ'
[1,2,3]
=> [1,2,3,4]

string interpolation ທີ່ - \(foo)
ພາຍໃນສະຕຣິງ, ທ່ານສາມາດໃສ່ການສະແດງອອກພາຍໃນ paren ຫຼັງຈາກ backslash. ບໍ່ວ່າ
ການສະແດງຜົນຕອບແທນຈະຖືກ interpolated ເຂົ້າໄປໃນສະຕຣິງ.

jq ´"ການປ້ອນຂໍ້ມູນແມ່ນ \.), ເຊິ່ງແມ່ນໜຶ່ງໜ້ອຍກວ່າ \(+1)"´
42
=> "ການປ້ອນຂໍ້ມູນແມ່ນ 42, ເຊິ່ງແມ່ນໜຶ່ງໜ້ອຍກວ່າ 43"

ປ່ຽນແປງ ໄປ/ຈາກ JSON
ໄດ້ ໂທຊັນ ແລະ ຈາກjson buildins dump ຄ່າເປັນຂໍ້ຄວາມ JSON ຫຼືແຍກຂໍ້ຄວາມ JSON ເປັນ
ຄຸນຄ່າ, ຕາມລໍາດັບ. ພູສັນທີ່ສ້າງຂຶ້ນແຕກຕ່າງຈາກ tostring ໃນການກັບຄືນ tostring ນັ້ນ
strings unmodified, ໃນຂະນະທີ່ toson encodes strings ເປັນ JSON strings.

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

ຮູບແບບ strings ແລະ ຫນີ
ໄດ້ @foo syntax ຖືກນໍາໃຊ້ເພື່ອຈັດຮູບແບບແລະຫນີ strings, ເຊິ່ງເປັນປະໂຫຍດສໍາລັບການສ້າງ URLs,
ເອກະສານໃນພາສາເຊັ່ນ HTML ຫຼື XML, ແລະອື່ນໆ. @foo ສາມາດໃຊ້ເປັນຕົວກອງໄດ້
ຂອງຕົນເອງ, ການຫລົບຫນີທີ່ເປັນໄປໄດ້ແມ່ນ:

@ຂໍ້​ຄວາມ:

ໂທຫາເຄືອຂ່າຍ ເຊືອກຜູກ, ເບິ່ງຫນ້າທີ່ສໍາລັບລາຍລະອຽດ.

@json:

Serializes ການປ້ອນຂໍ້ມູນເປັນ JSON.

@html:

ນຳໃຊ້ HTML/XML escaping, ໂດຍການສ້າງແຜນທີ່ຕົວອັກສອນ <>&´" ກັບ​ຫົວ​ຫນ່ວຍ​ຂອງ​ເຂົາ​ເຈົ້າ​
ທຽບເທົ່າ <, >, ,, ', ".

@uri:

ນຳໃຊ້ການເຂົ້າລະຫັດເປັນເປີເຊັນ, ໂດຍການສ້າງແຜນທີ່ຕົວອັກສອນ URI ທີ່ສະຫງວນໄວ້ທັງໝົດໃສ່ a %XX ລໍາດັບ.

@csv:

ການປ້ອນຂໍ້ມູນຕ້ອງເປັນ array, ແລະມັນຖືກສະແດງເປັນ CSV ດ້ວຍວົງຢືມຄູ່
strings, ແລະວົງຢືມຫນີໄປໂດຍການຄ້າງຫ້ອງ.

@tsv:

ການປ້ອນຂໍ້ມູນຕ້ອງເປັນອາເຣ, ແລະມັນຈະຖືກສະແດງເປັນ TSV (ຄ່າທີ່ແຍກແທັບແທັບ). ແຕ່ລະ
array input ຈະຖືກພິມອອກເປັນແຖວດຽວ. ຊ່ອງຂໍ້ມູນຖືກແຍກອອກໂດຍແຖບດຽວ
(ascii 0x09). ປ້ອນ​ຕົວ​ອັກ​ສອນ​ເສັ້ນ​ຟີດ (ascii 0x0ກ), carriage-return (ascii
0x0d), tab (ascii 0x09) ແລະ backslash (ascii ຂະ ໜາດ 0x5c) ຈະ​ໄດ້​ຮັບ​ຜົນ​ຜະ​ລິດ​ເປັນ escape​
ລໍາດັບ \n, \r, \t, \\ ຕາມລໍາດັບ.

@sh:

ການປ້ອນຂໍ້ມູນຖືກຫລົບໜີ ເໝາະສຳລັບໃຊ້ໃນແຖວຄຳສັ່ງສຳລັບ POSIX shell. ຖ້າ
input ເປັນ array, output ຈະເປັນຊຸດຂອງ space-srings ແຍກຕ່າງຫາກ.

@base64:

ການປ້ອນຂໍ້ມູນຖືກປ່ຽນເປັນ base64 ຕາມທີ່ລະບຸໄວ້ໂດຍ RFC 4648.

syntax ນີ້ສາມາດຖືກລວມເຂົ້າກັບ string interpolation ໃນທາງທີ່ເປັນປະໂຫຍດ. ທ່ານສາມາດປະຕິບັດຕາມ a
@foo ໂທເຄັນທີ່ມີຕົວໜັງສືສະຕຣິງ. ເນື້ອໃນຂອງຕົວໜັງສືຈະ ບໍ່ ຖືກ​ຫລົບ​ຫນີ​.
ແນວໃດກໍ່ຕາມ, ການແຊກແຊງທັງໝົດທີ່ສ້າງຂຶ້ນພາຍໃນຕົວໜັງສືນັ້ນຈະຖືກຫລົບໜີ. ຕົວ​ຢ່າງ,

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

ຈະຜະລິດຜົນຜະລິດຕໍ່ໄປນີ້ສໍາລັບການປ້ອນຂໍ້ມູນ {"search":"ຫຍັງ is jq?"}:

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

ໃຫ້ສັງເກດວ່າເຄື່ອງຕັດ, ເຄື່ອງຫມາຍຄໍາຖາມ, ແລະອື່ນໆໃນ URL ບໍ່ໄດ້ຖືກຫລົບຫນີ, ຍ້ອນວ່າພວກເຂົາເປັນສ່ວນຫນຶ່ງ
ຂອງ string literal.

jq '@html'
"ນີ້ເຮັດວຽກຖ້າ x < y"
=> "ນີ້ເຮັດວຽກຖ້າ x < y"

jq ´@sh "echo \.)"´
"O'Hara's Ale"
=> "ສະທ້ອນ 'O'\\'Hara's Ale'

ວັນ
jq ສະຫນອງບາງຫນ້າທີ່ຈັດການວັນທີພື້ນຖານ, ມີລະດັບສູງແລະລະດັບຕ່ໍາ
ເຄື່ອງກໍ່ສ້າງ. ໃນທຸກກໍລະນີ buildins ເຫຼົ່ານີ້ຈັດການກັບເວລາໃນ UTC ເທົ່ານັ້ນ.

ໄດ້ ຈາກdateiso8601 builtin parses datetimes ໃນຮູບແບບ ISO 8601 ເປັນຈໍານວນວິນາທີ
ຕັ້ງແຕ່ຍຸກ Unix (1970-01-01T00:00:00Z). ໄດ້ ວັນ​ທີ 8601 buildin ເຮັດ inverse ໄດ້.

ໄດ້ ເລີ່ມແຕ່ວັນທີ builtin parses datetime strings. ໃນປັດຈຸບັນ ເລີ່ມແຕ່ວັນທີ ຮອງຮັບ ISO 8601 ເທົ່ານັ້ນ
datetime strings, ແຕ່ໃນອະນາຄົດມັນຈະພະຍາຍາມວິເຄາະສະຕຣິງ datetime ຕື່ມອີກ
ຮູບແບບຕ່າງໆ.

ໄດ້ ມື້ນີ້ buildin ແມ່ນນາມແຝງສໍາລັບ ວັນ​ທີ 8601.

ໄດ້ ໃນປັດຈຸບັນ builtin ໃຫ້ຜົນໄດ້ຮັບຂອງເວລາປະຈຸບັນ, ເປັນວິນາທີນັບຕັ້ງແຕ່ຍຸກ Unix.

ການໂຕ້ຕອບ jq ລະດັບຕໍ່າກັບຟັງຊັນເວລາຂອງ C-library ແມ່ນສະຫນອງໃຫ້: strptime,
ເວລາຕໍ່ເວລາ, mktime, ແລະ gmtime. ອ້າງອີງເຖິງເອກະສານຂອງລະບົບການດຳເນີນງານຂອງເຈົ້າສຳລັບ
ຮູບແບບສະຕຣິງທີ່ໃຊ້ໂດຍ strptime ແລະ ເວລາຕໍ່ເວລາ. ຫມາຍເຫດ: ເຫຼົ່ານີ້ບໍ່ຈໍາເປັນຕ້ອງມີຄວາມຫມັ້ນຄົງ
ການໂຕ້ຕອບໃນ jq, ໂດຍສະເພາະກັບການທໍາງານຂອງທ້ອງຖິ່ນຂອງພວກເຂົາ.

ໄດ້ gmtime buildin ໃຊ້ຈໍານວນວິນາທີນັບຕັ້ງແຕ່ຍຸກ Unix ແລະຜົນໄດ້ຮັບ "ແຕກຫັກ
down time" ການ​ເປັນ​ຕົວ​ແທນ​ຂອງ​ເວ​ລາ​ເປັນ array ຂອງ​ຕົວ​ເລກ​ທີ່​ເປັນ​ຕົວ​ແທນ (ໃນ​ລໍາ​ດັບ​ນີ້): the
ປີ, ເດືອນ (ຕາມສູນ), ວັນຂອງເດືອນ, ຊົ່ວໂມງຂອງມື້, ນາທີຂອງ
ຊົ່ວໂມງ, ທີສອງຂອງນາທີ, ມື້ຂອງອາທິດ, ແລະມື້ຂອງປີ - ທັງຫມົດ
ອີງ​ໃສ່​ອັນ​ດຽວ​ເວັ້ນ​ເສຍ​ແຕ່​ໄດ້​ກ່າວ​ເປັນ​ຢ່າງ​ອື່ນ​.

ໄດ້ mktime buildin ໃຊ້ "ເວລາທີ່ແຕກຫັກ" ການສະແດງຜົນຂອງເວລາໂດຍ gmtime
ແລະ strptime.

ໄດ້ strptime(fmt) buildin parses input strings matching the fmt ການໂຕ້ຖຽງ. ຜົນຜະລິດແມ່ນຢູ່ໃນ
ການສະແດງ "ເວລາທີ່ແຕກຫັກ" ທີ່ບໍລິໂພກໂດຍ gmtime ແລະຜົນຜະລິດໂດຍ mktime.

ໄດ້ srftime(fmt) buildin ຮູບແບບທີ່ໃຊ້ເວລາກັບຮູບແບບທີ່ໃຫ້.

ຮູບແບບສະຕຣິງສໍາລັບ strptime ແລະ ເວລາຕໍ່ເວລາ ໄດ້ຖືກອະທິບາຍໄວ້ໃນຫ້ອງສະຫມຸດ C ປົກກະຕິ
ເອກະສານ. ສະຕຣິງຮູບແບບສໍາລັບ ISO 8601 datetime ແມ່ນ "%Y-%m-%dT%H:%M:%SZ".

jq ອາດຈະບໍ່ຮອງຮັບການທໍາງານວັນທີນີ້ບາງອັນ ຫຼືທັງໝົດໃນບາງລະບົບ.

jq 'ຈາກວັນທີ'
"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

ເງື່ອນໄຂ ແລະ ການປຽບທຽບ

==, !=
ສຳນວນ 'a == b' ຈະຜະລິດເປັນ 'ຈິງ' ຖ້າຜົນຂອງ a ແລະ b ເທົ່າກັນ (ຄື,
ຖ້າພວກເຂົາເປັນຕົວແທນຂອງເອກະສານ JSON ທຽບເທົ່າ) ແລະ 'false' ຖ້າບໍ່ດັ່ງນັ້ນ. ໂດຍສະເພາະ, ສາຍ
ບໍ່ເຄີຍຖືວ່າເທົ່າກັບຕົວເລກ. ຖ້າທ່ານມາຈາກ Javascript, jq's == ຄື
Javascript's === - ພິຈາລະນາຄ່າເທົ່າທຽມກັນພຽງແຕ່ເມື່ອພວກມັນມີປະເພດດຽວກັນເຊັ່ນດຽວກັນ
ມູນຄ່າດຽວກັນ.

!= ແມ່ນ "ບໍ່ເທົ່າກັນ", ແລະ ´a != b´ ຕອບຄ່າກົງກັນຂ້າມຂອງ ´a == b´.

jq ´.[] == 1´
[1, 1.0, "1", "ກ້ວຍ"]
=> ຖືກ, ຖືກ, ຜິດ, ຜິດ

ຖ້າຫາກວ່າ - ຫຼັງຈາກນັ້ນ - ອື່ນ
if A ຫຼັງຈາກນັ້ນ B ອື່ນ C ໃນຕອນທ້າຍ ຈະປະຕິບັດເຊັ່ນດຽວກັນກັບ B if A ຜະລິດມູນຄ່າອື່ນທີ່ບໍ່ແມ່ນຜິດຫຼື
null, ແຕ່ປະຕິບັດເຊັ່ນດຽວກັນກັບ C ຖ້າບໍ່ດັ່ງນັ້ນ.

ການກວດສອບບໍ່ຖືກຕ້ອງຫຼື null ແມ່ນແນວຄິດທີ່ງ່າຍດາຍຂອງ "ຄວາມຈິງ" ຫຼາຍກວ່າທີ່ພົບໃນ Javascript
ຫຼື Python, ແຕ່ມັນຫມາຍຄວາມວ່າບາງຄັ້ງເຈົ້າຈະຕ້ອງມີຄວາມຊັດເຈນຫຼາຍຂຶ້ນກ່ຽວກັບເງື່ອນໄຂ
ທ່ານຕ້ອງການ: ທ່ານບໍ່ສາມາດທົດສອບວ່າ, ຕົວຢ່າງ: string ຫວ່າງເປົ່າໂດຍໃຊ້ if ຊື່ ຫຼັງຈາກນັ້ນ A ອື່ນ B ໃນຕອນທ້າຍ,
ທ່ານຕ້ອງການບາງສິ່ງບາງຢ່າງເຊັ່ນ: if (.ຊື່ | ຄວາມຍາວ) > 0 ຫຼັງຈາກນັ້ນ A ອື່ນ B ໃນຕອນທ້າຍ ແທນທີ່ຈະເປັນ.

ຖ້າເງື່ອນໄຂ A ສ້າງຜົນໄດ້ຮັບຫຼາຍ, ມັນຖືວ່າເປັນ "ຄວາມຈິງ" ຖ້າມີອັນໃດອັນຫນຶ່ງ
ຜົນໄດ້ຮັບບໍ່ແມ່ນບໍ່ຖືກຕ້ອງຫຼື null. ຖ້າ​ຫາກ​ວ່າ​ມັນ​ສ້າງ​ຜົນ​ໄດ້​ຮັບ​ສູນ​, ມັນ​ໄດ້​ຖືກ​ຖື​ວ່າ​ບໍ່​ຖືກ​ຕ້ອງ​.

ກໍລະນີເພີ່ມເຕີມສາມາດຖືກເພີ່ມໃສ່ຖ້າໃຊ້ ເອລີຟ A ຫຼັງຈາກນັ້ນ B syntax

jq 'ຖ້າ . == 0 ແລ້ວ

"ສູນ" elif . == 1 ຈາກນັ້ນ "ໜຶ່ງ" ອື່ນ "ຫຼາຍ" ຈົບ' 2 => "ຫຼາຍ"

>, >=, <=, <
ຕົວປະຕິບັດການປຽບທຽບ >, >=, <=, < ກັບຄືນບໍ່ວ່າຈະເປັນການໂຕ້ຖຽງຊ້າຍຂອງພວກເຂົາແມ່ນໃຫຍ່ກວ່າ,
ໃຫຍ່ກວ່າ ຫຼືເທົ່າກັບ, ໜ້ອຍກວ່າ ຫຼືເທົ່າກັບ ຫຼືໜ້ອຍກວ່າການໂຕ້ຖຽງທີ່ຖືກຕ້ອງ
(ຕາມລໍາດັບ).

ຄໍາສັ່ງແມ່ນຄືກັນກັບທີ່ອະທິບາຍໄວ້ ການຈັດລຽງ, ຂ້າງເທິງ.

jq ´. < 5´
2
=> ຄວາມຈິງ

ແລະ/ຫຼື/ບໍ່
jq ສະຫນັບສະຫນູນຕົວປະຕິບັດການ Boolean ປົກກະຕິແລະ / ຫຼື / ບໍ່ແມ່ນ. ພວກເຂົາເຈົ້າມີມາດຕະຖານດຽວກັນຂອງຄວາມຈິງ
as if expressions - false ແລະ null ຖືກພິຈາລະນາເປັນ "ຄ່າທີ່ບໍ່ຖືກຕ້ອງ", ແລະສິ່ງອື່ນແມ່ນ a
"ມູນຄ່າທີ່ແທ້ຈິງ".

ຖ້າ operand ຂອງຫນຶ່ງໃນຕົວປະຕິບັດການເຫຼົ່ານີ້ຜະລິດຜົນໄດ້ຮັບຫຼາຍ, ຜູ້ປະກອບການເອງ
ຈະສ້າງຜົນໄດ້ຮັບສໍາລັບການປ້ອນຂໍ້ມູນແຕ່ລະຄົນ.

ບໍ່ ໃນ​ຄວາມ​ເປັນ​ຈິງ​ແມ່ນ​ເປັນ​ການ​ທໍາ​ງານ buildin ແທນ​ທີ່​ຈະ​ເປັນ​ປະ​ຕິ​ບັດ​ການ, ສະ​ນັ້ນ​ມັນ​ໄດ້​ຖືກ​ເອີ້ນ​ວ່າ​ເປັນ​ຕົວ​ກັ່ນ​ຕອງ​ເພື່ອ
ສິ່ງທີ່ສາມາດຖືກທໍ່ແທນທີ່ຈະມີ syntax ພິເສດ, ຄືກັບໃນ .foo ແລະ . ຄາເຟ | ບໍ່.

ສາມອັນນີ້ພຽງແຕ່ຜະລິດຄຸນຄ່າ "ຄວາມຈິງ" ແລະ "ບໍ່ຖືກຕ້ອງ", ແລະດັ່ງນັ້ນຈຶ່ງເປັນປະໂຫຍດພຽງແຕ່ຂອງແທ້
ການດໍາເນີນງານ Boolean, ແທນທີ່ຈະເປັນພາສາ Perl/Python/Ruby ທົ່ວໄປຂອງ
"value_that_may_be_null ຫຼືຄ່າເລີ່ມຕົ້ນ". ຖ້າທ່ານຕ້ອງການໃຊ້ຮູບແບບຂອງ "ຫຼື", ເລືອກລະຫວ່າງ
ສອງຄ່າແທນທີ່ຈະປະເມີນເງື່ອນໄຂ, ເບິ່ງຕົວປະຕິບັດການ "//" ຂ້າງລຸ່ມນີ້.

jq ´42 ແລະ “a string”´
null
=> ຄວາມຈິງ

jq '(ຈິງ, ຜິດ) ຫຼື false'
null
=> ຖືກ, ຜິດ

jq '(ແທ້, ຈິງ) ແລະ (ຈິງ, ຜິດ)'
null
=> ຄວາມຈິງ, ຜິດ, ຖືກ, ຜິດ

jq ´[ຈິງ, ຜິດ | ບໍ່]´
null
=> [ບໍ່ຖືກຕ້ອງ, ຄວາມຈິງ]

ທາງ​ເລືອກ ປະຕິບັດການ - //
ການກັ່ນຕອງຂອງແບບຟອມ a // b ຜະລິດຜົນໄດ້ຮັບເຊັ່ນດຽວກັນກັບ a, ຖ້າ a ສ້າງ​ຜົນ​ໄດ້​ຮັບ​ອື່ນໆ​
ກ່ວາ ທີ່ບໍ່ຖືກຕ້ອງ ແລະ null. ຖ້າບໍ່ດັ່ງນັ້ນ, a // b ຜະລິດຜົນໄດ້ຮັບເຊັ່ນດຽວກັນກັບ b.

ນີ້ແມ່ນເປັນປະໂຫຍດສໍາລັບການສະຫນອງຄ່າເລີ່ມຕົ້ນ: .foo // 1 ຈະ​ປະ​ເມີນ​ຜົນ 1 ຖ້າບໍ່ມີ .foo
ອົງປະກອບໃນການປ້ອນຂໍ້ມູນ. ມັນຄ້າຍຄືກັນກັບວິທີການ or ບາງຄັ້ງຖືກໃຊ້ໃນ Python (jq's or ປະຕິບັດການ
ສະຫງວນໄວ້ສໍາລັບການດໍາເນີນການ Boolean ຢ່າງເຂັ້ມງວດ).

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

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

ພະຍາຍາມຈັບ
ຄວາມຜິດພາດສາມາດຖືກຈັບໄດ້ໂດຍການນໍາໃຊ້ ພະຍາຍາມ EXP ຈັບ EXP. ການສະແດງອອກທໍາອິດຖືກປະຕິບັດ, ແລະຖ້າ
ມັນລົ້ມເຫລວຫຼັງຈາກນັ້ນທີສອງຖືກປະຕິບັດດ້ວຍຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດ. ຜົນຜະລິດຂອງ handler, ຖ້າ
any, is output as if it has been the output of expression to try.

ໄດ້ ພະຍາຍາມ EXP ການນໍາໃຊ້ແບບຟອມ ຫວ່າງເປົ່າ ເປັນຕົວຈັດການຂໍ້ຍົກເວັ້ນ.

jq ´ try .a catch ". ບໍ່ແມ່ນວັດຖຸ"´
ທີ່ແທ້ຈິງ
=> "ບໍ່ແມ່ນວັດຖຸ"

jq ´[.[]|ພະຍາຍາມ .a]´
[{}, ຈິງ, {"a":1}]
=> [null, 1]

jq 'ພະຍາຍາມຜິດພາດ ("ບາງຂໍ້ຍົກເວັ້ນ") ຈັບ ​​.. ´
ທີ່ແທ້ຈິງ
=> "ຂໍ້ຍົກເວັ້ນບາງຢ່າງ"

breaking ອອກ of ການຄວບຄຸມ ໂຄງສ້າງ
ການ​ນໍາ​ໃຊ້​ສະ​ດວກ​ຂອງ​ການ​ພະ​ຍາ​ຍາມ / ຈັບ​ແມ່ນ​ເພື່ອ​ທໍາ​ລາຍ​ອອກ​ຈາກ​ໂຄງ​ສ້າງ​ການ​ຄວບ​ຄຸມ​ເຊັ່ນ​:​ ຫຼຸດຜ່ອນ, foreach,
ໃນຂະນະທີ່, ແລະອື່ນໆ.

ຍົກ​ຕົວ​ຢ່າງ:

# ເຮັດຊ້ຳສຳນວນຈົນກວ່າມັນຈະຍົກ "ແຕກ" ເປັນ
# ຂໍ້ຜິດພາດ, ຈາກນັ້ນຢຸດການເຮັດຊ້ຳໂດຍບໍ່ສ້າງຂໍ້ຜິດພາດຄືນໃໝ່.
# ແຕ່ຖ້າຈັບຜິດບໍ່ໄດ້ "ແຕກ" ແລ້ວຍົກຂຶ້ນມາໃໝ່.
ລອງເຮັດເລື້ມຄືນ(exp) catch .=="break" ຈາກນັ້ນຫວ່າງເປົ່າຂໍ້ຜິດພາດອື່ນ;

jq ມີ syntax ສໍາລັບປ້າຍ lexical ທີ່ມີຊື່ວ່າ "break" ຫຼື "go (ກັບຄືນ)":

ປ້າຍ $out | ... ແຕກ $out ...

ໄດ້ ພັກຜ່ອນ $label_name ການສະແດງອອກຈະເຮັດໃຫ້ໂຄງການປະຕິບັດຄືກັບວ່າຢູ່ໃກ້ທີ່ສຸດ
(ທາງຊ້າຍ) ປ້າຍ $label_name ຜະລິດ ຫວ່າງເປົ່າ.

ສາຍພົວພັນລະຫວ່າງ ພັກຜ່ອນ ແລະທີ່ສອດຄ້ອງກັນ ປ້າຍ ແມ່ນ lexical: ປ້າຍຊື່ຕ້ອງມີ
"ສັງເກດເຫັນ" ຈາກການພັກຜ່ອນ.

ແຍກອອກຈາກ ກ ຫຼຸດຜ່ອນ, ຍົກ​ຕົວ​ຢ່າງ:

ປ້າຍ $out | ຫຼຸດ .[] ເປັນ $item (null; ຖ້າ .==false ແລ້ວແຍກ $out else... end)

ໂປຣແກຣມ jq ຕໍ່ໄປນີ້ສ້າງຂໍ້ຜິດພາດ syntax:

ແຕກ $ ອອກ

ເນື່ອງຈາກວ່າບໍ່ມີປ້າຍຊື່ $out ແມ່ນສັງເກດເຫັນ.

? ປະຕິບັດການ
ໄດ້ ? operator, ໃຊ້ເປັນ EXP?, ແມ່ນ shorthand ສໍາລັບ ພະຍາຍາມ EXP.

jq ´[.[]|.a)?]´
[{}, ຈິງ, {"a":1}]
=> [null, 1]

REGULAR ການສະແດງອອກ (PCRE)

jq ໃຊ້ຫ້ອງສະຫມຸດການສະແດງອອກປົກກະຕິ Oniguruma, ເຊັ່ນດຽວກັບ php, ruby, TextMate, Sublime Text,
ແລະອື່ນໆ, ດັ່ງນັ້ນຄໍາອະທິບາຍຢູ່ທີ່ນີ້ຈະເນັ້ນໃສ່ສະເພາະ jq.

ການກັ່ນຕອງ jq regex ຖືກກໍານົດເພື່ອໃຫ້ພວກເຂົາສາມາດຖືກນໍາໃຊ້ໂດຍໃຊ້ຫນຶ່ງໃນຮູບແບບເຫຼົ່ານີ້:

STRING | ການກັ່ນຕອງ( REGEX )
STRING | ການກັ່ນຕອງ( REGEX; ທຸງ )
STRING | FILTER( [REGEX] )
STRING | FILTER( [REGEX, FLAGS] )

ບ່ອນທີ່: * STRING, REGEX ແລະ FLAGS ແມ່ນ jq strings ແລະຂຶ້ນກັບ jq string interpolation; *
REGEX, ຫຼັງຈາກ string interpolation, ຄວນເປັນ PCRE regex ທີ່ຖືກຕ້ອງ; * FILTER ແມ່ນ​ຫນຶ່ງ​ໃນ​ ການທົດສອບ,
ການແຂ່ງຂັນ, ຫຼື ຈັບ, ດັ່ງທີ່ໄດ້ອະທິບາຍຂ້າງລຸ່ມນີ້.

FLAGS ແມ່ນສະຕຣິງທີ່ປະກອບດ້ວຍໜຶ່ງໃນທຸງທີ່ຮອງຮັບເພີ່ມເຕີມ:

· g - ການ​ຄົ້ນ​ຫາ​ທົ່ວ​ໂລກ (ຊອກ​ຫາ​ການ​ແຂ່ງ​ຂັນ​ທັງ​ຫມົດ​, ບໍ່​ພຽງ​ແຕ່​ຄັ້ງ​ທໍາ​ອິດ​)

· i - ການຄົ້ນຫາແບບບໍ່ລະອຽດອ່ອນ

· m - ຮູບ​ແບບ​ຫຼາຍ​ເສັ້ນ ('.' ຈະ​ກົງ​ກັບ​ເສັ້ນ​ໃຫມ່​)

· n - ບໍ່​ສົນ​ໃຈ​ການ​ແຂ່ງ​ຂັນ​ເປົ່າ​ຫວ່າງ​

· p - ທັງສອງໂຫມດ s ແລະ m ຖືກເປີດໃຊ້

· s - ໂໝດເສັ້ນດ່ຽວ (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - ຊອກ​ຫາ​ການ​ແຂ່ງ​ຂັນ​ທີ່​ຍາວ​ທີ່​ສຸດ​

· x - ຂະ​ຫຍາຍ​ຮູບ​ແບບ regex (ລະ​ເລີຍ​ຊ່ອງ​ຫວ່າງ​ແລະ​ຄໍາ​ຄິດ​ເຫັນ​)

ເພື່ອຈັບຄູ່ຊ່ອງຫວ່າງໃນຮູບແບບ x ໃຊ້ຕົວຫນີເຊັ່ນ \s, ຕົວຢ່າງ

· ການທົດສອບ ( "a\sb", "x" ).

ໃຫ້ສັງເກດວ່າບາງທຸງອາດຈະຖືກລະບຸພາຍໃນ REGEX, ເຊັ່ນ:

· jq -n ´("test", "Test", "teST", "TEST") | ທົດສອບ("(?i)te(?-i)st")´

ປະເມີນເປັນ: ຄວາມຈິງ, ຄວາມຈິງ, ບໍ່ຖືກຕ້ອງ, ບໍ່ຖືກຕ້ອງ.

[ຕ້ອງການ 1.5] ການທົດສອບ(val), ທົດສອບ(regex; ທຸງ)
ຄື ການແຂ່ງຂັນ, ແຕ່ບໍ່ສົ່ງຄືນວັດຖຸທີ່ກົງກັນ, ເທົ່ານັ້ນ ທີ່ແທ້ຈິງ or ທີ່ບໍ່ຖືກຕ້ອງ ສໍາລັບບໍ່ວ່າຈະເປັນຫຼືບໍ່
regex ກົງກັບວັດສະດຸປ້ອນ.

jq 'test("foo")´
"ຟູ"
=> ຄວາມຈິງ

jq ´.[] | test("abc # spaces are ignored"; "ix")´
["xabcd", "ABC"]
=> ຈິງ, ແທ້

[ຕ້ອງການ 1.5] match(val), match(regex; ທຸງ)
ການແຂ່ງຂັນ ຜົນໄດ້ຮັບຂອງວັດຖຸສໍາລັບແຕ່ລະການແຂ່ງຂັນທີ່ມັນພົບ. ການແຂ່ງຂັນມີຊ່ອງດັ່ງຕໍ່ໄປນີ້:

· ຊົດເຊີຍ - ຊົດເຊີຍໃນຈຸດລະຫັດ UTF-8 ຈາກຈຸດເລີ່ມຕົ້ນຂອງການປ້ອນຂໍ້ມູນ

· ຄວາມຍາວ - ຄວາມຍາວໃນລະຫັດ UTF-8 ຂອງການແຂ່ງຂັນ

· string - ຊ່ອຍແນ່ທີ່ມັນກົງກັນ

· captures - array ຂອງວັດຖຸທີ່ເປັນຕົວແທນຂອງກຸ່ມການຈັບ.

ການຈັບກຸ່ມວັດຖຸມີຊ່ອງຂໍ້ມູນຕໍ່ໄປນີ້:

· ຊົດເຊີຍ - ຊົດເຊີຍໃນຈຸດລະຫັດ UTF-8 ຈາກຈຸດເລີ່ມຕົ້ນຂອງການປ້ອນຂໍ້ມູນ

· ຄວາມຍາວ - ຄວາມຍາວໃນ UTF-8 codepoints ຂອງກຸ່ມການຈັບນີ້

· string - ສາຍທີ່ຈັບໄດ້

· ຊື່ - ຊື່​ຂອງ​ກຸ່ມ​ຈັບ​ໄດ້ (ຫຼື​ null ຖ້າມັນບໍ່ມີຊື່)

ການຈັບກຸ່ມທີ່ບໍ່ກົງກັບອັນໃດອັນໜຶ່ງໃຫ້ຄ່າຊົດເຊີຍຂອງ -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", "ຊື່": 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 " , "captures": []}

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

jq ´[ match( "."; "g")] | ຄວາມຍາວ
"abc"
=> 3

[ຕ້ອງການ 1.5] capture(val), capture(regex; ທຸງ)
ເກັບ​ກໍາ​ຂໍ້​ມູນ​ທີ່​ມີ​ຊື່​ໃນ​ວັດ​ຖຸ JSON​, ໂດຍ​ມີ​ຊື່​ຂອງ​ການ​ຈັບ​ພາບ​ແຕ່​ລະ​ຄົນ​ເປັນ​ກະ​ແຈ​,
ແລະສະຕຣິງທີ່ກົງກັນເປັນຄ່າທີ່ສອດຄ້ອງກັນ.

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

[ຕ້ອງການ 1.5] ສະແກນ(regex), ສະແກນ(regex; ທຸງ)
ປ່ອຍກະແສຂອງສາຍຍ່ອຍທີ່ບໍ່ທັບຊ້ອນກັນຂອງວັດສະດຸປ້ອນທີ່ກົງກັບ regex ໃນ
ອີງ​ຕາມ​ທຸງ​ຊາດ​, ຖ້າ​ຫາກ​ວ່າ​ມີ​ການ​ລະ​ບຸ​ໄວ້​. ຖ້າບໍ່ມີການແຂ່ງຂັນ, ນ້ໍາແມ່ນ
ຫວ່າງເປົ່າ. ເພື່ອບັນທຶກການຈັບຄູ່ທັງໝົດສໍາລັບແຕ່ລະສະຕຣິງການປ້ອນຂໍ້ມູນ, ໃຫ້ໃຊ້ idiom [ ຕົວຢ່າງ ], ຕົວຢ່າງ [
ສະແກນ(regex) ].

ແຍກ(regex; ທຸງ)
ສໍາລັບຄວາມເຂົ້າກັນໄດ້ໃນດ້ານຫລັງ, ແບ່ງປັນ ແຍກຢູ່ໃນສະຕຣິງ, ບໍ່ແມ່ນ regex.

[ຕ້ອງການ 1.5] splits(regex), splits(regex; ທຸງ)
ເຫຼົ່ານີ້ສະຫນອງຜົນໄດ້ຮັບເຊັ່ນດຽວກັນກັບຂອງເຂົາເຈົ້າ ແບ່ງປັນ ຄູ່, ແຕ່ເປັນນ້ໍາແທນທີ່ຈະເປັນ
ຂບວນ.

[ຕ້ອງການ 1.5] ຍ່ອຍ(regex; ສາຍເຊືອກ) ຍ່ອຍ(regex; ຊ່ອຍແນ່; ທຸງ)
ປ່ອຍຕົວສະຕຣິງທີ່ໄດ້ຮັບໂດຍການປ່ຽນແທນການຈັບຄູ່ທຳອິດຂອງ regex ໃນສະຕຣິງປ້ອນເຂົ້າດ້ວຍ
ເຊືອກຜູກ, ຫຼັງຈາກ interpolation. ເຊືອກຜູກ ຄວນເປັນສະຕຣິງ jq, ແລະອາດຈະມີການອ້າງອີງ
ກັບ captures ຊື່. ໃນຄວາມເປັນຈິງ, ການຈັບພາບທີ່ມີຊື່ແມ່ນນໍາສະເຫນີເປັນວັດຖຸ JSON (ເປັນ
ກໍ່ສ້າງໂດຍ ຈັບ) ໄປ ເຊືອກຜູກ, ດັ່ງນັ້ນການອ້າງອີງເຖິງຕົວແປທີ່ຈັບໄດ້ທີ່ມີຊື່ວ່າ "x" ຈະ
ເອົາແບບຟອມ: ".x)".

[ຕ້ອງການ 1.5] gsub(regex; string), gsub(regex; ຊ່ອຍແນ່; ທຸງ)
gsub ແມ່ນຄ້າຍຄື ການຍ່ອຍ ແຕ່ທຸກການປະກົດຕົວທີ່ບໍ່ທັບຊ້ອນກັນຂອງ regex ຈະຖືກແທນທີ່ດ້ວຍ
string, ຫຼັງຈາກ interpolation.

ADVANCED ຄຸນ​ລັກ​ສະ​ນະ

ຕົວແປແມ່ນມີຄວາມຈໍາເປັນຢ່າງແທ້ຈິງໃນພາສາການຂຽນໂປຼແກຼມສ່ວນໃຫຍ່, ແຕ່ພວກມັນຖືກຍົກເລີກ
ກັບ "ຄຸນສົມບັດຂັ້ນສູງ" ໃນ jq.

ໃນພາສາສ່ວນໃຫຍ່, ຕົວແປແມ່ນວິທີດຽວຂອງການຖ່າຍທອດຂໍ້ມູນ. ຖ້າທ່ານຄິດໄລ່ a
ຄ່າ, ແລະທ່ານຕ້ອງການໃຊ້ມັນຫຼາຍກວ່າຫນຶ່ງຄັ້ງ, ທ່ານຈະຕ້ອງເກັບຮັກສາມັນໄວ້ໃນຕົວແປ. ເຖິງ
ສົ່ງຄ່າໄປຫາສ່ວນອື່ນຂອງໂຄງການ, ເຈົ້າຕ້ອງການສ່ວນນັ້ນຂອງໂປຣແກຣມ
ກໍານົດຕົວແປ (ເປັນພາລາມິເຕີຟັງຊັນ, ສະມາຊິກຂອງວັດຖຸ, ຫຼືໃດກໍ່ຕາມ) ທີ່ຈະວາງ
ຂໍ້ມູນ.

ມັນຍັງເປັນໄປໄດ້ທີ່ຈະກໍານົດຫນ້າທີ່ໃນ jq, ເຖິງແມ່ນວ່ານີ້ແມ່ນຄຸນສົມບັດທີ່ໃຫຍ່ທີ່ສຸດ
ການນໍາໃຊ້ແມ່ນກໍານົດຫ້ອງສະຫມຸດມາດຕະຖານ jq ຂອງ (ຫຼາຍຫນ້າທີ່ jq ເຊັ່ນ: ແຜນທີ່ ແລະ ຊອກຫາ ແມ່ນຢູ່ໃນຄວາມເປັນຈິງ
ຂຽນໃນ jq).

jq ມີຕົວປະຕິບັດການຫຼຸດຜ່ອນ, ເຊິ່ງມີອໍານາດຫຼາຍແຕ່ມີຄວາມຫຍຸ້ງຍາກເລັກນ້ອຍ. ອີກເທື່ອຫນຶ່ງ, ເຫຼົ່ານີ້ແມ່ນ
ສ່ວນຫຼາຍແມ່ນໃຊ້ພາຍໃນ, ເພື່ອກໍານົດບາງສ່ວນທີ່ເປັນປະໂຫຍດຂອງຫ້ອງສະຫມຸດມາດຕະຖານ jq.

ມັນອາດຈະບໍ່ຈະແຈ້ງໃນຕອນທໍາອິດ, ແຕ່ jq ແມ່ນທັງຫມົດກ່ຽວກັບເຄື່ອງປັ່ນໄຟ (ແມ່ນແລ້ວ, ຕາມທີ່ພົບເຫັນເລື້ອຍໆໃນ
ພາ​ສາ​ອື່ນໆ). ອຸປະໂພກຈໍານວນຫນຶ່ງແມ່ນສະຫນອງໃຫ້ເພື່ອຊ່ວຍຈັດການກັບເຄື່ອງປັ່ນໄຟ.

ຮອງຮັບ I/O ໜ້ອຍທີ່ສຸດ (ນອກຈາກການອ່ານ JSON ຈາກການປ້ອນຂໍ້ມູນມາດຕະຖານ, ແລະຂຽນ JSON ເຖິງ
ຜົນຜະລິດມາດຕະຖານ) ແມ່ນມີຢູ່.

ສຸດທ້າຍ, ມີລະບົບໂມດູນ / ຫ້ອງສະຫມຸດ.

Variables
ໃນ jq, ການກັ່ນຕອງທັງຫມົດມີວັດສະດຸປ້ອນແລະຜົນຜະລິດ, ສະນັ້ນທໍ່ນ້ໍາຄູ່ມືແມ່ນບໍ່ຈໍາເປັນ
ສົ່ງຄ່າຈາກສ່ວນໜຶ່ງຂອງໂປຣແກຣມໄປຫາອັນຕໍ່ໄປ. ສໍານວນຫຼາຍ, ສໍາລັບການຍົກຕົວຢ່າງ a + b,
ຜ່ານ​ການ​ປ້ອນ​ຂໍ້​ມູນ​ຂອງ​ເຂົາ​ເຈົ້າ​ກັບ​ສອງ subexpressions ທີ່​ແຕກ​ຕ່າງ​ກັນ (ທີ່ນີ້ a ແລະ b ທັງສອງຜ່ານຄືກັນ
input), ດັ່ງນັ້ນຕົວແປຕ່າງໆແມ່ນບໍ່ຈໍາເປັນເພື່ອນໍາໃຊ້ຄ່າສອງຄັ້ງ.

ສໍາລັບຕົວຢ່າງ, ການຄິດໄລ່ຄ່າສະເລ່ຍຂອງ array ຂອງຕົວເລກຮຽກຮ້ອງໃຫ້ມີຈໍານວນຫນ້ອຍ
ຕົວແປໃນພາສາສ່ວນໃຫຍ່ - ຢ່າງຫນ້ອຍຫນຶ່ງເພື່ອຖື array, ບາງທີຫນຶ່ງສໍາລັບແຕ່ລະອົງປະກອບ
ຫຼືສໍາລັບ loop counter. ໃນ jq, ມັນງ່າຍດາຍ ເພີ່ມ / ຄວາມຍາວ - ໄດ້ ເພີ່ມ ການສະແດງອອກແມ່ນໄດ້ຮັບ
array ແລະຜະລິດຜົນລວມຂອງມັນ, ແລະ ຄວາມຍາວ ການສະແດງອອກແມ່ນໃຫ້ array ແລະຜະລິດຂອງມັນ
ຄວາມຍາວ.

ດັ່ງນັ້ນ, ໂດຍທົ່ວໄປແລ້ວມີວິທີທີ່ສະອາດກວ່າທີ່ຈະແກ້ໄຂບັນຫາສ່ວນໃຫຍ່ໃນ jq ກ່ວາການກໍານົດຕົວແປ.
ຢ່າງໃດກໍຕາມ, ບາງຄັ້ງພວກເຂົາເຮັດໃຫ້ສິ່ງຕ່າງໆງ່າຍຂຶ້ນ, ດັ່ງນັ້ນ jq ຊ່ວຍໃຫ້ທ່ານກໍານົດຕົວແປໂດຍໃຊ້
ການສະແດງອອກ as $variable. ຊື່ຕົວແປທັງໝົດເລີ່ມຕົ້ນດ້ວຍ $. ນີ້ແມ່ນສະບັບ uglier ເລັກນ້ອຍ
ຂອງຕົວຢ່າງ array-Average:

ຄວາມຍາວເປັນ $array_length | ເພີ່ມ / $ array_length

ພວກເຮົາຈະຕ້ອງການບັນຫາທີ່ສັບສົນກວ່າເພື່ອຊອກຫາສະຖານະການທີ່ໃຊ້ຕົວແປຕົວຈິງ
ເຮັດໃຫ້ຊີວິດຂອງພວກເຮົາງ່າຍຂຶ້ນ.

ສົມມຸດວ່າພວກເຮົາມີ array ຂອງບົດຄວາມ blog, ມີ "ຜູ້ຂຽນ" ແລະ "ຫົວຂໍ້" ຊ່ອງຂໍ້ມູນ, ແລະອື່ນ
ວັດຖຸທີ່ໃຊ້ໃນແຜນທີ່ຊື່ຜູ້ໃຊ້ຂອງຜູ້ຂຽນກັບຊື່ແທ້. ການປ້ອນຂໍ້ມູນຂອງພວກເຮົາເບິ່ງຄືວ່າ:

{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "ບົດຄວາມທີ່ຂຽນໄດ້ດີ", "ຜູ້ຂຽນ": "person1"}],
"ຊື່ແທ້": {"anon": "ບໍ່ປະສົງອອກນາມ",
"person1": "Person McPherson"}}

ພວກເຮົາຕ້ອງການຜະລິດຂໍ້ຄວາມທີ່ມີພາກສະຫນາມຜູ້ຂຽນທີ່ມີຊື່ແທ້, ເຊັ່ນ:

{"title": "Frist psot", "author": "Anonymous Coward"}
{"title": "ບົດຄວາມທີ່ຂຽນໄດ້ດີ", "ຜູ້ຂຽນ": "Person McPherson"}

ພວກເຮົາໃຊ້ຕົວແປ, $names, ເພື່ອເກັບຮັກສາວັດຖຸຊື່ແທ້, ດັ່ງນັ້ນພວກເຮົາສາມາດອ້າງເຖິງມັນໄດ້ໃນພາຍຫຼັງ
ເມື່ອຊອກຫາຊື່ຜູ້ໃຊ້ຂອງຜູ້ຂຽນ:

.ຊື່ແທ້ເປັນ $names | .posts[] | {title, author: $names[.author]}

ການສະແດງອອກ exp as $x | ... ຫມາຍຄວາມວ່າ: ສໍາລັບແຕ່ລະມູນຄ່າຂອງການສະແດງອອກ exp, ດໍາເນີນການສ່ວນທີ່ເຫຼືອຂອງ
ທໍ່ກັບວັດສະດຸປ້ອນຕົ້ນສະບັບທັງຫມົດ, ແລະດ້ວຍ $x ຕັ້ງເປັນຄ່ານັ້ນ. ດັ່ງນັ້ນ as
ເຮັດຫນ້າທີ່ເປັນບາງສິ່ງບາງຢ່າງຂອງ loop foreach.

ພຽງແຕ່ເປັນ {foo} ເປັນວິທີການຂຽນທີ່ມີປະໂຫຍດ {foo: .foo}, ດັ່ງນັ້ນ {$foo} ເປັນວິທີການຂຽນທີ່ມີປະໂຫຍດ
{foo:$foo}.

ຫຼາຍຕົວແປອາດຈະຖືກປະກາດໂດຍໃຊ້ອັນດຽວ as ການສະແດງອອກໂດຍການສະຫນອງຮູບແບບ
ທີ່ກົງກັບໂຄງສ້າງຂອງວັດສະດຸປ້ອນ (ອັນນີ້ເອີ້ນວ່າ "ການທໍາລາຍ"):

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

ການປະກາດຕົວແປໃນຮູບແບບ array (ເຊັ່ນ: . as [$ທຳອິດ, $second]) ຜູກມັດກັບ
ອົງປະກອບຂອງ array ໃນຈາກອົງປະກອບຢູ່ໃນດັດຊະນີສູນຂຶ້ນ, ຕາມລໍາດັບ. ໃນເວລາທີ່ບໍ່ມີ
ຄ່າຢູ່ໃນດັດຊະນີສໍາລັບອົງປະກອບຮູບແບບ array, null ຖືກຜູກມັດກັບຕົວແປນັ້ນ.

ຕົວແປແມ່ນຂອບເຂດຫຼາຍກວ່າສ່ວນທີ່ເຫລືອຂອງການສະແດງຜົນທີ່ກໍານົດພວກມັນ, ດັ່ງນັ້ນ

.ຊື່ແທ້ເປັນ $names | (.posts[] | {title, author: $names[.author]})

ຈະເຮັດວຽກ, ແຕ່

(.ຊື່ແທ້ເປັນ $names | .posts[]) | {title, author: $names[.author]}

ຈະບໍ່.

ສໍາລັບນັກທິດສະດີພາສາການຂຽນໂປລແກລມ, ມັນຖືກຕ້ອງກວ່າທີ່ຈະເວົ້າວ່າຕົວແປ jq ແມ່ນ
ການຜູກມັດທີ່ມີຂອບເຂດ. ໂດຍສະເພາະ, ບໍ່ມີວິທີທີ່ຈະປ່ຽນມູນຄ່າຂອງການຜູກມັດ;
ຫນຶ່ງພຽງແຕ່ສາມາດຕັ້ງຄ່າການຜູກມັດໃຫມ່ທີ່ມີຊື່ດຽວກັນ, ແຕ່ວ່າຈະບໍ່ເຫັນບ່ອນໃດ
ເກົ່າແມ່ນ.

jq ´.bar ເປັນ $x | .foo | . + $x'
{"foo":10, "bar":200}
=> 210

jq ´. ເປັນ $i|[(.*2|. as $i| $i), $i]´
5
=> [10,5]

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

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

ນິຍາມ ຫນ້າທີ່
ທ່ານສາມາດຕັ້ງຊື່ການກັ່ນຕອງໂດຍໃຊ້ syntax "def":

def ເພີ່ມຂຶ້ນ: . + 1;

ຈາກ​ນັ້ນ​ມາ, ການເພີ່ມຂື້ນ ສາມາດໃຊ້ໄດ້ເປັນຕົວກອງຄືກັນກັບຟັງຊັນ builtin (ໃນຄວາມເປັນຈິງ, ນີ້
ແມ່ນວິທີການຈໍານວນຫນຶ່ງຂອງ buildins ໄດ້ຖືກກໍານົດ). ຟັງຊັນອາດຈະໃຊ້ການໂຕ້ຖຽງ:

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

ອາກິວເມັນຖືກສົ່ງຜ່ານເປັນຕົວກອງ, ບໍ່ແມ່ນຄ່າ. ການໂຕ້ຖຽງດຽວກັນອາດຈະຖືກອ້າງອີງ
ຫຼາຍຄັ້ງດ້ວຍການປ້ອນຂໍ້ມູນທີ່ແຕກຕ່າງກັນ (ທີ່ນີ້ f ແມ່ນດໍາເນີນການສໍາລັບແຕ່ລະອົງປະກອບຂອງ array ການປ້ອນຂໍ້ມູນ).
arguments ຕໍ່ກັບຟັງຊັນເຮັດວຽກຄືກັບ callbacks ຫຼາຍກວ່າຄືກັບ value argument. ນີ້​ແມ່ນ
ສໍາຄັນທີ່ຈະເຂົ້າໃຈ. ພິ​ຈາ​ລະ​ນາ:

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

ຜົນໄດ້ຮັບຈະເປັນ 20 ເນື່ອງຈາກວ່າ f is .*2, ແລະໃນລະຫວ່າງການຮຽກຮ້ອງຄັ້ງທໍາອິດຂອງ f . ຈະ​ເປັນ 5​,
ແລະຄັ້ງທີສອງມັນຈະເປັນ 10 (5 * 2), ດັ່ງນັ້ນຜົນໄດ້ຮັບຈະເປັນ 20. ການໂຕ້ຖຽງ Function
ແມ່ນຕົວກອງ, ແລະຕົວກອງຄາດວ່າຈະມີການປ້ອນຂໍ້ມູນເມື່ອຖືກເອີ້ນ.

ຖ້າທ່ານຕ້ອງການພຶດຕິກໍາການໂຕ້ຖຽງມູນຄ່າສໍາລັບການກໍານົດຫນ້າທີ່ງ່າຍດາຍ, ທ່ານພຽງແຕ່ສາມາດນໍາໃຊ້ a
ຕົວປ່ຽນແປງ:

def addvalue(f): f as $f | ແຜນທີ່(+$f);

ຫຼືໃຊ້ມືສັ້ນ:

def addvalue($f): ... ;

ມີ​ຄໍາ​ນິ​ຍາມ​ທັງ​ຫມົດ​, addvalue.foo ຈະເພີ່ມການປ້ອນຂໍ້ມູນປະຈຸບັນ .foo ພາກສະຫນາມແຕ່ລະຄົນ
ອົງປະກອບຂອງອາເຣ.

ອະນຸຍາດຫຼາຍຄໍານິຍາມໂດຍໃຊ້ຊື່ຟັງຊັນດຽວກັນ. ແຕ່ລະຄໍານິຍາມໃຫມ່ທົດແທນ
ອັນ​ທີ່​ຜ່ານ​ມາ​ສໍາ​ລັບ​ຈໍາ​ນວນ​ດຽວ​ກັນ​ຂອງ​ການ​ໂຕ້​ຕອບ​ຫນ້າ​ທີ່​, ແຕ່​ວ່າ​ພຽງ​ແຕ່​ສໍາ​ລັບ​ການ​ອ້າງ​ອີງ​ຈາກ​
ຫນ້າທີ່ (ຫຼືໂຄງການຕົ້ນຕໍ) ຕໍ່ມາກັບຄໍານິຍາມໃຫມ່.

jq ´def addvalue(f): . + [f]; ແຜນທີ່(ເພີ່ມມູນຄ່າ(.[0]))´
[[1,2], [10,20]]
=> [[1,2,1], [10,20,10]]

jq ´def addvalue(f): f as $x | ແຜນທີ່ (+ $x); addvalue(.[0])´
[[1,2], [10,20]]
=> [[1,2,1,2], [10,20,1,2]]

ຫຼຸດລົງ
ໄດ້ ຫຼຸດຜ່ອນ syntax ໃນ jq ຊ່ວຍໃຫ້ທ່ານສາມາດສົມທົບຜົນໄດ້ຮັບທັງຫມົດຂອງການສະແດງອອກໂດຍ
ສະສົມໃຫ້ເຂົາເຈົ້າເຂົ້າໄປໃນຄໍາຕອບດຽວ. ເປັນຕົວຢ່າງ, ພວກເຮົາຈະຜ່ານ [3,2,1] ນີ້
ການສະແດງອອກ:

ຫຼຸດ .[] ເປັນ $item (0; . + $item)

ສໍາລັບຜົນໄດ້ຮັບແຕ່ລະຄົນ .[] ຜະ​ລິດ​ຕະ​ພັນ​, . + $item ແມ່ນແລ່ນເພື່ອສະສົມການແລ່ນທັງໝົດ,
ເລີ່ມຕົ້ນຈາກ 0. ໃນຕົວຢ່າງນີ້, .[] ຜະລິດຜົນໄດ້ຮັບ 3, 2, ແລະ 1, ດັ່ງນັ້ນຜົນກະທົບແມ່ນ
ຄ້າຍຄືກັບແລ່ນບາງສິ່ງບາງຢ່າງເຊັ່ນນີ້:

0 | (3 ເປັນ $item | . + $item) |
(2 ເປັນ $item | . + $item) |
(1 ເປັນ $item | . + $item)

jq 'ຫຼຸດ.[] ເປັນ $item (0; . + $item)´
[10,2,5,3]
=> 20

limit(n; exp)
ໄດ້ ກໍານົດຂອບເຂດ ຟັງຊັນສະກັດເຖິງ n ຜົນຜະລິດຈາກ exp.

jq ´[ຈຳກັດ(3;.[])]´
[0,1,2,3,4,5,6,7,8,9]
=> [0,1,2]

ທໍາອິດ (expr), ສຸດທ້າຍ(expr), nth(n; expr)
ໄດ້ ທໍາອິດ (expr) ແລະ ສຸດທ້າຍ (expr) ຟັງຊັນສະກັດຄ່າທໍາອິດແລະສຸດທ້າຍຈາກ ຕົວຢ່າງ,
ຕາມລໍາດັບ.

ໄດ້ nth(n; expr) ຟັງຊັນສະກັດເອົາຜົນຜະລິດມູນຄ່າ nth ໂດຍ ຕົວຢ່າງ. ນີ້ສາມາດຖືກກໍານົດເປັນ
def nth(n; expr): last(limit(ນ + 1; expr));. ໃຫ້ສັງເກດວ່າ nth(n; expr) ບໍ່ສະຫນັບສະຫນູນ
ຄຸນ​ຄ່າ​ທາງ​ລົບ​ຂອງ​ n.

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

ຄັ້ງທໍາອິດ, ສຸດທ້າຍ, nth(n)
ໄດ້ ຄັ້ງທໍາອິດ ແລະ ສຸດທ້າຍ functions ສະກັດຄ່າທໍາອິດແລະສຸດທ້າຍຈາກ array ໃດ ..

ໄດ້ nth(n) ຟັງຊັນສະກັດຄ່າທີ n ຂອງອາເຣໃດນຶ່ງຢູ່ ..

jq ´[range.)]|[ທຳອິດ, ສຸດທ້າຍ, ນ(5)]´
10
=> [0,9,5]

foreach
ໄດ້ foreach syntax ແມ່ນຄ້າຍຄືກັນກັບ ຫຼຸດຜ່ອນ, ແຕ່ມີຈຸດປະສົງເພື່ອອະນຸຍາດໃຫ້ການກໍ່ສ້າງຂອງ ກໍານົດຂອບເຂດ
ແລະຕົວຫຼຸດຜ່ອນທີ່ຜະລິດຜົນໄດ້ຮັບລະດັບປານກາງ (ເບິ່ງຕົວຢ່າງ).

ແບບຟອມແມ່ນ foreach EXP as $var (ໃນ​ມັນ; ອັບເດດ; ສານສະກັດຈາກ)ທີ່ຢູ່ ເຊັ່ນດຽວກັນ ຫຼຸດຜ່ອນ, ໃນ​ມັນ ຖືກປະເມີນຜົນ
ເມື່ອຜະລິດມູນຄ່າຂອງລັດ, ຫຼັງຈາກນັ້ນແຕ່ລະຜົນຜະລິດຂອງ EXP ຖືກຜູກມັດກັບ $var, UPDATE is
ການ​ປະ​ເມີນ​ຜົນ​ສໍາ​ລັບ​ການ​ຜະ​ລິດ​ຕະ​ພັນ​ຂອງ​ແຕ່​ລະ​ຄົນ​ EXP ກັບສະຖານະປະຈຸບັນແລະກັບ $var ເຫັນໄດ້. ແຕ່ລະມູນຄ່າ
ຜົນຜະລິດໂດຍ UPDATE ແທນທີ່ລັດທີ່ຜ່ານມາ. ສຸດທ້າຍ, EXTRACT ຖືກປະເມີນສໍາລັບແຕ່ລະອັນໃຫມ່
ລັດທີ່ຈະສະກັດຜົນຜະລິດຂອງ foreach.

ນີ້ສ່ວນໃຫຍ່ແມ່ນເປັນປະໂຫຍດພຽງແຕ່ສໍາລັບການກໍ່ສ້າງ ຫຼຸດຜ່ອນ- ແລະ ກໍານົດຂອບເຂດ- ຫນ້າ​ທີ່​ຄ້າຍ​ຄື​. ແຕ່ມັນແມ່ນ
ໂດຍທົ່ວໄປຫຼາຍ, ຍ້ອນວ່າມັນອະນຸຍາດໃຫ້ມີການຫຼຸດຜ່ອນບາງສ່ວນ (ເບິ່ງຕົວຢ່າງຂ້າງລຸ່ມນີ້).

jq ´[foreach.[] as $item ([[],[]]; ຖ້າ $item == null ຫຼັງຈາກນັ້ນ [[],.[0]] else [(.[0] + [$item]),[ ]] ສິ້ນສຸດ; ຖ້າ $item == null ຫຼັງຈາກນັ້ນ .[1] ສິ້ນເປົ່າອື່ນ)]´
[1,2,3,4,null,"a","b",null]
=> [[1,2,3,4],["a","b"]]

Recursion
ດັ່ງທີ່ອະທິບາຍໄວ້ຂ້າງເທິງ, ພະຍາບານ ໃຊ້ recursion, ແລະຟັງຊັນ jq ໃດກໍ່ຕາມສາມາດ recursive. ໄດ້
ໃນຂະນະທີ່ buildin ຍັງຖືກປະຕິບັດໃນເງື່ອນໄຂຂອງ recursion.

ການໂທຫາງຈະຖືກປັບໃຫ້ເໝາະສົມທຸກຄັ້ງທີ່ສະແດງອອກທາງຊ້າຍຂອງຜົນການໂທແບບ recursive
ມູນຄ່າສຸດທ້າຍຂອງມັນ. ໃນການປະຕິບັດນີ້ຫມາຍຄວາມວ່າການສະແດງອອກໄປທາງຊ້າຍຂອງ recursive ໄດ້
ການໂທບໍ່ຄວນຜະລິດຫຼາຍກ່ວາຫນຶ່ງຜົນຜະລິດສໍາລັບແຕ່ລະ input.

ຍົກ​ຕົວ​ຢ່າງ:

def recurse(f): def r: ., (f | ເລືອກ. != null) | r); r;

def while(cond; update):
def _while:
if cond then ., (update | _while) else ສິ້ນເປົ່າ;
_ໃນຂະນະທີ່;

def repeat(exp):
def _repeat:
exp, _repeat;
_ຊ້ຳ;

ກໍາເນີດໄຟຟ້າ ແລະ ຜູ້ເຮັດຊ້ຳ
ບາງຕົວປະຕິບັດການ jq ແລະຫນ້າທີ່ຕົວຈິງແມ່ນເຄື່ອງກໍາເນີດທີ່ພວກເຂົາສາມາດຜະລິດສູນ,
ຫນຶ່ງ, ຫຼືຫຼາຍມູນຄ່າສໍາລັບການປ້ອນຂໍ້ມູນແຕ່ລະຄົນ, ຄືກັນກັບທີ່ອາດຈະຄາດຫວັງໃນການຂຽນໂປລແກລມອື່ນ
ພາສາທີ່ມີເຄື່ອງກໍາເນີດ. ຍົກ​ຕົວ​ຢ່າງ, .[] ສ້າງຄ່າທັງໝົດໃນການປ້ອນຂໍ້ມູນຂອງມັນ
(ເຊິ່ງຈະຕ້ອງເປັນ array ຫຼືວັດຖຸ), ຊ່ວງ(0; 10) ສ້າງຈຳນວນເຕັມລະຫວ່າງ 0 ແລະ
10, ແລະອື່ນໆ.

ເຖິງແມ່ນວ່າຕົວປະຕິບັດການເຄື່ອງໝາຍຈຸດແມ່ນເຄື່ອງກໍາເນີດ, ສ້າງຄ່າທໍາອິດທີ່ສ້າງຂຶ້ນໂດຍ
ການສະແດງຜົນໄປທາງຊ້າຍຂອງເຄື່ອງໝາຍຈຸດ, ຈາກນັ້ນສຳລັບແຕ່ລະອັນ, ຄ່າທີ່ສ້າງຂຶ້ນໂດຍເຄື່ອງໝາຍຈຸດ
ການສະແດງອອກຢູ່ເບື້ອງຂວາຂອງເຄື່ອງໝາຍຈຸດ.

ໄດ້ ຫວ່າງເປົ່າ buildin ແມ່ນເຄື່ອງກໍາເນີດທີ່ຜະລິດຜົນຜະລິດສູນ. ໄດ້ ຫວ່າງເປົ່າ ປຸກສ້າງ
backtracks ກັບການສະແດງອອກຂອງເຄື່ອງກໍາເນີດກ່ອນຫນ້າ.

ຟັງຊັນ jq ທັງໝົດສາມາດເປັນເຄື່ອງປັ່ນໄຟໄດ້ໂດຍການໃຊ້ເຄື່ອງສ້າງໃນຕົວ. ມັນກໍ່ເປັນໄປໄດ້
ເພື່ອກໍານົດເຄື່ອງກໍາເນີດໃຫມ່ໂດຍໃຊ້ພຽງແຕ່ recursion ແລະຕົວປະຕິບັດການເຄື່ອງໝາຍຈຸດ. ຖ້າ recursive
ການໂທແມ່ນ (ແມ່ນ) "ຢູ່ໃນຕໍາແຫນ່ງຫາງ" ຫຼັງຈາກນັ້ນເຄື່ອງກໍາເນີດໄຟຟ້າຈະມີປະສິດທິພາບ. ໃນຕົວຢ່າງ
ຂ້າງລຸ່ມນີ້ການໂທ recursive ໂດຍ _ໄລຍະ ຕົວຂອງມັນເອງແມ່ນຢູ່ໃນຕໍາແຫນ່ງຫາງ. ຕົວຢ່າງສະແດງໃຫ້ເຫັນ
ສາມຫົວຂໍ້ຂັ້ນສູງ: ຫາງ recursion, ການກໍ່ສ້າງເຄື່ອງກໍາເນີດໄຟຟ້າ, ແລະຫນ້າທີ່ຍ່ອຍ.

jq ´def range(init; upto; by): def _range: ຖ້າ (ໂດຍ > 0 ແລະ . < upto) ຫຼື (ໂດຍ < 0 ແລະ . > upto) ຫຼັງຈາກນັ້ນ ., (.+by)|_range) ອື່ນ . ສິ້ນສຸດ; ຖ້າໂດຍ == 0 ຫຼັງຈາກນັ້ນ init ອື່ນ init|_range end | ເລືອກ((ໂດຍ > 0 ແລະ . < upto) ຫຼື (ໂດຍ < 0 ແລະ . > upto)); ຊ່ວງ(0; 10; 3).
null
=> 0, 3, 6, 9

jq ´def while(cond; update): def _while: if cond then ., (update | _while) else empty end; _ໃນຂະນະທີ່; [ໃນຂະນະທີ່ (<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

MATH

jq ໃນປັດຈຸບັນມີພຽງແຕ່ IEEE754 double-precision (64-bit) ສະຫນັບສະຫນູນຕົວເລກຈຸດເລື່ອນ.

ນອກ​ຈາກ​ຕົວ​ປະ​ຕິ​ບັດ​ການ​ເລກ​ຄະ​ນິດ​ງ່າຍ​ດາຍ​ເຊັ່ນ​:​ +, jq ຍັງມີຟັງຊັນຄະນິດສາດມາດຕະຖານຫຼາຍທີ່ສຸດ
ຈາກ​ຫ້ອງ​ສະ​ຫມຸດ​ຄະ​ນິດ​ສາດ C​. ຟັງຊັນຄະນິດສາດ C ທີ່ເອົາການໂຕ້ຖຽງການປ້ອນຂໍ້ມູນອັນດຽວ (ຕົວຢ່າງ: ບາບ())
ສາມາດໃຊ້ໄດ້ເປັນຟັງຊັນ jq zero-argument. ຟັງຊັນຄະນິດສາດ C ທີ່ເອົາສອງ input
ການໂຕ້ຖຽງ (ຕົວຢ່າງ: pow()) ສາມາດໃຊ້ໄດ້ເປັນສອງ argument jq function ທີ່ບໍ່ສົນໃຈ ..

ຄວາມພ້ອມຂອງຟັງຊັນທາງຄະນິດສາດມາດຕະຖານແມ່ນຂຶ້ນກັບຄວາມພ້ອມຂອງທີ່ສອດຄ້ອງກັນ
ຟັງຊັນທາງຄະນິດສາດໃນລະບົບປະຕິບັດການຂອງທ່ານແລະຫ້ອງສະຫມຸດຄະນິດສາດ C. ຟັງຊັນຄະນິດສາດບໍ່ສາມາດໃຊ້ໄດ້
ຈະຖືກກໍານົດແຕ່ຈະເພີ່ມຄວາມຜິດພາດ.

ຂ້າພະເຈົ້າ / O

ໃນເວລານີ້ jq ມີການສະຫນັບສະຫນູນຫນ້ອຍທີ່ສຸດສໍາລັບ I / O, ສ່ວນໃຫຍ່ແມ່ນຢູ່ໃນຮູບແບບຂອງການຄວບຄຸມເວລາ
ວັດສະດຸປ້ອນໄດ້ຖືກອ່ານ. ສອງຟັງຊັນ buildins ແມ່ນສະຫນອງໃຫ້ສໍາລັບການນີ້, ການປ້ອນຂໍ້ມູນ ແລະ ວັດສະດຸປ້ອນ, ທີ່ອ່ານ
ຈາກແຫຼ່ງດຽວກັນ (ຕົວຢ່າງ: stdin, ໄຟລ໌ທີ່ມີຊື່ຢູ່ໃນເສັ້ນຄໍາສັ່ງ) ເປັນ jq ຕົວຂອງມັນເອງ. ເຫຼົ່ານີ້
ສອງ buildins, ແລະການດໍາເນີນການອ່ານຂອງ jq ຂອງຕົນເອງ, ສາມາດ interleaved ເຊິ່ງກັນແລະກັນ.

ຫນຶ່ງ builtin ສະຫນອງຄວາມສາມາດຜົນຜະລິດຫນ້ອຍ, debug. (ຈື່ໄວ້ວ່າໂຄງການ jq
ຄ່າຜົນຜະລິດແມ່ນຜົນອອກມາສະເໝີເມື່ອຂໍ້ຄວາມ JSON ເປີດ stdout.) ທ debug builtin ສາມາດມີ
ພຶດຕິກໍາສະເພາະຂອງແອັບພລິເຄຊັນ, ເຊັ່ນ: ສໍາລັບການປະຕິບັດທີ່ນໍາໃຊ້ libjq C API ແຕ່ບໍ່ແມ່ນ.
jq ສາມາດປະຕິບັດໄດ້ເອງ.

ການປ້ອນຂໍ້ມູນ
ສົ່ງຜົນອອກອັນໜຶ່ງອັນໃໝ່.

ວັດສະດຸປ້ອນ
ສົ່ງອອກວັດສະດຸປ້ອນທີ່ຍັງເຫຼືອທັງໝົດ, ແຕ່ລະອັນ.

ນີ້ແມ່ນເປັນປະໂຫຍດຕົ້ນຕໍສໍາລັບການຫຼຸດຜ່ອນການປ້ອນຂໍ້ມູນຂອງໂຄງການ.

debug
ເຮັດໃຫ້ຂໍ້ຄວາມດີບັກໂດຍອ້າງອີງຈາກຄ່າທີ່ປ້ອນເຂົ້າທີ່ຈະຜະລິດ. jq wraps ປະຕິບັດໄດ້
ມູນຄ່າການປ້ອນຂໍ້ມູນກັບ ["ດີບັກ:", ] ແລະພິມນັ້ນແລະແຖວໃຫມ່ໃນ stderr,
ແໜ້ນໜາ. ນີ້ອາດຈະມີການປ່ຽນແປງໃນອະນາຄົດ.

input_filename
ສົ່ງຄືນຊື່ຂອງໄຟລ໌ທີ່ປ້ອນເຂົ້າຖືກກັ່ນຕອງ. ໃຫ້ສັງເກດວ່ານີ້ຈະ
ເຮັດວຽກບໍ່ດີເວັ້ນເສຍແຕ່ jq ເຮັດວຽກຢູ່ໃນທ້ອງຖິ່ນ UTF-8.

input_line_number
ສົ່ງຄືນໝາຍເລກແຖວຂອງການປ້ອນຂໍ້ມູນທີ່ຖືກກັ່ນຕອງໃນປັດຈຸບັນ.

ກະຕືລືລົ້ນ

ມີ -- ກະແສ ທາງ​ເລືອກ jq ສາ​ມາດ​ແຍກ​ຂໍ້​ຄວາມ​ການ​ປ້ອນ​ຂໍ້​ມູນ​ໃນ​ຮູບ​ແບບ​ການ​ສະ​ຕີມ​, ໃຫ້ jq​
ໂປລແກລມເພື່ອເລີ່ມຕົ້ນການປຸງແຕ່ງຂໍ້ຄວາມ JSON ຂະຫນາດໃຫຍ່ໃນທັນທີແທນທີ່ຈະຫຼັງຈາກການວິເຄາະ
ສໍາເລັດ. ຖ້າທ່ານມີຂໍ້ຄວາມ JSON ດຽວທີ່ມີຂະຫນາດ 1GB, ການຖ່າຍທອດມັນຈະຊ່ວຍໃຫ້ທ່ານ
ເພື່ອປຸງແຕ່ງມັນໄວຂຶ້ນ.

ຢ່າງໃດກໍຕາມ, streaming ບໍ່ແມ່ນເລື່ອງງ່າຍທີ່ຈະຈັດການກັບໂຄງການ jq ຈະມີ [ ,
] (ແລະຮູບແບບອື່ນໆຈໍານວນຫນ້ອຍ) ເປັນວັດສະດຸປ້ອນ.

Builin ຫຼາຍອັນໄດ້ຖືກສະຫນອງໃຫ້ເພື່ອເຮັດໃຫ້ການຈັດການສາຍນ້ໍາງ່າຍຂຶ້ນ.

ຕົວຢ່າງຂ້າງລຸ່ມນີ້ໃຊ້ຮູບແບບການຖ່າຍທອດຂອງ [0,[1]], ເຊິ່ງແມ່ນ
[[0],0],[[1,0],1],[[1,0]],[[1]].

ຮູບແບບການຖ່າຍທອດປະກອບມີ [ , ] (ເພື່ອຊີ້ບອກຄ່າ scalar ໃດ, array ຫວ່າງເປົ່າ,
ຫຼືວັດຖຸເປົ່າ), ແລະ [ ] (ເພື່ອຊີ້ບອກຈຸດສິ້ນສຸດຂອງອາເຣ ຫຼືວັດຖຸ). ອະນາຄົດ
ລຸ້ນ jq ແລ່ນດ້ວຍ -- ກະແສ ແລະ -seq ອາດຈະອອກແບບຟອມເພີ່ມເຕີມເຊັ່ນ: ["ຄວາມຜິດພາດ
ຂໍ້ຄວາມ"] ເມື່ອຂໍ້ຄວາມທີ່ປ້ອນເຂົ້າບໍ່ສາມາດແຍກວິເຄາະໄດ້.

truncate_stream(stream_expression)
ບໍລິໂພກຕົວເລກເປັນການປ້ອນຂໍ້ມູນ ແລະຕັດຕົວເລກທີ່ສອດຄ້ອງກັນຂອງອົງປະກອບເສັ້ນທາງຈາກ
ຊ້າຍຂອງຜົນໄດ້ຮັບຂອງການສະແດງນ້ໍາທີ່ໃຫ້.

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

fromstream(stream_expression)
ເອົາຄ່າທີ່ສອດຄ້ອງກັບຜົນໄດ້ຮັບຂອງການສະແດງຜົນຂອງກະແສ.

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

ຖ່າຍທອດ
ໄດ້ ຖ່າຍທອດ builtin outputs ຮູບແບບການຖ່າຍທອດຂອງການປ້ອນຂໍ້ມູນຂອງມັນ.

jq ´. ເປັນ $dot|fromstream($dot|tostream)|.==$dot´
[0,[1,{"a":1},{"b":2}]]
=> ຄວາມຈິງ

ວຽກ

ການມອບໝາຍເຮັດວຽກແຕກຕ່າງກັນເລັກນ້ອຍໃນ jq ກ່ວາພາສາການຂຽນໂປຼແກຼມສ່ວນໃຫຍ່. jq ບໍ່
ຈໍາແນກລະຫວ່າງການອ້າງອິງແລະສໍາເນົາຂອງບາງສິ່ງບາງຢ່າງ - ສອງວັດຖຸຫຼື arrays ແມ່ນ
ສະເໝີກັນ ຫຼື ບໍ່ເທົ່າກັນ, ໂດຍບໍ່ມີແນວຄິດເພີ່ມເຕີມວ່າ “ເປັນວັດຖຸອັນດຽວກັນ” ຫຼື “ບໍ່ແມ່ນ
ວັດຖຸດຽວກັນ."

ຖ້າວັດຖຸມີສອງຊ່ອງຂໍ້ມູນທີ່ເປັນ array, .foo ແລະ . ຄາເຟ, ແລະທ່ານຕື່ມບາງສິ່ງບາງຢ່າງໃສ່
.foo, ຫຼັງຈາກນັ້ນ . ຄາເຟ ຈະບໍ່ໃຫຍ່ຂຶ້ນ. ເຖິງແມ່ນວ່າເຈົ້າຫາກໍ່ຕັ້ງ . ຄາເຟ = .foo. ຖ້າເຈົ້າໃຊ້ແລ້ວ
ການຂຽນໂປລແກລມໃນພາສາເຊັ່ນ Python, Java, Ruby, Javascript, ແລະອື່ນໆ, ຫຼັງຈາກນັ້ນທ່ານສາມາດຄິດ
ຂອງມັນຄືກັບວ່າ jq ເຮັດສໍາເນົາເລິກເຕັມທີ່ຂອງທຸກໆວັດຖຸກ່ອນທີ່ມັນຈະເຮັດການມອບຫມາຍ
(ສໍາລັບການປະຕິບັດ, ຕົວຈິງແລ້ວມັນບໍ່ໄດ້ເຮັດແນວນັ້ນ, ແຕ່ນັ້ນແມ່ນຄວາມຄິດທົ່ວໄປ).

ຕົວປະຕິບັດການມອບໝາຍທັງໝົດໃນ jq ມີຕົວສະແດງເສັ້ນທາງຢູ່ເບື້ອງຊ້າຍມື.

=
ຕົວກອງ .foo = 1 ຈະ​ໃຊ້​ເວ​ລາ​ເປັນ​ການ​ປ້ອນ​ຂໍ້​ມູນ​ວັດ​ຖຸ​ແລະ​ຜະ​ລິດ​ຕະ​ພັນ​ເປັນ​ຜົນ​ຜະ​ລິດ​ວັດ​ຖຸ​ທີ່​ມີ​
ພາກສະຫນາມ "foo" ກໍານົດເປັນ 1. ບໍ່ມີແນວຄິດຂອງ "ດັດແກ້" ຫຼື "ການປ່ຽນແປງ" ບາງສິ່ງບາງຢ່າງໃນ jq -
ຄ່າ jq ທັງໝົດແມ່ນບໍ່ສາມາດປ່ຽນແປງໄດ້. ຕົວ​ຢ່າງ,

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

ຈະບໍ່ມີຜົນຂ້າງຄຽງຂອງການຕັ້ງຄ່າ .bar.baz ທີ່ຈະຕັ້ງເປັນ 1, ເປັນລັກສະນະທີ່ຄ້າຍຄືກັນ
ໂປຣແກຣມໃນ Javascript, Python, Ruby ຫຼືພາສາອື່ນໆ. ບໍ່ຄືກັບພາສາເຫຼົ່ານີ້ (ແຕ່
ເຊັ່ນ​: Haskell ແລະ​ບາງ​ພາ​ສາ​ທີ່​ເຮັດ​ວຽກ​ອື່ນໆ​)​, ບໍ່​ມີ​ແນວ​ຄິດ​ຂອງ​ສອງ​ອາ​ເຣ​ຫຼື​
ວັດຖຸທີ່ເປັນ "ອາເຣດຽວກັນ" ຫຼື "ວັດຖຸດຽວກັນ". ພວກເຂົາສາມາດເທົ່າທຽມກັນ, ຫຼືບໍ່ເທົ່າທຽມກັນ, ແຕ່
ຖ້າ​ຫາກ​ວ່າ​ພວກ​ເຮົາ​ມີ​ການ​ປ່ຽນ​ແປງ​ຫນຶ່ງ​ຂອງ​ເຂົາ​ເຈົ້າ​ໃນ​ສະ​ຖາ​ນະ​ການ​ທີ່​ບໍ່​ມີ​ການ​ປ່ຽນ​ແປງ​ທີ່​ຢູ່​ເບື້ອງ​ຫຼັງ​ຂອງ​ພວກ​ເຮົາ​.

ນີ້ຫມາຍຄວາມວ່າມັນເປັນໄປບໍ່ໄດ້ທີ່ຈະສ້າງມູນຄ່າວົງໃນ jq (ເຊັ່ນ array ທີ່
ອົງປະກອບທໍາອິດແມ່ນຕົວຂອງມັນເອງ). ນີ້ແມ່ນຂ້ອນຂ້າງຕັ້ງໃຈ, ແລະຮັບປະກັນວ່າສິ່ງໃດທີ່ເປັນ jq
ໂຄງການສາມາດຜະລິດສາມາດເປັນຕົວແທນໃນ JSON.

ໃຫ້ສັງເກດວ່າເບື້ອງຊ້າຍຂອງ '=' ຫມາຍເຖິງຄ່າໃນ .ທີ່ຢູ່ ດັ່ງນັ້ນ $var.foo = 1 ຈະບໍ່ເຮັດວຽກ
ຕາມທີ່ຄາດໄວ້ ($var.foo ບໍ່ແມ່ນການສະແດງອອກທາງທີ່ຖືກຕ້ອງ ຫຼືເປັນປະໂຫຍດໃນ .); ໃຊ້ $var | .foo = 1
ແທນທີ່ຈະເປັນ.

ຖ້າທາງຂວາມືຂອງ '=' ຜະລິດຫຼາຍຄ່າ, ຫຼັງຈາກນັ້ນສໍາລັບແຕ່ລະຄ່າດັ່ງກ່າວ jq ຈະ
ກໍາ​ນົດ​ເສັ້ນ​ທາງ​ໃນ​ເບື້ອງ​ຊ້າຍ​ມື​ກັບ​ຄ່າ​ແລະ​ຫຼັງ​ຈາກ​ນັ້ນ​ມັນ​ຈະ​ໄດ້​ຮັບ​ຜົນ​ຜະ​ລິດ​ການ​ດັດ​ແກ້​ ..
ຍົກ​ຕົວ​ຢ່າງ, (.a,.b)=ລະດັບ(2​) ຜົນໄດ້ຮັບ {"a":0,b":0}, ຫຼັງຈາກນັ້ນ {"a":1,b":1}. "ການປັບປຸງ"
ແບບຟອມການມອບຫມາຍ (ເບິ່ງຂ້າງລຸ່ມນີ້) ຢ່າເຮັດແນວນີ້.

ໃຫ້ສັງເກດວ່າ .a,.b=0 ບໍ່ໄດ້ກໍານົດ .a ແລະ .b, ແຕ່ (.a,.b)=0 ກໍານົດທັງສອງ.

|=
ເຊັ່ນດຽວກັນກັບຕົວປະຕິບັດການມອບຫມາຍ ´=´, jq ສະຫນອງຕົວປະຕິບັດການ "ປັບປຸງ" ´|=´, ເຊິ່ງ.
ເອົາການກັ່ນຕອງຢູ່ເບື້ອງຂວາມືແລະເຮັດວຽກອອກມູນຄ່າໃຫມ່ສໍາລັບຊັບສິນຂອງ .
ຖືກມອບຫມາຍໃຫ້ໂດຍການແລ່ນຄ່າເກົ່າຜ່ານການສະແດງນີ້. ຕົວຢ່າງ, .foo |=
.+1 ຈະສ້າງວັດຖຸທີ່ມີຊ່ອງຂໍ້ມູນ "foo" ທີ່ຕັ້ງເປັນ "foo" ບວກ 1 ຂອງ input.

ຕົວຢ່າງນີ້ຄວນສະແດງໃຫ້ເຫັນຄວາມແຕກຕ່າງລະຫວ່າງ ´=´ ແລະ ´|=´:

ສະໜອງການປ້ອນຂໍ້ມູນ ´{"a": {"b": 10}, "b": 20}´ ໃຫ້ກັບບັນດາໂຄງການ:

.a = .b .a |= .b

ອະດີດຈະກໍານົດ "a" ພາກສະຫນາມຂອງວັດສະດຸປ້ອນກັບພາກສະຫນາມ "b" ຂອງການປ້ອນຂໍ້ມູນ, ແລະຜະລິດ
ຜົນຜະລິດ {"a": 20}. ອັນສຸດທ້າຍຈະຕັ້ງຊ່ອງຂໍ້ມູນ "a" ຂອງການປ້ອນຂໍ້ມູນໃສ່ຊ່ອງຂໍ້ມູນ "a".
"b" ພາກສະຫນາມ, ການຜະລິດ {"a": 10}.

ເບື້ອງຊ້າຍມືສາມາດເປັນການສະແດງອອກທາງທົ່ວໄປໃດໆ; ເບິ່ງ ເສັ້ນທາງ().

ໃຫ້ສັງເກດວ່າເບື້ອງຊ້າຍຂອງ ´|=´ ຫມາຍເຖິງຄ່າໃນ .ທີ່ຢູ່ ດັ່ງນັ້ນ $var.foo |= . + 1 ຈະບໍ່
ເຮັດວຽກຕາມທີ່ຄາດໄວ້ ($var.foo ບໍ່ແມ່ນການສະແດງອອກທາງທີ່ຖືກຕ້ອງ ຫຼືເປັນປະໂຫຍດໃນ .); ໃຊ້ $var | .foo
|= . + 1 ແທນທີ່ຈະເປັນ.

ຖ້າທາງຂວາມືອອກຫຼາຍຄ່າ, ມີພຽງແຕ່ອັນສຸດທ້າຍເທົ່ານັ້ນທີ່ຈະຖືກນໍາໃຊ້.

jq ´ (..|select(type=="boolean")) |= ຖ້າ . ຫຼັງຈາກນັ້ນ 1 ອື່ນ 0 ສິ້ນສຸດ'
[ຈິງ, ຜິດ, [5, ຈິງ, [ຈິງ, [ຜິດ]], ຜິດ]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, //, %=, // =
jq ມີຕົວປະຕິບັດການຈໍານວນຫນ້ອຍຂອງແບບຟອມ a op= b, ເຊິ່ງທັງຫມົດແມ່ນເທົ່າກັບ a |= . op b. ສະນັ້ນ,
+= 1 ສາມາດໃຊ້ເພື່ອເພີ່ມມູນຄ່າ.

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

ສະລັບສັບຊ້ອນ ວຽກມອບ ໝາຍ
ມີຫຼາຍສິ່ງຫຼາຍຢ່າງຖືກອະນຸຍາດໃຫ້ຢູ່ເບື້ອງຊ້າຍຂອງວຽກ jq ຫຼາຍກວ່າສ່ວນໃຫຍ່
ພາສາ. ພວກ​ເຮົາ​ໄດ້​ເຫັນ​ແລ້ວ​ການ​ເຂົ້າ​ເຖິງ​ພາກ​ສະ​ຫນາມ​ງ່າຍ​ດາຍ​ຢູ່​ເບື້ອງ​ຊ້າຍ​ມື​, ແລະ​ມັນ​ບໍ່​ແມ່ນ​
ແປກໃຈທີ່ array ເຂົ້າເຖິງເຮັດວຽກເຊັ່ນດຽວກັນ:

.posts[0].title = "ຄູ່ມື JQ"

ສິ່ງທີ່ອາດຈະແປກໃຈແມ່ນວ່າການສະແດງອອກທາງຊ້າຍອາດຈະຜະລິດຫຼາຍ
ຜົນໄດ້ຮັບ, ໂດຍອ້າງອີງໃສ່ຈຸດທີ່ແຕກຕ່າງກັນໃນເອກະສານການປ້ອນຂໍ້ມູນ:

.posts[].comments |= . + ["ອັນ​ນີ້​ຍິ່ງ​ໃຫຍ່"]

ຕົວຢ່າງນັ້ນຕື່ມຂໍ້ຄວາມ "ອັນນີ້ດີ" ກັບອາເຣ "ຄຳເຫັນ" ຂອງແຕ່ລະໂພສໃນ
input (ບ່ອນທີ່ input ແມ່ນວັດຖຸທີ່ມີພາກສະຫນາມ "posts" ເຊິ່ງເປັນ array ຂອງ posts).

ເມື່ອ jq ພົບກັບການມອບຫມາຍເຊັ່ນ 'a = b', ມັນຈະບັນທຶກ "ເສັ້ນທາງ" ທີ່ຈະເລືອກເອົາ
ສ່ວນຫນຶ່ງຂອງເອກະສານການປ້ອນຂໍ້ມູນໃນຂະນະທີ່ດໍາເນີນການ a. ຫຼັງຈາກນັ້ນ, ເສັ້ນທາງນີ້ຖືກນໍາໃຊ້ເພື່ອຊອກຫາພາກສ່ວນໃດ
ວັດສະດຸປ້ອນເພື່ອປ່ຽນແປງໃນຂະນະທີ່ປະຕິບັດການມອບໝາຍ. ການກັ່ນຕອງໃດອາດຈະຖືກນໍາໃຊ້ໃນ
ຊ້າຍມືຂອງເທົ່າກັບ - ເສັ້ນທາງໃດທີ່ມັນເລືອກຈາກການປ້ອນຂໍ້ມູນຈະເປັນບ່ອນທີ່
ການມອບຫມາຍແມ່ນປະຕິບັດ.

ນີ້ແມ່ນການດໍາເນີນງານທີ່ມີປະສິດທິພາບຫຼາຍ. ສົມມຸດວ່າພວກເຮົາຕ້ອງການເພີ່ມຄໍາຄິດຄໍາເຫັນໃສ່ບົດຄວາມ blog, ການນໍາໃຊ້
ການປ້ອນຂໍ້ມູນ "blog" ດຽວກັນຂ້າງເທິງ. ເວລານີ້, ພວກເຮົາພຽງແຕ່ຕ້ອງການຄໍາເຫັນກ່ຽວກັບຂໍ້ຄວາມທີ່ຂຽນໂດຍ
"stedolan". ພວກເຮົາສາມາດຊອກຫາຂໍ້ຄວາມເຫຼົ່ານັ້ນໂດຍໃຊ້ຫນ້າທີ່ "ເລືອກ" ທີ່ອະທິບາຍກ່ອນຫນ້ານີ້:

.posts[] | select.author == "stedolan")

ເສັ້ນທາງທີ່ສະຫນອງໃຫ້ໂດຍການປະຕິບັດງານນີ້ຊີ້ໃຫ້ເຫັນເຖິງແຕ່ລະຂໍ້ຄວາມທີ່ "stedolan" ຂຽນ, ແລະ
ພວກ​ເຮົາ​ສາ​ມາດ​ໃຫ້​ຄໍາ​ເຫັນ​ຂອງ​ເຂົາ​ເຈົ້າ​ແຕ່​ລະ​ຄົນ​ໃນ​ວິ​ທີ​ການ​ທີ່​ພວກ​ເຮົາ​ໄດ້​ເຮັດ​ກ່ອນ​ຫນ້າ​ນີ້​:

(.posts[] | select.author == "stedolan") | .comments) |=
. + ["ຂີ້ຮ້າຍ."]

MODULES

jq ມີລະບົບຫ້ອງສະຫມຸດ / ໂມດູນ. ໂມດູນແມ່ນໄຟລ໌ທີ່ມີຊື່ລົງທ້າຍ .jq.

ໂມດູນທີ່ນໍາເຂົ້າໂດຍໂຄງການແມ່ນຊອກຫາຢູ່ໃນເສັ້ນທາງຄົ້ນຫາໃນຕອນຕົ້ນ (ເບິ່ງຂ້າງລຸ່ມນີ້). ໄດ້
ການນໍາເຂົ້າ ແລະ ປະກອບດ້ວຍ ຄໍາສັ່ງອະນຸຍາດໃຫ້ຜູ້ນໍາເຂົ້າປ່ຽນແປງເສັ້ນທາງນີ້.

ເສັ້ນທາງໃນເສັ້ນທາງຄົ້ນຫາແມ່ນຂຶ້ນກັບການທົດແທນຕ່າງໆ.

ສໍາລັບເສັ້ນທາງທີ່ເລີ່ມຕົ້ນດ້ວຍ "~/", ໄດເລກະທໍລີເຮືອນຂອງຜູ້ໃຊ້ຈະຖືກປ່ຽນແທນດ້ວຍ "~".

ສໍາລັບເສັ້ນທາງທີ່ເລີ່ມຕົ້ນດ້ວຍ "$ORIGIN/", ເສັ້ນທາງຂອງ jq executable ແມ່ນປ່ຽນແທນ.
"$ORIGIN".

ສໍາລັບເສັ້ນທາງທີ່ເລີ່ມຕົ້ນດ້ວຍ "./" ຫຼືເສັ້ນທາງທີ່ເປັນ ".", ເສັ້ນທາງຂອງໄຟລ໌ລວມທັງ
ແທນ "." ສໍາລັບບັນດາໂຄງການລະດັບສູງສຸດທີ່ໃຫ້ຢູ່ໃນເສັ້ນຄໍາສັ່ງ, ປະຈຸບັນ
ໄດເລກະທໍລີຖືກນໍາໃຊ້.

ຄໍາສັ່ງນໍາເຂົ້າທາງເລືອກສາມາດກໍານົດເສັ້ນທາງຄົ້ນຫາທີ່ຄ່າເລີ່ມຕົ້ນຖືກຕື່ມໃສ່.

ເສັ້ນທາງຄົ້ນຫາເລີ່ມຕົ້ນແມ່ນເສັ້ນທາງຄົ້ນຫາທີ່ມອບໃຫ້ -L ທາງເລືອກແຖວຄໍາສັ່ງ, ອື່ນ
["~/.jq", "$ORIGIN/../lib/jq", "$ORIGIN/../ lib"].

ອົງປະກອບເສັ້ນທາງສະຕຣິງ null ແລະຫວ່າງເປົ່າຢຸດການປະມວນຜົນເສັ້ນທາງການຊອກຫາ.

ການຂຶ້ນກັບເສັ້ນທາງທີ່ກ່ຽວຂ້ອງ "foo/bar" ຈະຖືກຄົ້ນຫາໃນ "foo/bar.jq" ແລະ
"foo/bar/bar.jq" ໃນເສັ້ນທາງການຊອກຫາທີ່ໃຫ້. ນີ້ແມ່ນມີຈຸດປະສົງເພື່ອໃຫ້ໂມດູນຖືກວາງໄວ້
ໃນໄດເລກະທໍລີພ້ອມກັບ, ສໍາລັບການຍົກຕົວຢ່າງ, ໄຟລ໌ຄວບຄຸມສະບັບ, ໄຟລ໌ README, ແລະອື່ນໆ,
ແຕ່ຍັງອະນຸຍາດໃຫ້ສໍາລັບໂມດູນໄຟລ໌ດຽວ.

ອົງປະກອບຕິດຕໍ່ກັນທີ່ມີຊື່ດຽວກັນແມ່ນບໍ່ອະນຸຍາດໃຫ້ຫຼີກເວັ້ນຄວາມບໍ່ແນ່ນອນ (ຕົວຢ່າງ:
"foo/foo").

ຍົກຕົວຢ່າງ, ກັບ -L$HOME/.jq ໂມດູນ ຟູ ສາມາດພົບເຫັນຢູ່ໃນ $HOME/.jq/foo.jq ແລະ
$HOME/.jq/foo/foo.jq.

ຖ້າ "$HOME/.jq" ເປັນໄຟລ໌, ມັນມາຈາກໂຄງການຕົ້ນຕໍ.

ການນໍາເຂົ້າ RelativePathString as NAME [ ];
ນໍາເຂົ້າໂມດູນທີ່ພົບເຫັນຢູ່ໃນເສັ້ນທາງທີ່ໃຫ້ທຽບກັບໄດເລກະທໍລີໃນເສັ້ນທາງຄົ້ນຫາ. A ".jq"
ຄຳຕໍ່ທ້າຍຈະຖືກເພີ່ມໃສ່ສະຕຣິງເສັ້ນທາງທີ່ກ່ຽວຂ້ອງ. ສັນຍາລັກຂອງໂມດູນແມ່ນນໍາຫນ້າດ້ວຍ
"NAME::".

metadata ທາງເລືອກຕ້ອງເປັນການສະແດງ jq ຄົງທີ່. ມັນຄວນຈະເປັນວັດຖຸທີ່ມີກະແຈ
ເຊັ່ນ "ຫນ້າທໍາອິດ" ແລະອື່ນໆ. ໃນເວລານີ້ jq ໃຊ້ພຽງແຕ່ "ຄົ້ນຫາ" ຄີ / ຄ່າຂອງ
metadata. metadata ແມ່ນຍັງເຮັດໃຫ້ຜູ້ໃຊ້ສາມາດໃຊ້ໄດ້ຜ່ານ ໂມດູນເມຕາ ກໍ່ສ້າງ.

ປຸ່ມ "ຄົ້ນຫາ" ໃນ metadata, ຖ້າມີ, ຄວນມີ string ຫຼື array value (array
ຂອງສາຍ); ນີ້​ແມ່ນ​ເສັ້ນ​ທາງ​ການ​ຊອກ​ຫາ​ທີ່​ຈະ​ນໍາ​ຫນ້າ​ກັບ​ເສັ້ນ​ທາງ​ການ​ຊອກ​ຫາ​ລະ​ດັບ​ເທິງ​.

ປະກອບດ້ວຍ RelativePathString [ ];
ນໍາເຂົ້າໂມດູນທີ່ພົບເຫັນຢູ່ໃນເສັ້ນທາງທີ່ໃຫ້ທຽບກັບໄດເລກະທໍລີໃນເສັ້ນທາງຄົ້ນຫາຄືກັບວ່າມັນ
ໄດ້ຖືກລວມເຂົ້າໃນສະຖານທີ່. ຄຳຕໍ່ທ້າຍ ".jq" ຈະຖືກເພີ່ມໃສ່ສະຕຣິງເສັ້ນທາງທີ່ກ່ຽວຂ້ອງ. ໄດ້
ສັນຍາລັກຂອງໂມດູນຖືກນໍາເຂົ້າເຂົ້າໄປໃນ namespace ຂອງຜູ້ໂທຄືກັບວ່າເນື້ອຫາຂອງໂມດູນມີ
ໄດ້ຖືກລວມເຂົ້າໂດຍກົງ.

metadata ທາງເລືອກຕ້ອງເປັນການສະແດງ jq ຄົງທີ່. ມັນຄວນຈະເປັນວັດຖຸທີ່ມີກະແຈ
ເຊັ່ນ "ຫນ້າທໍາອິດ" ແລະອື່ນໆ. ໃນເວລານີ້ jq ໃຊ້ພຽງແຕ່ "ຄົ້ນຫາ" ຄີ / ຄ່າຂອງ
metadata. metadata ແມ່ນຍັງເຮັດໃຫ້ຜູ້ໃຊ້ສາມາດໃຊ້ໄດ້ຜ່ານ ໂມດູນເມຕາ ກໍ່ສ້າງ.

ການນໍາເຂົ້າ RelativePathString as $NAME [ ];
ນໍາເຂົ້າໄຟລ໌ JSON ທີ່ພົບເຫັນຢູ່ໃນເສັ້ນທາງທີ່ໃຫ້ທຽບກັບໄດເລກະທໍລີໃນເສັ້ນທາງຄົ້ນຫາ. ກ
ຄຳຕໍ່ທ້າຍ ".json" ຈະຖືກເພີ່ມໃສ່ສະຕຣິງເສັ້ນທາງທີ່ກ່ຽວຂ້ອງ. ຂໍ້ມູນຂອງໄຟລ໌ຈະເປັນ
ມີຢູ່ໃນ $NAME::NAME.

metadata ທາງເລືອກຕ້ອງເປັນການສະແດງ jq ຄົງທີ່. ມັນຄວນຈະເປັນວັດຖຸທີ່ມີກະແຈ
ເຊັ່ນ "ຫນ້າທໍາອິດ" ແລະອື່ນໆ. ໃນເວລານີ້ jq ໃຊ້ພຽງແຕ່ "ຄົ້ນຫາ" ຄີ / ຄ່າຂອງ
metadata. metadata ແມ່ນຍັງເຮັດໃຫ້ຜູ້ໃຊ້ສາມາດໃຊ້ໄດ້ຜ່ານ ໂມດູນເມຕາ ກໍ່ສ້າງ.

ປຸ່ມ "ຄົ້ນຫາ" ໃນ metadata, ຖ້າມີ, ຄວນມີ string ຫຼື array value (array
ຂອງສາຍ); ນີ້​ແມ່ນ​ເສັ້ນ​ທາງ​ການ​ຊອກ​ຫາ​ທີ່​ຈະ​ນໍາ​ຫນ້າ​ກັບ​ເສັ້ນ​ທາງ​ການ​ຊອກ​ຫາ​ລະ​ດັບ​ເທິງ​.

ໂມດູນ ;
ຄໍາສັ່ງນີ້ແມ່ນທາງເລືອກທັງຫມົດ. ມັນບໍ່ຈໍາເປັນສໍາລັບການປະຕິບັດງານທີ່ເຫມາະສົມ. ມັນໃຫ້ບໍລິການ
ພຽງແຕ່ຈຸດປະສົງຂອງການສະຫນອງ metadata ທີ່ສາມາດອ່ານໄດ້ກັບ ໂມດູນເມຕາ ກໍ່ສ້າງ.

metadata ຈະຕ້ອງເປັນການສະແດງ jq ຄົງທີ່. ມັນຄວນຈະເປັນວັດຖຸທີ່ມີກະແຈເຊັ່ນ
"ຫນ້າທໍາອິດ". ໃນເວລານີ້ jq ບໍ່ໄດ້ໃຊ້ metadata ນີ້, ແຕ່ມັນມີໃຫ້ຜູ້ໃຊ້
ຜ່ານ ໂມດູນເມຕາ ກໍ່ສ້າງ.

ໂມດູນເມຕາ
ເອົາຊື່ໂມດູນເປັນ input ແລະ outputs metadata ຂອງໂມດູນເປັນວັດຖຸ, ກັບ
ການນໍາເຂົ້າຂອງໂມດູນ (ລວມທັງ metadata) ເປັນຄ່າ array ສໍາລັບລະຫັດ "deps".

ໂປຣແກຣມສາມາດໃຊ້ອັນນີ້ເພື່ອສອບຖາມ metadata ຂອງໂມດູນ, ເຊິ່ງເຂົາເຈົ້າສາມາດນຳໃຊ້ໄດ້
ຕົວຢ່າງ, ຊອກຫາ, ດາວໂຫລດ ແລະຕິດຕັ້ງການເພິ່ງພາອາໄສທີ່ຂາດຫາຍໄປ.

ໃຊ້ jq ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net