jq - ออนไลน์ในคลาวด์

โครงการ:

ชื่อ

jq - ตัวประมวลผล JSON บรรทัดคำสั่ง

เรื่องย่อ

jq [ตัวเลือก... ] กรอง [ไฟล์... ]

jq สามารถแปลง JSON ได้หลากหลายรูปแบบ โดยเลือก วนซ้ำ ลดขนาด และอื่นๆ
การจัดการเอกสาร JSON ตัวอย่างเช่น การรันคำสั่ง jq ´แผนที่(.price) | เพิ่ม จะ
นำอาร์เรย์ของออบเจ็กต์ JSON เป็นอินพุตและส่งคืนผลรวมของฟิลด์ "ราคา"

jq สามารถยอมรับการป้อนข้อความได้เช่นกัน แต่โดยค่าเริ่มต้น jq อ่านสตรีมของเอนทิตี JSON
(รวมทั้งตัวเลขและตัวอักษรอื่นๆ) จาก สเตดิน. ต้องใช้ช่องว่างเพื่อแยกเท่านั้น
เอนทิตีเช่น 1 และ 2 และจริงและเท็จ หนึ่งหรือมากกว่า ไฟล์ อาจระบุได้ ซึ่ง
กรณี jq จะอ่านข้อมูลจากสิ่งเหล่านั้นแทน

พื้นที่ ตัวเลือก อธิบายไว้ใน เรียก JQ ส่วน; ส่วนใหญ่เกี่ยวข้องกับอินพุตและเอาต์พุต
การจัดรูปแบบ กรอง ถูกเขียนด้วยภาษา jq และระบุวิธีการแปลงไฟล์
ไฟล์อินพุตหรือเอกสาร

กรอง

โปรแกรม jq เป็น "ตัวกรอง": รับอินพุตและสร้างเอาต์พุต มีจำนวนมาก
ตัวกรองในตัวสำหรับแยกเขตข้อมูลเฉพาะของวัตถุหรือแปลงตัวเลขเป็น
สตริงหรืองานมาตรฐานอื่นๆ

ตัวกรองสามารถรวมกันได้หลายวิธี - คุณสามารถวางเอาต์พุตของตัวกรองเดียวลงใน
ตัวกรองอื่น หรือรวบรวมผลลัพธ์ของตัวกรองลงในอาร์เรย์

ตัวกรองบางตัวสร้างผลลัพธ์หลายรายการ เช่น มีตัวกรองที่สร้าง . ทั้งหมด
องค์ประกอบของอาร์เรย์อินพุต การวางตัวกรองนั้นลงในวินาทีจะเรียกใช้ตัวกรองที่สองสำหรับ
แต่ละองค์ประกอบของอาร์เรย์ โดยทั่วไป สิ่งที่จะทำด้วยการวนซ้ำและการวนซ้ำ
ในภาษาอื่นทำได้เพียงแค่ติดตัวกรองเข้าด้วยกันใน jq

สิ่งสำคัญคือต้องจำไว้ว่าทุกตัวกรองมีอินพุตและเอาต์พุต แม้แต่ตัวอักษร
เช่น "สวัสดี" หรือ 42 เป็นตัวกรอง - พวกเขารับอินพุต แต่สร้างตัวอักษรเดียวกับ
เอาท์พุท การดำเนินการที่รวมตัวกรองสองตัวเข้าด้วยกัน เช่น การเพิ่มเติม โดยทั่วไปจะป้อนอินพุตเดียวกัน
ทั้งสองอย่างและรวมผลลัพธ์เข้าด้วยกัน ดังนั้น คุณสามารถใช้ตัวกรองเฉลี่ยเป็น เพิ่ม / ความยาว
- ป้อนอาร์เรย์อินพุตทั้งสองไปที่ เพิ่ม ตัวกรองและ ความยาว กรองแล้วดำเนินการ
แผนก

แต่นั่นเป็นการก้าวไปข้างหน้าของตัวเราเอง :) มาเริ่มกันด้วยสิ่งที่ง่ายกว่ากัน:

เรียก JQ

ตัวกรอง jq ทำงานบนสตรีมข้อมูล JSON อินพุตของ jq ถูกแยกวิเคราะห์เป็นลำดับของ
ค่า JSON ที่คั่นด้วยช่องว่างซึ่งส่งผ่านตัวกรองที่ให้มาที่a
เวลา. เอาต์พุตของตัวกรองถูกเขียนเป็นมาตรฐาน อีกครั้งตามลำดับของ
ข้อมูล JSON ที่คั่นด้วยช่องว่าง

หมายเหตุ: เป็นสิ่งสำคัญที่ต้องคำนึงถึงกฎการเสนอราคาของเชลล์ ตามกฎทั่วไปแล้ว เป็นการดีที่สุดที่จะ
อ้างเสมอ (ด้วยอักขระอัญประกาศเดี่ยว) โปรแกรม jq เนื่องจากอักขระจำนวนมากเกินไปด้วย
ความหมายพิเศษของ jq ก็คือเชลล์ meta-characters เช่นกัน ตัวอย่างเช่น, jq "ฟู" จะล้มเหลวใน
เชลล์ Unix ส่วนใหญ่เพราะนั่นจะเหมือนกับ jq fooซึ่งโดยทั่วไปจะล้มเหลว
เพราะ foo is ไม่ กำหนด. เมื่อใช้ command shell ของ Windows (cmd.exe) จะเป็นการดีที่สุดที่จะ
ใช้เครื่องหมายอัญประกาศคู่รอบโปรแกรม jq ของคุณเมื่อได้รับบนบรรทัดคำสั่ง (แทน -f
โปรแกรมไฟล์ ตัวเลือก) แต่แล้วเครื่องหมายคำพูดคู่ในโปรแกรม jq จำเป็นต้องหลีกเลี่ยงแบ็กสแลช

คุณสามารถส่งผลต่อวิธีที่ jq ​​อ่านและเขียนอินพุตและเอาต์พุตโดยใช้ command-line
ตัวเลือก:

· --รุ่น:

ส่งออกเวอร์ชัน jq และออกด้วยศูนย์

· --seq:

ใช้ แอปพลิเคชัน/json-seq โครงร่างประเภท MIME สำหรับแยกข้อความ JSON ในอินพุตของ jq
และผลผลิต ซึ่งหมายความว่ามีการพิมพ์อักขระ ASCII RS (ตัวคั่นบันทึก) ก่อน
แต่ละค่าบนเอาต์พุตและ ASCII LF (การป้อนบรรทัด) จะถูกพิมพ์หลังจากทุกเอาต์พุต ป้อนข้อมูล
ข้อความ JSON ที่แยกวิเคราะห์ไม่สำเร็จจะถูกละเว้น (แต่ถูกเตือน) โดยจะละทิ้งทั้งหมด
อินพุตต่อมาจนถึง RS ถัดไป สิ่งนี้ยังแยกวิเคราะห์เอาต์พุตของ jq โดยไม่มี
--seq ตัวเลือก

· --ลำธาร:

แยกวิเคราะห์อินพุตในรูปแบบการสตรีม เอาต์พุตอาร์เรย์ของค่าพาธและลีฟ
(สเกลาร์และอาร์เรย์ว่างหรือวัตถุว่าง) ตัวอย่างเช่น, "NS" จะกลายเป็น [[],"NS"]และ
[[],"a",["b"]] จะกลายเป็น [[0],[]], [1],"ก"]และ [[1,0],"ข"].

สิ่งนี้มีประโยชน์สำหรับการประมวลผลอินพุตขนาดใหญ่มาก ใช้สิ่งนี้ร่วมกับ
การกรองและ ลด และ แต่ละ ไวยากรณ์เพื่อลดอินพุตขนาดใหญ่แบบค่อยเป็นค่อยไป

· --น้ำลายไหล/-s:

แทนที่จะรันตัวกรองสำหรับวัตถุ JSON แต่ละรายการในอินพุต ให้อ่านอินพุตทั้งหมด
สตรีมไปยังอาร์เรย์ขนาดใหญ่และเรียกใช้ตัวกรองเพียงครั้งเดียว

· --raw อินพุต/-R:

อย่าแยกวิเคราะห์อินพุตเป็น JSON ข้อความแต่ละบรรทัดจะถูกส่งไปยังตัวกรองแทน a
สตริง ถ้ารวมกับ --น้ำลายไหลจากนั้นอินพุตทั้งหมดจะถูกส่งไปยังตัวกรองเป็น a
สายเดี่ยวยาว.

· --null-อินพุต/-n:

อย่าอ่านข้อมูลใด ๆ เลย! ตัวกรองจะทำงานเมื่อใช้ โมฆะ เป็นอินพุต
สิ่งนี้มีประโยชน์เมื่อใช้ jq เป็นเครื่องคิดเลขอย่างง่าย หรือสร้างข้อมูล JSON จาก
เกา.

· --กะทัดรัด-เอาท์พุต / -c:

โดยค่าเริ่มต้น jq สวยพิมพ์เอาต์พุต JSON การใช้ตัวเลือกนี้จะส่งผลให้มีมากขึ้น
เอาต์พุตที่กะทัดรัดโดยการวางแต่ละอ็อบเจ็กต์ JSON ไว้ในบรรทัดเดียวแทน

· --แท็บ:

ใช้แท็บสำหรับแต่ละระดับการเยื้องแทนช่องว่างสองช่อง

· --เยื้อง n:

ใช้จำนวนช่องว่างที่กำหนด (ไม่เกิน 8) สำหรับการเยื้อง

· --สีเอาท์พุท / -C และ --ขาวดำ-เอาท์พุต / -M:

โดยค่าเริ่มต้น jq จะแสดงสี JSON หากเขียนไปยังเทอร์มินัล คุณสามารถบังคับให้
สร้างสีแม้ว่าจะเขียนไปยังไพพ์หรือไฟล์โดยใช้ -Cและปิดการใช้งานสีด้วย -M.

· --ascii-เอาท์พุท / -a:

jq มักจะส่งออกจุดโค้ด Unicode ที่ไม่ใช่ ASCII เป็น UTF-8 แม้ว่าอินพุตจะถูกระบุ
เป็นลำดับหลีก (เช่น "\u03bc") เมื่อใช้ตัวเลือกนี้ คุณสามารถบังคับ jq to
สร้างเอาต์พุต ASCII บริสุทธิ์ด้วยอักขระที่ไม่ใช่ ASCII ทุกตัวแทนที่ด้วยค่าที่เท่ากัน
ลำดับการหลบหนี

· --ไม่มีบัฟเฟอร์

ฟลัชเอาต์พุตหลังจากพิมพ์วัตถุ JSON แต่ละรายการ (มีประโยชน์หากคุณกำลังไพพ์ช้า
แหล่งข้อมูลลงใน jq และไพพ์เอาต์พุตของ jq ที่อื่น)

· --sort-คีย์ / -S:

ส่งออกฟิลด์ของแต่ละอ็อบเจ็กต์ด้วยคีย์ตามลำดับการเรียงลำดับ

· --ดิบ-เอาท์พุท / -r:

ด้วยตัวเลือกนี้ หากผลลัพธ์ของตัวกรองเป็นสตริง จะถูกเขียนโดยตรง
เป็นเอาต์พุตมาตรฐานแทนที่จะจัดรูปแบบเป็นสตริง JSON พร้อมเครื่องหมายคำพูด นี้สามารถ
มีประโยชน์สำหรับการทำให้ตัวกรอง jq พูดคุยกับระบบที่ไม่ใช่ JSON

· --join-เอาท์พุท / -j:

Like -r แต่ jq จะไม่พิมพ์ขึ้นบรรทัดใหม่หลังจากแต่ละเอาต์พุต

· -f ชื่อไฟล์ / --จากไฟล์ ชื่อไฟล์:

อ่านตัวกรองจากไฟล์แทนที่จะอ่านจากบรรทัดคำสั่ง เช่น awk´s -f ตัวเลือก คุณ
สามารถใช้ ´#´ เพื่อแสดงความคิดเห็นได้เช่นกัน

· -Lไดเรกทอรี / -L ไดเรกทอรี:

นำหน้า ไดเรกทอรี ไปที่รายการค้นหาโมดูล หากใช้ตัวเลือกนี้แสดงว่าไม่มี
ใช้รายการค้นหาในตัว ดูหัวข้อโมดูลด้านล่าง

· -e / --exit-สถานะ:

ตั้งค่าสถานะการออกของ jq เป็น 0 หากค่าเอาต์พุตสุดท้ายไม่ใช่ค่า เท็จ ไม่ โมฆะ,
1 ถ้าค่าเอาต์พุตสุดท้ายเป็นอย่างใดอย่างหนึ่ง เท็จ or โมฆะ, หรือ 4 หากไม่มีผลลัพธ์ที่ถูกต้อง
ผลิต โดยปกติ jq จะออกด้วย 2 หากมีปัญหาการใช้งานหรือข้อผิดพลาดของระบบ 3
หากมีข้อผิดพลาดในการคอมไพล์โปรแกรม jq หรือ 0 หากโปรแกรม jq ทำงาน

· -- หาเรื่อง ชื่อ ความคุ้มค่า:

อ็อพชันนี้ส่งค่าไปยังโปรแกรม jq เป็นตัวแปรที่กำหนดไว้ล่วงหน้า หากคุณเรียกใช้ jq
กับ -- หาเรื่อง foo บาร์แล้ว $ฟู มีอยู่ในโปรแกรมและมีค่า "บาร์".
โปรดทราบว่า ความคุ้มค่า จะถือว่าเป็นสตริง ดังนั้น -- หาเรื่อง foo 123 จะผูกมัด $ฟู ไปยัง "123".

· --argjson ชื่อ JSON-ข้อความ:

ตัวเลือกนี้ส่งผ่านค่าที่เข้ารหัส JSON ไปยังโปรแกรม jq เป็นตัวแปรที่กำหนดไว้ล่วงหน้า ถ้า
คุณเรียกใช้ jq ด้วย --argjson foo 123แล้ว $ฟู มีอยู่ในโปรแกรมและมี
ความคุ้มค่า 123.

· --slurpfile ชื่อตัวแปร ชื่อไฟล์:

ตัวเลือกนี้อ่านข้อความ JSON ทั้งหมดในไฟล์ที่มีชื่อและผูกอาร์เรย์ของ
แยกวิเคราะห์ค่า JSON ไปยังตัวแปรส่วนกลางที่กำหนด หากคุณเรียกใช้ jq ด้วย --argfile foo บาร์,
แล้วก็ $ฟู มีอยู่ในโปรแกรมและมีอาร์เรย์ที่มีองค์ประกอบตรงกับ
ข้อความในไฟล์ชื่อ บาร์.

· --argfile ชื่อตัวแปร ชื่อไฟล์:

ไม่ได้ใช้. ใช้ --slurpfile แทน.

(ตัวเลือกนี้เป็นเหมือน --slurpfileแต่เมื่อไฟล์มีเพียงข้อความเดียว นั่นคือ
ใช้ มิฉะนั้นอาร์เรย์ของข้อความจะถูกใช้เป็นin --slurpfile.)

· --รัน-ทดสอบ [ชื่อไฟล์]:

รันการทดสอบในไฟล์ที่กำหนดหรืออินพุตมาตรฐาน นี่จะต้องเป็นตัวเลือกสุดท้ายที่ได้รับ
และไม่ให้เกียรติตัวเลือกก่อนหน้านี้ทั้งหมด อินพุตประกอบด้วยบรรทัดความคิดเห็น ว่างเปล่า
บรรทัด และบรรทัดโปรแกรมที่ตามด้วยบรรทัดอินพุตหนึ่งบรรทัด เท่ากับจำนวนบรรทัดของเอาต์พุตเท่ากับ are
ที่คาดไว้ (หนึ่งรายการต่อเอาต์พุต) และบรรทัดว่างที่สิ้นสุด การทดสอบความล้มเหลวในการรวบรวม
ขึ้นต้นด้วยบรรทัดที่มีเพียง "%%FAIL" จากนั้นขึ้นบรรทัดที่มีโปรแกรมto
คอมไพล์แล้วบรรทัดที่มีข้อความแสดงข้อผิดพลาดเพื่อเปรียบเทียบกับของจริง

ถูกเตือนว่าตัวเลือกนี้สามารถย้อนกลับอย่างเข้ากันไม่ได้

พื้นฐาน กรอง

.
ตัวกรองที่ง่ายที่สุด (และน่าสนใจน้อยที่สุด) คือ .. นี่คือตัวกรองที่ใช้
อินพุตและผลิตเป็นเอาต์พุตไม่เปลี่ยนแปลง

เนื่องจาก jq โดยปริยายจะพิมพ์เอาท์พุตทั้งหมดออกมาสวย โปรแกรมเรื่องไม่สำคัญนี้จึงเป็นวิธีที่มีประโยชน์ของ
การจัดรูปแบบเอาต์พุต JSON จาก, พูด, โค้ง.

เจค ´.´
"สวัสดีชาวโลก!"
=> "สวัสดีชาวโลก!"

.ฟู .foo.bar
ง่ายที่สุด มีประโยชน์ ตัวกรองคือ .ฟู. เมื่อได้รับวัตถุ JSON (หรือที่เรียกว่าพจนานุกรมหรือแฮช) เป็น
อินพุตจะสร้างค่าที่คีย์ "foo" หรือเป็นค่าว่างหากไม่มีอยู่

หากคีย์มีอักขระพิเศษ คุณต้องล้อมรอบด้วยเครื่องหมายคำพูดคู่ เช่น
นี้: ."foo$".

ตัวกรองของแบบฟอร์ม .foo.bar เทียบเท่ากับ .foo|.บาร์.

jq ´.ฟู´
{"foo": 42, "bar": "ข้อมูลที่น่าสนใจน้อยกว่า"}
=> 42

jq ´.ฟู´
{"notfoo": จริง, "ยังnotfoo": เท็จ}
=> null

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

.ฟู?
เช่นเดียวกับ .ฟูแต่ไม่แสดงผลแม้แต่ข้อผิดพลาดเมื่อ . ไม่ใช่อาร์เรย์หรือวัตถุ

jq ´.ฟู?´
{"foo": 42, "bar": "ข้อมูลที่น่าสนใจน้อยกว่า"}
=> 42

jq ´.ฟู?´
{"notfoo": จริง, "ยังnotfoo": เท็จ}
=> null

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

jq ´[.ฟู?]´
[1,2]
=> []

.[ ], .[2] .[10:15]
คุณยังสามารถค้นหาเขตข้อมูลของวัตถุโดยใช้ไวยากรณ์เช่น .["ฟู"] (.foo ด้านบนคือ a
ฉบับย่อนี้) สิ่งนี้ใช้ได้กับอาร์เรย์เช่นกัน หากคีย์เป็นจำนวนเต็ม
อาร์เรย์เป็นแบบ zero-based (เช่น javascript) ดังนั้น . [2] ส่งคืนองค์ประกอบที่สามของอาร์เรย์

พื้นที่ .[10:15] ไวยากรณ์สามารถใช้เพื่อส่งคืนอาร์เรย์ย่อยของอาร์เรย์หรือสตริงย่อยของสตริง
อาร์เรย์ที่ส่งคืนโดย .[10:15] จะมีความยาว 5 ประกอบด้วยองค์ประกอบจากดัชนี 10
(รวม) ถึงดัชนี 15 (ไม่รวม) ดัชนีใดดัชนีหนึ่งอาจเป็นค่าลบ (ในกรณีนี้ ให้นับ
ย้อนกลับจากจุดสิ้นสุดของอาร์เรย์) หรือละเว้น (ซึ่งในกรณีนี้หมายถึงการเริ่มต้นหรือ
ท้ายอาร์เรย์)

พื้นที่ . [2] ไวยากรณ์สามารถใช้เพื่อส่งคืนองค์ประกอบที่ดัชนีที่กำหนด ดัชนีติดลบคือ
อนุญาตโดย -1 หมายถึงองค์ประกอบสุดท้าย -2 หมายถึงองค์ประกอบถัดจากองค์ประกอบสุดท้าย
เป็นต้น

พื้นที่ .ฟู วากยสัมพันธ์ใช้ได้เฉพาะกับคีย์เท่านั้น เช่น คีย์ที่เป็นอักขระที่เป็นตัวอักษรและตัวเลขคละกันทั้งหมด
.[ ] ใช้งานได้กับปุ่มที่มีอักขระพิเศษ เช่น ทวิภาคและจุด สำหรับ
ตัวอย่าง .["foo::bar"] และ .["foo.bar"] ทำงานในขณะที่ .foo::บาร์ และ .foo.bar จะไม่

พื้นที่ ? "ตัวดำเนินการ" สามารถใช้กับตัวดำเนินการสไลซ์ได้เช่นกัน เช่น in .[10:15]?ซึ่งผลลัพธ์
ค่าที่อินพุตเป็นแบบแบ่งส่วนได้

เจคิว '.[0]'
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> {"name":"JSON", "ดี":จริง}

เจคิว '.[2]'
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> null

เจคิว ´.[2:4]´
["a","b","c","d","e"]
=> ["c", "d"]

เจคิว ´.[2:4]´
"abcdefghi"
=> "ซีดี"

เจคิว ´.[:3]´
["a","b","c","d","e"]
=> ["a", "b", "c"]

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

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

-
ถ้าคุณใช้ .[ดัชนี] ไวยากรณ์ แต่ละเว้นดัชนีทั้งหมดก็จะกลับ ทั้งหมด ของ
องค์ประกอบของอาร์เรย์ วิ่ง - ด้วยการป้อนข้อมูล [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

-
Like -แต่จะไม่มีข้อผิดพลาดใด ๆ ออกมาหาก ไม่ใช่อาร์เรย์หรือวัตถุ

,
หากตัวกรองสองตัวคั่นด้วยเครื่องหมายจุลภาค อินพุตจะถูกป้อนเข้าทั้งสองและตรงนั้น
จะเป็นหลายเอาต์พุต: อันดับแรก เอาต์พุตทั้งหมดที่สร้างโดยนิพจน์ด้านซ้าย และ
จากนั้นผลลัพธ์ทั้งหมดที่ผลิตโดยด้านขวา ตัวอย่างเช่น filter .ฟู .คาเฟ่ผลิต
ทั้งช่อง "foo" และช่อง "bar" เป็นเอาต์พุตแยกกัน

jq ´.ฟู, .bar´
{"foo": 42, "bar": "อย่างอื่น", "baz": true}
=> 42 "อย่างอื่น"

jq ´.ผู้ใช้, .projects[]´
{"user":"stedolan", "projects": ["jq", "wikiflow"]}
=> "stedolan", "jq", "wikiflow"

เจคิว '.[4,2]'
["a","b","c","d","e"]
=> "อี", "ค"

|
The | โอเปอเรเตอร์รวมตัวกรองสองตัวโดยป้อนเอาต์พุตของตัวกรองทางด้านซ้ายลงใน
อินพุตด้านขวา มันค่อนข้างเหมือนกับไพพ์ของเชลล์ Unix if
คุณคุ้นเคยกับสิ่งนั้น

ถ้าตัวทางซ้ายได้ผลลัพธ์หลายตัว ตัวทางขวาจะถูกเรียกใช้สำหรับ
แต่ละผลลัพธ์เหล่านั้น ดังนั้น นิพจน์ - | .ฟู ดึงฟิลด์ "foo" ของแต่ละ
องค์ประกอบของอาร์เรย์อินพุต

jq ´.[] | .ชื่อ
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> "JSON", "XML"

ประเภท AND VALUES

jq รองรับประเภทข้อมูลชุดเดียวกันกับ JSON - ตัวเลข, สตริง, บูลีน, อาร์เรย์,
ออบเจ็กต์ (ซึ่งใน JSON-speak เป็นแฮชที่มีเฉพาะคีย์สตริง) และ "null"

บูลีน ค่าว่าง สตริง และตัวเลขถูกเขียนในลักษณะเดียวกับในจาวาสคริปต์ เหมือนกับ
ทุกอย่างอื่นใน jq ค่าง่าย ๆ เหล่านี้รับอินพุตและสร้างเอาต์พุต - 42 คือ
นิพจน์ jq ที่ถูกต้องที่รับอินพุต ละเว้น และส่งคืน 42 แทน

แถว การก่อสร้าง - []
เช่นเดียวกับใน JSON [] ใช้ในการสร้างอาร์เรย์เช่นใน [1,2,3]. องค์ประกอบของอาร์เรย์สามารถ
เป็นนิพจน์ jq ใด ๆ ผลลัพธ์ทั้งหมดที่เกิดจากนิพจน์ทั้งหมดจะถูกรวบรวม
เป็นอาร์เรย์ขนาดใหญ่หนึ่ง คุณสามารถใช้มันเพื่อสร้างอาร์เรย์จากจำนวนค่าที่รู้จัก
(เหมือนใน [.ฟู, .บาร์, .บาส]) หรือเพื่อ "รวบรวม" ผลลัพธ์ทั้งหมดของตัวกรองลงในอาร์เรย์ (as
in [.รายการ[].ชื่อ])

เมื่อคุณเข้าใจตัวดำเนินการ "," คุณสามารถดูไวยากรณ์อาร์เรย์ของ jq ในรูปแบบอื่นได้
แสง: การแสดงออก [1,2,3] ไม่ได้ใช้ไวยากรณ์ในตัวสำหรับอาร์เรย์ที่คั่นด้วยเครื่องหมายจุลภาค
แต่กำลังใช้ .แทน [] ตัวดำเนินการ (รวบรวมผลลัพธ์) ไปยังนิพจน์ 1,2,3 (ซึ่ง
ให้ผลต่างกันสามอย่าง)

หากคุณมีตัวกรอง X ที่ให้ผล XNUMX ประการ แล้วนิพจน์ [X] จะผลิต
ผลลัพธ์เดียว อาร์เรย์ขององค์ประกอบสี่อย่าง

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

วัตถุ - {}
เช่นเดียวกับ JSON {} ใช้สำหรับสร้างวัตถุ (aka พจนานุกรมหรือแฮช) เช่น: {"NS": 42,
"NS": สิบสาม}.

หากปุ่มต่างๆ นั้น "สมเหตุสมผล" (ตัวอักษรทั้งหมด) ก็สามารถเว้นเครื่องหมายคำพูดได้
ค่าสามารถเป็นนิพจน์ใดๆ ก็ได้ (แม้ว่าคุณอาจต้องใส่ในวงเล็บหากมัน'sa
ซับซ้อน) ซึ่งใช้กับอินพุตของนิพจน์ {} (จำไว้ว่าตัวกรองทั้งหมด
มีอินพุตและเอาต์พุต)

{ฟู: .bar}

จะสร้างวัตถุ JSON {"ฟู": สิบสาม} ถ้าได้รับวัตถุ JSON {"แถบ":42, "บาส":43}.
คุณสามารถใช้ตัวเลือกนี้เพื่อเลือกฟิลด์เฉพาะของออบเจกต์: หากอินพุตเป็นออบเจกต์ด้วย
ฟิลด์ "ผู้ใช้", "ชื่อ", "id" และ "เนื้อหา" และคุณเพียงแค่ต้องการ "ผู้ใช้" และ "ชื่อ" คุณสามารถ
เขียน

{ผู้ใช้: .user ชื่อ: .title}

เนื่องจากเป็นเรื่องปกติธรรมดา จึงมีรูปแบบคำสั่งลัด: {ผู้ใช้ หัวข้อ}.

หากนิพจน์หนึ่งสร้างผลลัพธ์หลายรายการ พจนานุกรมหลายพจนานุกรมจะเป็น
ผลิต ถ้าอินพุต's

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

แล้วนิพจน์

{ผู้ใช้ ชื่อ: .titles[]}

จะผลิตสองผลลัพธ์:

{"ผู้ใช้": "สเตโดแลน", "หัวเรื่อง": "JQ ไพรเมอร์"}
{"user":"stedolan", "title": "More JQ"}

การใส่วงเล็บรอบคีย์หมายความว่าจะประเมินเป็นนิพจน์ กับ
อินพุตเดียวกับด้านบน

{(.ผู้ใช้): .titles}

ผลิต

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

jq ´{ผู้ใช้, หัวข้อ: .titles[]}´
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
=> {"user": "sedolan", "title": "JQ Primer"}, {"user":"stedolan", "title": "More JQ"}

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

สร้างขึ้น ผู้ประกอบการ AND ฟังก์ชั่น

โอเปอเรเตอร์ jq บางตัว (เช่น +) ทำสิ่งต่าง ๆ ขึ้นอยู่กับประเภทของพวกมัน
อาร์กิวเมนต์ (อาร์เรย์ ตัวเลข ฯลฯ) อย่างไรก็ตาม jq ไม่เคยทำการแปลงประเภทโดยนัย ถ้า
คุณพยายามเพิ่มสตริงให้กับวัตถุ คุณจะได้รับข้อความแสดงข้อผิดพลาดและไม่มีผลลัพธ์

นอกจากนี้ - +
ตัวดำเนินการ + นำตัวกรองสองตัวมาใช้กับอินพุตเดียวกันและเพิ่ม
ผลลัพธ์ร่วมกัน "การเพิ่ม" หมายถึงอะไรขึ้นอยู่กับประเภทที่เกี่ยวข้อง:

· เบอร์ บวกด้วยเลขคณิตปกติ

· อาร์เรย์ ถูกเพิ่มโดยการต่อกันเป็นอาร์เรย์ที่ใหญ่ขึ้น

· Strings ถูกเพิ่มโดยการรวมเป็นสตริงที่ใหญ่ขึ้น

· วัตถุ ถูกเพิ่มโดยการรวม นั่นคือ การแทรกคู่คีย์-ค่าทั้งหมดจากทั้ง
ออบเจ็กต์ให้เป็นอ็อบเจกต์รวมกันเป็นชิ้นเดียว ถ้าวัตถุทั้งสองมีค่าเท่ากัน
กุญแจ วัตถุทางด้านขวาของ + ชนะ (สำหรับการผสานแบบเรียกซ้ำใช้ * โอเปอเรเตอร์)

โมฆะ สามารถเพิ่มค่าใดๆ ก็ได้ และส่งกลับค่าอื่นๆ ที่ไม่เปลี่ยนแปลง

เจคิว '.a + 1'
{"ก": 7}
=> 8

เจคิว '.a + .b'
{"a": [1,2], "b": [3,4]}
=> [1,2,3,4]

jq '.a + null'
{"ก": 1}
=> 1

เจคิว '.a + 1'
{}
=> 1

jq ´{a: 1} + {b: 2} + {c: 3} + {a: 42}´
โมฆะ
=> {"a": 42, "b": 2, "c": 3}

การลบ - -
เช่นเดียวกับการลบเลขคณิตปกติของตัวเลข - ตัวดำเนินการสามารถใช้กับอาร์เรย์
เพื่อลบองค์ประกอบทั้งหมดของอาร์เรย์ที่สองออกจากอาร์เรย์แรก

เจคิว '4 - .a'
{"ก":3}
=> 1

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

การคูณ แผนก, โมดูล - *, /, และ %
ตัวดำเนินการ infix เหล่านี้ทำงานตามที่คาดไว้เมื่อได้รับสองตัวเลข หารด้วยศูนย์เพิ่ม
ข้อผิดพลาด x % y คำนวณ x โมดูโล y

การคูณสตริงด้วยตัวเลขทำให้เกิดการต่อกันของสตริงนั้นที่มีจำนวนมาก
ครั้ง "NS" * 0 ผลิต โมฆะ.

การหารสตริงด้วยอีกอันหนึ่งจะแยกสตริงแรกโดยใช้ตัวคั่นที่สอง

การคูณสองอ็อบเจ็กต์จะรวมเข้าด้วยกันแบบเรียกซ้ำ: สิ่งนี้ทำงานเหมือนการบวก แต่ถ้าทั้งคู่
ออบเจ็กต์มีค่าสำหรับคีย์เดียวกัน และค่าเป็นอ็อบเจ็กต์ ทั้งสองจะถูกรวมเข้าด้วยกัน
ด้วยกลยุทธ์เดียวกัน

jq '10 / . * 3'
5
=> 6

jq´. / ",", "´
"เอ บี ซี ด อี"
=> ["a","b,c,d","e"]

jq ´{"k": {"a": 1, "b": 2}} * {"k": {"a": 0,"c": 3}}´
โมฆะ
=> {"k": {"a": 0, "b": 2, "c": 3}}

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

ความยาว
ฟังก์ชั่นในตัว ความยาว รับความยาวของค่าประเภทต่างๆ ดังนี้

· ความยาวของ a เชือก คือจำนวนจุดโค้ด Unicode ที่มีอยู่ (ซึ่งจะเป็น
เหมือนกับความยาวที่เข้ารหัส JSON เป็นไบต์หากเป็น ASCII แท้)

· ความยาวของ an แถว คือจำนวนองค์ประกอบ

· ความยาวของ an วัตถุ คือจำนวนคู่คีย์-ค่า

· ความยาวของ โมฆะ เป็นศูนย์

jq ´.[] | ความยาว´ [[1,2], "สตริง", {"a":2}, null] => 2, 6, 1, 0

กุญแจ key_unsorted
ฟังก์ชั่นในตัว กุญแจเมื่อได้รับอ็อบเจ็กต์ จะส่งคืนคีย์ของวัตถุนั้นในอาร์เรย์

คีย์ต่างๆ จะถูกจัดเรียง "ตามตัวอักษร" โดยเรียงลำดับยูนิโค้ดโค้ดพอยท์ นี่ไม่ใช่คำสั่ง
ที่สมเหตุสมผลในภาษาใดภาษาหนึ่ง แต่คุณสามารถวางใจได้ว่ามันเป็น
เหมือนกันสำหรับสองอ็อบเจ็กต์ที่มีชุดคีย์เดียวกัน โดยไม่คำนึงถึงการตั้งค่าโลแคล

เมื่อ กุญแจ ได้รับอาร์เรย์จะส่งคืนดัชนีที่ถูกต้องสำหรับอาร์เรย์นั้น: integers
จาก 0 ถึงความยาว -1

พื้นที่ key_unsorted ฟังก์ชั่นก็เหมือน กุญแจแต่ถ้าอินพุตเป็นวัตถุแล้วคีย์
จะไม่ถูกจัดเรียง แต่คีย์จะเรียงตามลำดับการแทรกแทน

jq ´คีย์'
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["ฟู", "abc", "abcd"]

jq ´คีย์'
[42,3,35]
=> [0,1,2]

มี (คีย์)
ฟังก์ชั่นในตัว มี ส่งคืนว่าวัตถุอินพุตมีคีย์ที่กำหนดหรืออินพุต
อาร์เรย์มีองค์ประกอบที่ดัชนีที่กำหนด

มี($คีย์) มีผลเช่นเดียวกับการตรวจสอบว่า $คีย์ เป็นสมาชิกของอาร์เรย์ที่ส่งคืน
by กุญแจถึงแม้ว่า มี จะเร็วขึ้น

jq ´map(มี("foo"))´
[{"foo": 42}, {}]
=> [จริงเท็จ]

jq ´แผนที่ (มี(2))'
[[0,1], ["a","b","c"]]
=> [เท็จจริง]

in
ฟังก์ชั่นในตัว in ส่งคืนคีย์อินพุตที่อยู่ในวัตถุที่กำหนดหรือดัชนีอินพุต
สอดคล้องกับองค์ประกอบในอาร์เรย์ที่กำหนด โดยพื้นฐานแล้วมันเป็นเวอร์ชันผกผันของ
มี.

jq ´.[] | ใน({"foo": 42})´
["foo", "บาร์"]
=> จริง เท็จ

jq ´map(ใน([0,1])))´
[2, 0]
=> [เท็จจริง]

เส้นทาง (path_expression)
แสดงผลการแทนค่าอาร์เรย์ของนิพจน์เส้นทางที่กำหนดใน .. ผลลัพธ์เป็นอาร์เรย์ของ
strings (คีย์ใน object0 และ/หรือตัวเลข (array indices.

นิพจน์เส้นทางคือนิพจน์ jq เช่น .aแต่ยัง -. ทางมี ๒ แบบ
นิพจน์: นิพจน์ที่สามารถจับคู่ได้ทั้งหมด และนิพจน์ที่ไม่สามารถทำได้ ตัวอย่างเช่น, .abc เป็น
นิพจน์เส้นทางการจับคู่แบบตรงทั้งหมดในขณะที่ .a[].ข ไม่ใช่.

เส้นทาง (exact_path_expression) จะสร้างการแสดงอาร์เรย์ของนิพจน์เส้นทาง
แม้จะไม่มีอยู่ใน .ถ้า . is โมฆะ หรืออาร์เรย์หรือวัตถุ

เส้นทาง(รูปแบบ) จะสร้างการแทนค่าอาร์เรย์ของเส้นทางที่ตรงกัน Belt hold ถ้า
มีเส้นทางอยู่ใน ..

โปรดทราบว่านิพจน์เส้นทางไม่แตกต่างจากนิพจน์ทั่วไป การแสดงออก
เส้นทาง(..|select(type=="boolean")) ส่งออกเส้นทางทั้งหมดไปยังค่าบูลีนใน .และเท่านั้น
เส้นทางเหล่านั้น

jq ´เส้นทาง(.a[0].b)´
โมฆะ
=> ["a",0,"b"]

jq ´[เส้นทาง(..)]´
{"a":[{"b":1}]}
=> [[],["a"],["a",0],["a",0,"b"]]

เดล (path_expression)
ฟังก์ชั่นในตัว เดล ลบคีย์และค่าที่เกี่ยวข้องออกจากวัตถุ

jq 'เดล(.foo)'
{"foo": 42 "บาร์": 9001, "baz": 42}
=> {"แถบ": 9001, "baz": 42}

jq ´เดล(.[1, 2])´
["foo", "บาร์", "baz"]
=> ["foo"]

ถึง_รายการ, จาก_รายการ, with_entries
ฟังก์ชันเหล่านี้จะแปลงระหว่างอ็อบเจ็กต์และอาร์เรย์ของคู่คีย์-ค่า ถ้า ถึง_รายการ
ถูกส่งผ่านวัตถุแล้วสำหรับแต่ละ k: v อินพุตในอาร์เรย์เอาต์พุตประกอบด้วย
{"กุญแจ": k, "ค่า": v}.

จาก_รายการ ทำการแปลงตรงกันข้ามและ with_entries(ฟู) เป็นชวเลขสำหรับ
ถึง_รายการ | แผนที่(foo) | จาก_รายการ, มีประโยชน์สำหรับการดำเนินการบางอย่างกับปุ่มทั้งหมดและ
ค่าของวัตถุ จาก_รายการ ยอมรับคีย์ คีย์ ชื่อ ค่า และค่าเป็นคีย์

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

jq 'จากรายการ'
[{"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) สร้างอินพุตไม่เปลี่ยนแปลง if foo คืนค่าจริงสำหรับอินพุตนั้น
และไม่มีผลผลิตเป็นอย่างอื่น

มีประโยชน์สำหรับการกรองรายการ: [1,2,3] | แผนที่(เลือก(. >= 2)) จะทำให้คุณ [2,3].

jq ´map(เลือก(. >= 2))´
[1,5,3,0,7]
=> [5,3,7]

jq ´.[] | select(.id == "วินาที")´
[{"id": "first", "val": 1}, {"id": "second", "val": 2}]
=> {"id": "วินาที", "val": 2}

อาร์เรย์ วัตถุ ทำซ้ำได้, บูลีน ตัวเลข ปกติ, จำกัด สตริง ค่าว่าง ค่า
สเกลาร์
บิวท์อินเหล่านี้เลือกเฉพาะอินพุตที่เป็นอาร์เรย์ อ็อบเจ็กต์ iterables (อาร์เรย์หรือ
วัตถุ), บูลีน, ตัวเลข, ตัวเลขปกติ, จำนวนจำกัด, สตริง, null, non-null
ค่าและค่าที่ทำซ้ำไม่ได้ตามลำดับ

jq ´.[]|ตัวเลข´
[[],{},1,"foo",null,จริง,เท็จ]
=> 1

ไม่มีข้อมูล
ไม่มีข้อมูล ไม่ส่งคืนผลลัพธ์ ไม่มีเลย ไม่เท่ากัน โมฆะ.

มีประโยชน์ในบางโอกาส คุณจะรู้ว่าถ้าคุณต้องการ :)

jq ´1, ว่าง, 2´
โมฆะ
=> 1, 2

jq ´[1,2,ว่าง,3]´
โมฆะ
=> [1,2,3]

ความผิดพลาด(ข้อความ)
ทำให้เกิดข้อผิดพลาดเช่นเดียวกับ .a นำไปใช้กับค่าอื่นที่ไม่ใช่ null และอ็อบเจกต์จะ, แต่
ด้วยข้อความที่กำหนดเป็นค่าของข้อผิดพลาด

$__ล็อค__
สร้างวัตถุด้วยปุ่ม "ไฟล์" และปุ่ม "บรรทัด" พร้อมชื่อไฟล์และหมายเลขบรรทัด
ที่ไหน $__ล็อค__ เกิดขึ้นเป็นค่านิยม

jq ´try error("\($__loc__)") จับ .´
โมฆะ
=> "{\"ไฟล์\":\" \",\"บรรทัด\":1}"

แผนที่(x), map_values(x)
สำหรับตัวกรองใด ๆ x, แผนที่(x) จะเรียกใช้ตัวกรองนั้นสำหรับแต่ละองค์ประกอบของอาร์เรย์อินพุตและ
สร้างเอาต์พุตอาร์เรย์ใหม่ แผนที่(.+1) จะเพิ่มแต่ละองค์ประกอบของอาร์เรย์ของ
หมายเลข

ในทำนองเดียวกัน map_values(x) จะเรียกใช้ตัวกรองนั้นสำหรับแต่ละองค์ประกอบ แต่จะส่งคืน an
วัตถุเมื่อวัตถุถูกส่งผ่าน

แผนที่(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), leaf_paths
เส้นทาง ส่งออกเส้นทางไปยังองค์ประกอบทั้งหมดในอินพุต (ยกเว้นจะไม่ส่งออก
รายการที่ว่างเปล่าแทน . เอง)

เส้นทาง (ฉ) ส่งออกเส้นทางไปยังค่าใด ๆ ที่ f เป็นความจริง. นั่นคือ, เส้นทาง(ตัวเลข)
ส่งออกเส้นทางไปยังค่าตัวเลขทั้งหมด

leaf_paths เป็นนามแฝงของ เส้นทาง(สเกลาร์); leaf_paths is เลิก และจะถูกลบออกใน
การเปิดตัวครั้งสำคัญครั้งต่อไป

jq ´[เส้นทาง]´
[1,[[],{"a":2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]

jq ´[เส้นทาง(สเกลาร์)]´
[1,[[],{"a":2}]]
=> [[0],[1,1,"a"]]

เพิ่ม
ตัวกรอง เพิ่ม รับเป็นอินพุตอาร์เรย์และสร้างเป็นเอาต์พุตองค์ประกอบของอาร์เรย์
รวมเข้าด้วยกัน ซึ่งอาจหมายถึงผลรวม ต่อกัน หรือรวมกัน ขึ้นอยู่กับประเภทของ
องค์ประกอบของอาร์เรย์อินพุต - กฎเหมือนกับกฎของ + ผู้ประกอบการ
(อธิบายไว้ข้างต้น).

หากอินพุตเป็นอาร์เรย์ว่าง เพิ่ม รับคืน โมฆะ.

jq 'เพิ่ม'
["a","b","c"]
=> "เอบีซี"

jq 'เพิ่ม'
[1, 2, 3]
=> 6

jq 'เพิ่ม'
[]
=> null

ใด ๆ, ใดๆ(เงื่อนไข) ใด ๆ (เครื่องกำเนิดไฟฟ้า; เงื่อนไข)
ตัวกรอง ใด รับอาร์เรย์ของค่าบูลีนเป็นอินพุตและสร้าง จริง เป็นเอาต์พุต if
องค์ประกอบใด ๆ ของอาร์เรย์คือ จริง.

หากอินพุตเป็นอาร์เรย์ว่าง ใด รับคืน เท็จ.

พื้นที่ ใดๆ(เงื่อนไข) form ใช้เงื่อนไขที่กำหนดกับองค์ประกอบของอาร์เรย์อินพุต

พื้นที่ ใด ๆ (เครื่องกำเนิดไฟฟ้า; เงื่อนไข) แบบฟอร์มใช้เงื่อนไขที่กำหนดกับผลลัพธ์ทั้งหมดของ
เครื่องกำเนิดไฟฟ้าที่ได้รับ

jq 'ใด ๆ '
[ถูกผิด]
=> จริง

jq 'ใด ๆ '
[เท็จเท็จ]
=> เท็จ

jq 'ใด ๆ '
[]
=> เท็จ

ทั้งหมด, ทั้งหมด(เงื่อนไข) ทั้งหมด(เครื่องกำเนิดไฟฟ้า; เงื่อนไข)
ตัวกรอง ทั้งหมด รับอาร์เรย์ของค่าบูลีนเป็นอินพุตและสร้าง จริง เป็นเอาต์พุต if
องค์ประกอบทั้งหมดของอาร์เรย์คือ จริง.

พื้นที่ ทั้งหมด(เงื่อนไข) form ใช้เงื่อนไขที่กำหนดกับองค์ประกอบของอาร์เรย์อินพุต

พื้นที่ ทั้งหมด(เครื่องกำเนิดไฟฟ้า; เงื่อนไข) แบบฟอร์มใช้เงื่อนไขที่กำหนดกับผลลัพธ์ทั้งหมดของ
เครื่องกำเนิดไฟฟ้าที่ได้รับ

หากอินพุตเป็นอาร์เรย์ว่าง ทั้งหมด รับคืน จริง.

jq 'ทั้งหมด'
[ถูกผิด]
=> เท็จ

jq 'ทั้งหมด'
[จริง จริง]
=> จริง

jq 'ทั้งหมด'
[]
=> จริง

[ต้องใช้ 1.5] เรียบ, แผ่(ความลึก)
ตัวกรอง เรียบ รับอาร์เรย์ของอาร์เรย์ที่ซ้อนกันเป็นอินพุตและสร้างอาร์เรย์แบบแบนใน
ซึ่งอาร์เรย์ทั้งหมดภายในอาร์เรย์เดิมถูกแทนที่ด้วยค่าแบบเรียกซ้ำ
คุณสามารถส่งอาร์กิวเมนต์ไปให้เพื่อระบุจำนวนระดับของการซ้อนที่จะแบน

เรียบ(2) ก็เหมือน เรียบแต่ลึกลงไปเพียงสองระดับเท่านั้น

jq 'แผ่'
[1, [2], [[3]]]
=> [1, 2, 3]

เจค ´เรียบ(1)'
[1, [2], [[3]]]
=> [1, 2, [3]]

jq 'แผ่'
-
=> []

jq 'แผ่'
[{"foo": "bar"}, [{"foo": "baz"}]]
=> [{"foo": "bar"}, {"foo": "baz"}]

ช่วง (ไม่เกิน), ช่วง(จาก;ไม่เกิน) ช่วง(จาก;ไม่เกิน;โดย)
พื้นที่ พิสัย ฟังก์ชันสร้างช่วงของตัวเลข ช่วง (4;10) ผลิตตัวเลข 6 จาก 4
(รวม) ถึง 10 (ไม่รวม) ตัวเลขถูกสร้างเป็นเอาต์พุตแยกกัน ใช้
[ช่วง(4;10)] เพื่อรับช่วงเป็นอาร์เรย์

รูปแบบอาร์กิวเมนต์หนึ่งสร้างตัวเลขตั้งแต่ 0 ถึงตัวเลขที่กำหนดโดยเพิ่มขึ้น
1.

แบบฟอร์มอาร์กิวเมนต์ทั้งสองสร้างตัวเลขจาก ราคาเริ่มต้นที่ ไปยัง จนถึง โดยเพิ่มขึ้นทีละ 1

แบบฟอร์มอาร์กิวเมนต์สามตัวสร้างตัวเลข ราคาเริ่มต้นที่ ไปยัง จนถึง ด้วยการเพิ่มขึ้นของ by.

jq ระยะ (2;4)´
โมฆะ
=> 2, 3

jq ´[ช่วง(2;4)]´
โมฆะ
=> [2,3]

เจคิว '[พิสัย(4)]'
โมฆะ
=> [0,1,2,3]

jq ´[ช่วง(0;10;3)]´
โมฆะ
=> [0,3,6,9]

jq ´[ช่วง (0;10;-1)]´
โมฆะ
=> []

jq ´[ช่วง(0;-5;-1)]´
โมฆะ
=> [0,-1,-2,-3,-4]

ชั้น
พื้นที่ ชั้น ฟังก์ชั่นส่งคืนพื้นของอินพุตตัวเลข

jq 'พื้น'
3.14159
=> 3

ตร.ว
พื้นที่ ตร.ว ฟังก์ชันส่งคืนรากที่สองของอินพุตตัวเลข

jq 'sqrt'
9
=> 3

Tonumber
พื้นที่ Tonumber ฟังก์ชั่นแยกวิเคราะห์อินพุตเป็นตัวเลข มันจะแปลงรูปแบบที่ถูกต้อง
สตริงที่เทียบเท่ากับตัวเลข ปล่อยให้ตัวเลขเพียงอย่างเดียวและให้ข้อผิดพลาดกับรายการอื่น ๆ ทั้งหมด
อินพุต

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

สตริง
พื้นที่ สตริง ฟังก์ชั่นพิมพ์อินพุตเป็นสตริง สตริงจะไม่เปลี่ยนแปลงและทั้งหมด
ค่าอื่นๆ มีการเข้ารหัส JSON

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

ชนิด
พื้นที่ ชนิด ฟังก์ชันส่งคืนประเภทของอาร์กิวเมนต์เป็นสตริง ซึ่งเป็นหนึ่งในค่า null
บูลีน ตัวเลข สตริง อาร์เรย์ หรืออ็อบเจกต์

jq ´map(ประเภท)´
[0, เท็จ, [], {}, null, "สวัสดี"]
=> ["number", "boolean", "array", "object", "null", "string"]

อนันต์ น่าน ไม่มีที่สิ้นสุด, อิสนัน, ไม่มีที่สิ้นสุด, เป็นเรื่องปกติ
การดำเนินการทางคณิตศาสตร์บางอย่างสามารถให้ค่าอนันต์และค่า "ไม่ใช่ตัวเลข" (NaN) NS
ไม่มีที่สิ้นสุด ผลตอบแทนในตัว จริง หากข้อมูลเข้าเป็นอนันต์ NS อิสนัน ผลตอบแทนในตัว จริง
ถ้าอินพุตเป็น NaN NS อนันต์ builtin ส่งกลับค่าอนันต์ที่เป็นบวก NS น่าน
builtin ส่งคืน NaN NS เป็นเรื่องปกติ builtin คืนค่า จริง หากอินพุตเป็นตัวเลขปกติ

โปรดทราบว่าการหารด้วยศูนย์ทำให้เกิดข้อผิดพลาด

ปัจจุบันการดำเนินการเลขคณิตส่วนใหญ่ที่ทำงานบนอินฟินิตี้, NaN และ sub-normals ทำไม่ได้
ทำให้เกิดข้อผิดพลาด

jq ´.[] | (อนันต์ * .) < 0´
[-สิบเอ็ด]
=> จริง เท็จ

jq ´อนันต์ น่าน | พิมพ์
โมฆะ
=> "หมายเลข", "หมายเลข"

เรียงลำดับ sort_by(เส้นทาง_นิพจน์)
พื้นที่ ประเภท ฟังก์ชันจะจัดเรียงข้อมูลเข้า ซึ่งต้องเป็นอาร์เรย์ ค่าจะถูกจัดเรียงใน
คำสั่งดังต่อไปนี้:

· โมฆะ

· เท็จ

· จริง

· ตัวเลข

· สตริง ตามลำดับตัวอักษร (ตามค่าจุดโค๊ดยูนิโค้ด)

· อาร์เรย์ ตามลำดับศัพท์

· วัตถุ

ลำดับของวัตถุค่อนข้างซับซ้อน: ก่อนอื่นให้เปรียบเทียบโดยเปรียบเทียบของพวกมัน
ชุดคีย์ (เป็นอาร์เรย์ตามลำดับการจัดเรียง) และหากคีย์เท่ากัน ค่าก็จะเท่ากับ
เปรียบเทียบคีย์ทีละคีย์

ประเภท อาจใช้เพื่อจัดเรียงตามเขตข้อมูลเฉพาะของวัตถุ หรือโดยการใช้ตัวกรอง jq ใดๆ

sort_by(ฟู) เปรียบเทียบสององค์ประกอบโดยการเปรียบเทียบผลลัพธ์ของ foo ในแต่ละองค์ประกอบ

jq 'เรียงลำดับ'
[8,3,โมฆะ,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(เส้นทาง_นิพจน์)
group_by(.foo) ใช้เป็นอาร์เรย์อินพุต จัดกลุ่มองค์ประกอบที่เหมือนกัน .ฟู สนาม
ลงในอาร์เรย์ที่แยกจากกัน และสร้างอาร์เรย์ทั้งหมดเหล่านี้เป็นองค์ประกอบของอาร์เรย์ที่ใหญ่กว่า
เรียงตามค่าของ .ฟู สนาม

นิพจน์ jq ใดๆ ที่ไม่ใช่เพียงการเข้าถึงฟิลด์ อาจใช้แทน .ฟู. การเรียงลำดับ
คำสั่งเหมือนกับที่อธิบายไว้ใน ประเภท ฟังก์ชั่นด้านบน

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 (เส้นทาง_exp), max_by(path_exp)
ค้นหาองค์ประกอบต่ำสุดหรือสูงสุดของอาร์เรย์อินพุต

พื้นที่ min_by (เส้นทาง_exp) และ max_by(path_exp) ฟังก์ชั่นช่วยให้คุณระบุเฉพาะ
สาขาหรือทรัพย์สินที่จะตรวจสอบเช่น min_by(.foo) หาวัตถุที่มีขนาดเล็กที่สุด foo
สนาม

jq 'นาที'
[5,4,2,7]
=> 2

jq 'max_by(.foo)'
[{"foo":1, "bar":14}, {"foo":2, "bar":3}]
=> {"foo":2, "บาร์":3}

มีเอกลักษณ์, Unique_by (path_exp)
พื้นที่ เป็นเอกลักษณ์ ฟังก์ชั่นใช้เป็นอินพุตอาร์เรย์และสร้างอาร์เรย์ขององค์ประกอบเดียวกัน in
เรียงลำดับโดยลบรายการที่ซ้ำกัน

พื้นที่ Unique_by (path_exp) ฟังก์ชั่นจะเก็บเพียงองค์ประกอบเดียวสำหรับแต่ละค่าที่ได้รับโดย
การใช้อาร์กิวเมนต์ คิดว่ามันเป็นการสร้างอาร์เรย์โดยนำองค์ประกอบหนึ่งออกจากทุกๆ
กลุ่มที่ผลิตโดย กลุ่ม.

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(ความยาว)´
["อ้วน", "เบคอน", "ลูกแมว", "จั๊กจั่น", "หน่อไม้ฝรั่ง"]
=> ["เบคอน", "ก้อน", "หน่อไม้ฝรั่ง"]

ย้อนกลับ
ฟังก์ชันนี้จะย้อนกลับอาร์เรย์

jq 'ย้อนกลับ'
[1,2,3,4]
=> [4,3,2,1]

ประกอบด้วย (องค์ประกอบ)
ตัวกรอง ประกอบด้วย (ข) จะให้ผลเป็นจริงหาก b มีอยู่ภายในอินพุตอย่างสมบูรณ์ NS
สตริง B มีอยู่ในสตริง A ถ้า B เป็นสตริงย่อยของ A อาร์เรย์ B มีอยู่ใน
อาร์เรย์ A ถ้าองค์ประกอบทั้งหมดใน B มีอยู่ในองค์ประกอบใด ๆ ใน A วัตถุ B คือ
มีอยู่ในวัตถุ A หากค่าทั้งหมดใน B อยู่ในค่าใน A ด้วย
คีย์เดียวกัน ประเภทอื่น ๆ ทั้งหมดจะถือว่ามีกันและกันหากเท่ากัน

jq ´contains("bar")´
"ฟูบาร์"
=> จริง

jq ´contains(["baz", "bar"])´
["foobar", "foobaz", "blarp"]
=> จริง

jq ´contains(["bazzzzzz", "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 เกิดขึ้น อินพุตอาจเป็นอาร์เรย์ in
ซึ่งกรณี if s เป็นอาร์เรย์แล้วผลลัพธ์ของดัชนีจะเป็นที่ที่องค์ประกอบทั้งหมดอยู่ใน .
ตรงกับของ s.

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

เจค ´ดัชนี(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]

ดัชนี ดัชนี
ส่งออกดัชนีของตัวแรก (ดัชนี) หรือสุดท้าย (รินเดกซ์) การเกิดของ s ในการป้อนข้อมูล

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

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

ภายใน
ตัวกรอง ภายใน(ข) จะให้ผลเป็นจริงหากอินพุตมีอยู่ภายใน b อย่างสมบูรณ์ มัน
โดยพื้นฐานแล้วเป็นเวอร์ชันผกผันของ มี.

jq ´ภายใน("foobar")´
"บาร์"
=> จริง

jq ´inside(["foobar", "foobaz", "blarp"])´
["บาส", "บาร์"]
=> จริง

jq ´inside(["foobar", "foobaz", "blarp"])´
["bazzzz", "บาร์"]
=> เท็จ

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 จริง ถ้า . เริ่มต้นด้วยอาร์กิวเมนต์สตริงที่กำหนด

jq ´[.[]|startswith("foo")]´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [เท็จ, จริง, เท็จ, จริง, เท็จ]

ลงท้ายด้วย(str)
Outputs จริง ถ้า . ลงท้ายด้วยอาร์กิวเมนต์สตริงที่กำหนด

jq ´[.[]|ลงท้ายด้วย("foo")]´
["ฟูบาร์", "บาร์ฟู"]
=> [เท็จจริง]

ชุดค่าผสม ชุดค่าผสม(n)
แสดงผลการรวมองค์ประกอบทั้งหมดของอาร์เรย์ในอาร์เรย์อินพุต ถ้าให้
อาร์กิวเมนต์ n, มันส่งออกชุดค่าผสมทั้งหมดของ n การซ้ำซ้อนของอาร์เรย์อินพุต

jq 'ชุดค่าผสม'
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]

เจค ´รวม(2)'
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]

ltrimstr(สตริ)
เอาท์พุตอินพุตโดยลบสตริงคำนำหน้าที่ระบุออก ถ้ามันขึ้นต้นด้วย

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

rtrimstr(สตริ)
เอาท์พุตอินพุตโดยลบสตริงต่อท้ายที่กำหนดออก ถ้ามันลงท้ายด้วยสตริงนั้น

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

ระเบิด
แปลงสตริงอินพุตเป็นอาร์เรย์ของหมายเลขโค้ดพอยต์ของสตริง

jq 'ระเบิด'
"ฟูบาร์"
=> [102,111,111,98,97,114]

ระเบิด
ผกผันของการระเบิด

jq 'ระเบิด'
[65, 66, 67]
=> "เอบีซี"

แยก
แยกสตริงอินพุตบนอาร์กิวเมนต์ตัวคั่น

jq ´split(",", ")´
"เอ บี ซี ด อี "
=> ["a","b,c,d","e",""]

เข้าร่วม(str)
รวมอาร์เรย์ขององค์ประกอบที่กำหนดเป็นอินพุต โดยใช้อาร์กิวเมนต์เป็นตัวคั่น มันคือ
ผกผันของ แยก: นั่นคือการวิ่ง แยก ("foo") | เข้าร่วม ("foo") บนสตริงอินพุตใด ๆ
ส่งคืนสตริงอินพุตดังกล่าว

jq ´เข้าร่วม(", ")´
["a","b,c,d","e"]
=> "a, b,c,d, อี"

ascii_downcase, ascii_upcase
คัดลอกสตริงอินพุตที่แปลงเป็นตัวอักษร (az และ AZ) เป็น
กรณีที่ระบุ

ในขณะที่(เงื่อนไข; ปรับปรุง)
พื้นที่ ในขณะที่(เงื่อนไข; ปรับปรุง) ฟังก์ชั่นช่วยให้คุณใช้การอัพเดทซ้ำ ๆ กับ . จนกระทั่ง เงื่อนไข
เป็นเท็จ

โปรดทราบว่า ในขณะที่(เงื่อนไข; ปรับปรุง) ถูกกำหนดภายในเป็นฟังก์ชัน jq แบบเรียกซ้ำ เรียกซ้ำ
โทรภายใน ในขณะที่ จะไม่กินหน่วยความจำเพิ่มเติมถ้า ปรับปรุง ผลิตได้มากที่สุด
เอาต์พุตสำหรับแต่ละอินพุต ดูหัวข้อขั้นสูงด้านล่าง

jq ´[ในขณะที่(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

จนกระทั่ง(cond; ต่อไป)
พื้นที่ จนกระทั่ง(cond; ต่อไป) ฟังก์ชั่นช่วยให้คุณใช้นิพจน์ซ้ำ ๆ ได้ ถัดไป,
เริ่มแรกถึง . จากนั้นไปยังผลลัพธ์ของตัวเอง จนกระทั่ง เงื่อนไข เป็นความจริง. ตัวอย่างเช่น สามารถใช้
เพื่อใช้ฟังก์ชันแฟกทอเรียล (ดูด้านล่าง)

โปรดทราบว่า จนกระทั่ง(cond; ต่อไป) ถูกกำหนดภายในเป็นฟังก์ชัน jq แบบเรียกซ้ำ เรียกซ้ำ
โทรภายใน จนกระทั่ง() จะไม่กินหน่วยความจำเพิ่มเติมถ้า ถัดไป ผลิตได้มากที่สุด
เอาต์พุตสำหรับแต่ละอินพุต ดูหัวข้อขั้นสูงด้านล่าง

jq ´[.,1]|จนถึง(.[0] < 1; [.[0] - 1, .[1] * .[0]])|.[1]´
4
=> 24

ซ้ำ (f), ซ้ำ, ซ้ำ (f; สภาพ), recurse_down
พื้นที่ ซ้ำ (f) ฟังก์ชั่นช่วยให้คุณค้นหาผ่านโครงสร้างแบบเรียกซ้ำและแยก
ข้อมูลที่น่าสนใจจากทุกระดับ สมมติว่าอินพุตของคุณแสดงถึงระบบไฟล์:

{"name": "/", "ลูก": [
{"ชื่อ": "/ bin", "เด็ก": [
{"ชื่อ": "/ถัง/ลิตร", "เด็ก": []},
{"ชื่อ": "bin / sh /", "เด็ก": []}]},
{"ชื่อ": "/ หน้าแรก", "เด็ก": [
{"name": "/home/stephen", "children": [
{"name": "/home/stephen/jq", "children": []}]}]}]}

ตอนนี้ สมมติว่าคุณต้องการแยกชื่อไฟล์ทั้งหมดที่มีอยู่ คุณต้องเอาคืน ชื่อ.,
.ลูก[].ชื่อ, .เด็ก[].เด็ก[].ชื่อและอื่นๆ คุณสามารถทำได้ด้วย:

recurse(.children[]) | .ชื่อ

เมื่อถูกเรียกโดยไม่มีข้อโต้แย้ง ฟื้น เทียบเท่ากับ ซ้ำ (.[]?).

ซ้ำ (f) เหมือนกับ ซ้ำ (f; . != โมฆะ) และสามารถใช้ได้โดยไม่ต้องกังวลเรื่อง
ความลึกของการเรียกซ้ำ

ซ้ำ (f; เงื่อนไข) เป็นเครื่องกำเนิดไฟฟ้าที่เริ่มต้นด้วยการแผ่รังสี แล้วส่งเสียงออกมา
.|f, .|f|f, .|f|f|f, ... ตราบใดที่ค่าที่คำนวณได้ตรงตามเงื่อนไข สำหรับ
ตัวอย่าง การสร้างจำนวนเต็มทั้งหมด อย่างน้อยในหลักการ เราสามารถเขียน เรียกซ้ำ (.+1;
จริง).

ด้วยเหตุผลทางมรดก recurse_down มีอยู่เป็นนามแฝงในการเรียก ฟื้น โดยไม่มีข้อโต้แย้ง
นามแฝงนี้ถือเป็น เลิก และจะถูกลบออกในรุ่นใหญ่ครั้งต่อไป

การเรียกซ้ำใน ฟื้น จะไม่กินหน่วยความจำเพิ่มเติมเมื่อใดก็ตามที่ f ผลิตที่
ส่วนใหญ่เป็นเอาต์พุตเดียวสำหรับแต่ละอินพุต

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

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

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

..
อักษรย่อสำหรับ ฟื้น โดยไม่มีข้อโต้แย้ง สิ่งนี้มีจุดประสงค์เพื่อคล้ายกับXPath //
โอเปอเรเตอร์ สังเกตว่า ..NS ไม่สำเร็จ; ใช้ ..|ก แทนที่. ในตัวอย่างด้านล่างเราใช้
..|.ก? เพื่อค้นหาค่าทั้งหมดของคีย์วัตถุ "a" ในวัตถุใด ๆ ที่พบ "ด้านล่าง" ..

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

env
ส่งออกวัตถุที่แสดงถึงสภาพแวดล้อมของ jq

jq 'env.PAGER'
โมฆะ
=> "น้อยกว่า"

ไขว้
ย้ายเมทริกซ์ที่มีรอยหยัก (อาร์เรย์ของอาร์เรย์) แถวถูกเติมด้วยค่าว่าง ดังนั้น
ผลลัพธ์จะเป็นสี่เหลี่ยมเสมอ

jq ´ทรานสโพส'
[1], [2,3]]
=> [[1,2],[null,3]]

ค้นหา(x)
bsearch(x) ดำเนินการค้นหาไบนารีสำหรับ x ในอาร์เรย์อินพุต หากอินพุตถูกจัดเรียงและ
มี x แล้ว bsearch(x) จะส่งคืนดัชนีในอาร์เรย์ มิฉะนั้น ถ้าอาร์เรย์เป็น
เรียงลำดับ มันจะกลับ (-1 - ix) โดยที่ ix เป็นจุดแทรกเพื่อให้อาร์เรย์จะ
ยังคงถูกจัดเรียงหลังจากการแทรกของ x ที่ ix หากไม่ได้จัดเรียงอาร์เรย์ bsearch(x)
จะส่งกลับจำนวนเต็มที่ไม่น่าจะสนใจ

เจค ´ค้นหา(0)'
[0,1]
=> 0

เจค ´ค้นหา(0)'
[1,2,3]
=> -1

เจค ´ค้นหา(4) เป็น $ix | ถ้า $ix < 0 แล้ว .[-(1+$ix)] = 4 else จบ
[1,2,3]
=> [1,2,3,4]

เชือก การแก้ไข - \(ฟู)
ภายในสตริง คุณสามารถใส่นิพจน์ภายใน parens หลังแบ็กสแลช ไม่ว่า
การส่งคืนนิพจน์จะถูกสอดแทรกเข้าไปในสตริง

jq ´"ข้อมูลที่ป้อนคือ \(.) ซึ่งน้อยกว่า \(.+1)"´
42
=> "อินพุตคือ 42 ซึ่งน้อยกว่า 43"

แปลง ถึง/จาก JSON
พื้นที่ ทอจสัน และ จาก json ค่าดัมพ์บิวด์อินเป็นข้อความ JSON หรือแยกวิเคราะห์ข้อความ JSON เป็น
ค่าตามลำดับ tojson ในตัวแตกต่างจาก tostring ในการส่งคืน tostring
สตริงที่ไม่ได้แก้ไขในขณะที่ tojson เข้ารหัสสตริงเป็นสตริง JSON

jq ´[.[]|ทอสตริง]´
[1, "foo", ["foo"]]
=> ["1","foo","[\"foo\"]"]

jq ´[.[]|โทจสัน]´
[1, "foo", ["foo"]]
=> ["1","\"foo\"",","[\"foo\"]"]

jq ´[.[]|tojson|fromjson]´
[1, "foo", ["foo"]]
=> [1,"foo",["foo"]]

รูปแบบ เงื่อนไข และ การหลบหนี
พื้นที่ @ฟู ไวยากรณ์ใช้เพื่อจัดรูปแบบและหลีกสตริง ซึ่งมีประโยชน์สำหรับการสร้าง URL
เอกสารในภาษาเช่น HTML หรือ XML เป็นต้น @ฟู สามารถใช้เป็นตัวกรองบน
ของตัวเอง การหลบหนีที่เป็นไปได้คือ:

@ข้อความ:

โทร สตริงดูรายละเอียดในฟังก์ชันนั้น

@json:

จัดลำดับอินพุตเป็น JSON

@html:

ใช้การ Escape HTML/XML โดยการจับคู่อักขระ <>&´" สู่ตัวตนของพวกเขา
เทียบเท่า <, >, @, ', ".

@ยูริ:

ใช้การเข้ารหัสแบบเปอร์เซ็นต์โดยจับคู่อักขระ URI ที่สงวนไว้ทั้งหมดกับ a %XX ลำดับ.

@csv:

อินพุตต้องเป็นอาร์เรย์ และแสดงผลเป็น CSV ด้วยเครื่องหมายคำพูดคู่ for
สตริงและคำพูดหนีจากการทำซ้ำ

@tsv:

อินพุตต้องเป็นอาร์เรย์ และแสดงผลเป็น TSV (ค่าที่คั่นด้วยแท็บ) แต่ละ
อาร์เรย์อินพุตจะถูกพิมพ์เป็นบรรทัดเดียว เขตข้อมูลถูกคั่นด้วยแท็บเดียว
(แอสกี้ 0x09). ป้อนอักขระป้อนบรรทัด (ascii 0x0a) การคืนรถ (ascii
0x0d) แท็บ (ascii 0x09) และแบ็กสแลช (ascii 0x5c) จะถูกส่งออกเป็นการหลบหนี
ลำดับ \n, \r, \t, \\ ตามลำดับ

@NS:

อินพุตหลีกเหมาะสำหรับใช้ในบรรทัดคำสั่งสำหรับ POSIX เชลล์ ถ้า
อินพุตเป็นอาร์เรย์ เอาต์พุตจะเป็นชุดของสตริงที่คั่นด้วยช่องว่าง

@ฐาน64:

อินพุตถูกแปลงเป็น base64 ตามที่ RFC 4648 ระบุ

ไวยากรณ์นี้สามารถใช้ร่วมกับการแก้ไขสตริงได้อย่างมีประโยชน์ สามารถติดตาม
@ฟู โทเค็นด้วยตัวอักษรสตริง เนื้อหาของสตริงตามตัวอักษร will ไม่ จะหลบหนี
อย่างไรก็ตาม การแก้ไขทั้งหมดที่เกิดขึ้นภายในสตริงตามตัวอักษรนั้นจะถูกหลีกเลี่ยง ตัวอย่างเช่น

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

จะสร้างเอาต์พุตต่อไปนี้สำหรับอินพุต {"ค้นหา":อะไร is jq?"}:

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

โปรดทราบว่าเครื่องหมายทับ เครื่องหมายคำถาม ฯลฯ ใน URL จะไม่ถูก Escape เนื่องจากเป็นส่วนหนึ่ง
ของตัวอักษรสตริง

jq `@html´
"ใช้งานได้ถ้า x < y"
=> "ใช้งานได้ถ้า x < y"

jq ´@sh "echo \(.)"´
"เอลของโอฮาร่า"
=> "ก้อง ´O´\\´´Hara´\\´´s Ale´"

วันที่
jq มีฟังก์ชันการจัดการวันที่พื้นฐานด้วยระดับสูงและระดับต่ำ
บิวอิน ในทุกกรณีบิวด์อินเหล่านี้เกี่ยวข้องกับเวลาใน UTC เท่านั้น

พื้นที่ จากdateiso8601 builtin แยกวิเคราะห์ datetimes ในรูปแบบ ISO 8601 เป็นจำนวนวินาที
ตั้งแต่ยุค Unix (1970-01-01T00:00:00Z) NS โทดาเตะ iso8601 builtin ทำการผกผัน

พื้นที่ จากวันที่ builtin แยกวิเคราะห์สตริงวันที่และเวลา ปัจจุบัน จากวันที่ รองรับเฉพาะ ISO 8601
สตริง datetime แต่ในอนาคตจะพยายามแยกวิเคราะห์สตริง datetime เพิ่มเติม
รูปแบบ

พื้นที่ วันนี้ builtin เป็นนามแฝงสำหรับ โทดาเตะ iso8601.

พื้นที่ ตอนนี้ builtin แสดงเวลาปัจจุบันเป็นวินาทีตั้งแต่ยุค Unix

มีอินเทอร์เฟซ jq ระดับต่ำไปยังฟังก์ชันเวลา C-library: สตริปไทม์,
สตริฟไทม์, เอ็มเคไทม์และ จีเอ็มไทม์. อ้างถึงเอกสารของระบบปฏิบัติการโฮสต์ของคุณสำหรับ
รูปแบบสตริงที่ใช้โดย สตริปไทม์ และ สตริฟไทม์. หมายเหตุ: สิ่งเหล่านี้ไม่จำเป็นต้องเสถียร
อินเทอร์เฟซใน jq โดยเฉพาะอย่างยิ่งเกี่ยวกับฟังก์ชันการแปลเป็นภาษาท้องถิ่น

พื้นที่ จีเอ็มไทม์ builtin ใช้เวลาหลายวินาทีตั้งแต่ยุค Unix และส่งออก "เสีย
เวลาหยุดทำงาน" การแสดงเวลาเป็นอาร์เรย์ของตัวเลขที่แสดง (ตามลำดับนี้): the
ปี, เดือน (เป็นศูนย์), วันของเดือน, ชั่วโมงของวัน, นาทีของ
ชั่วโมง วินาทีของนาที วันในสัปดาห์ และวันของปี -- ทั้งหมด
แบบเดียวเว้นแต่จะระบุไว้เป็นอย่างอื่น

พื้นที่ เอ็มเคไทม์ บิวด์อินใช้ "เวลาที่เสีย" แทนการแสดงเวลาโดย จีเอ็มไทม์
และ สตริปไทม์.

พื้นที่ สแตรปไทม์ (fmt) builtin แยกวิเคราะห์สตริงอินพุตที่ตรงกับ เอฟเอ็มที การโต้แย้ง. เอาต์พุตอยู่ใน
การแสดง "เวลาที่เสีย" ที่บริโภคโดย จีเอ็มไทม์ และส่งออกโดย เอ็มเคไทม์.

พื้นที่ strftime (fmt) builtin จัดรูปแบบเวลาด้วยรูปแบบที่กำหนด

สตริงรูปแบบสำหรับ สตริปไทม์ และ สตริฟไทม์ อธิบายไว้ในไลบรารี C ทั่วไป
เอกสาร สตริงรูปแบบสำหรับ ISO 8601 datetime is "%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

เงื่อนไข AND การเปรียบเทียบ

- !=
นิพจน์ 'a == b´ จะสร้าง 'จริง' หากผลลัพธ์ของ a และ b เท่ากัน (นั่นคือ
หากเป็นเอกสาร JSON ที่เทียบเท่า) และ 'เท็จ' มิฉะนั้น โดยเฉพาะ strings
จะไม่ถือว่าเท่ากับตัวเลข หากคุณมาจาก Javascript jq´s == ก็เหมือน
Javascript´s === - พิจารณาค่าที่เท่ากันก็ต่อเมื่อมีประเภทเดียวกันและ
ค่าเดียวกัน

!= คือ "ไม่เท่ากัน" และ ´a != b´ คืนค่าตรงข้ามของ ´a == b´

jq ´.[] == 1´
[1, 1.0, "1", "กล้วย"]
=> จริง, จริง, เท็จ, เท็จ

ถ้า - แล้ว - อื่น
if A แล้วก็ B อื่น C ปลาย จะทำหน้าที่เหมือนกับ B if A สร้างค่าอื่นที่ไม่ใช่เท็จหรือ
null แต่ทำตัวเหมือน C มิฉะนั้น.

การตรวจสอบค่าเท็จหรือค่าว่างเป็นแนวคิดของ "ความจริง" ที่ง่ายกว่าที่พบใน Javascript
หรือ Python แต่หมายความว่าบางครั้งคุณจะต้องมีความชัดเจนมากขึ้นเกี่ยวกับเงื่อนไขนี้
คุณต้องการ: คุณไม่สามารถทดสอบได้ว่า เช่น สตริงว่างเปล่าโดยใช้ if ชื่อ. แล้วก็ A อื่น B ปลาย,
คุณจะต้องการอะไรมากกว่านี้ if (.ชื่อ | ความยาว) > 0 แล้วก็ A อื่น B ปลาย แทน.

หากเงื่อนไข A ให้ผลลัพธ์หลายรายการ ให้ถือว่า "จริง" หากมี
ผลลัพธ์ไม่เป็นเท็จหรือเป็นโมฆะ หากให้ผลลัพธ์เป็นศูนย์ จะถือเป็นเท็จ

สามารถเพิ่มเคสเพิ่มเติมใน if ใช้ elif A แล้วก็ B วากยสัมพันธ์

jq 'ถ้า == 0 แล้ว

"ศูนย์" เอลิฟ == 1 จากนั้น "หนึ่ง" อย่างอื่น "มากมาย" end´ 2 => "มากมาย"

>, >=, <=, <
ตัวดำเนินการเปรียบเทียบ >, >=, <=, < ส่งคืนว่าอาร์กิวเมนต์ด้านซ้ายของพวกเขามากกว่าหรือไม่
มากกว่าหรือเท่ากับ, น้อยกว่าหรือเท่ากับหรือน้อยกว่าอาร์กิวเมนต์ที่ถูกต้อง
(ตามลำดับ)

การสั่งซื้อเหมือนกับที่อธิบายไว้สำหรับ ประเภท, ข้างบน.

jq´. < 5´
2
=> จริง

และ/หรือ/ไม่
jq รองรับตัวดำเนินการบูลีนปกติและ/หรือ/ไม่ใช่ พวกเขามีมาตรฐานความจริงเหมือนกัน
ราวกับว่านิพจน์ - false และ null ถือเป็น "ค่าเท็จ" และอย่างอื่นคือ a
"มูลค่าที่แท้จริง".

ถ้าตัวถูกดำเนินการของหนึ่งในตัวดำเนินการเหล่านี้สร้างผลลัพธ์หลายตัว ตัวดำเนินการเอง
จะสร้างผลลัพธ์สำหรับแต่ละอินพุต

ไม่ อันที่จริงเป็นฟังก์ชันในตัวมากกว่าตัวดำเนินการ ดังนั้นจึงเรียกว่าเป็นตัวกรอง to
สิ่งต่าง ๆ ที่สามารถไพพ์ได้แทนที่จะใช้ไวยากรณ์พิเศษเช่นใน .ฟู และ .คาเฟ่ | ไม่.

ทั้งสามค่านี้สร้างเฉพาะค่า "จริง" และ "เท็จ" และมีประโยชน์สำหรับของแท้เท่านั้น
การดำเนินการบูลีน แทนที่จะเป็นสำนวน Perl/Python/Ruby ทั่วไปของ
"value_that_may_be_null หรือค่าเริ่มต้น" หากคุณต้องการใช้ "หรือ" แบบฟอร์มนี้ ให้เลือกระหว่าง
ค่าสองค่าแทนการประเมินเงื่อนไข โปรดดูตัวดำเนินการ "//" ด้านล่าง

jq ´42 และ "สตริง"´
โมฆะ
=> จริง

jq ´(จริง เท็จ) หรือ เท็จ´
โมฆะ
=> จริง เท็จ

jq ´(จริง, จริง) และ (จริง, เท็จ)´
โมฆะ
=> จริง, เท็จ, จริง, เท็จ

jq ´[จริง เท็จ | ไม่
โมฆะ
=> [เท็จจริง]

ทางเลือก ผู้ประกอบการ - //
ตัวกรองของแบบฟอร์ม a // b ให้ผลลัพธ์เช่นเดียวกับ aถ้า a ให้ผลลัพธ์อื่นๆ
กว่า เท็จ และ โมฆะ. มิฉะนั้น, a // b ให้ผลลัพธ์เช่นเดียวกับ b.

สิ่งนี้มีประโยชน์สำหรับการให้ค่าเริ่มต้น: .ฟู // 1 จะประเมินถึง 1 ถ้าไม่มี .ฟู
องค์ประกอบในการป้อนข้อมูล มันคล้ายกับวิธีการ or บางครั้งใช้ใน Python (jq´s or ผู้ประกอบการ
สงวนไว้สำหรับการดำเนินการบูลีนอย่างเคร่งครัด)

jq '.foo // 42'
{"ฟู": 19}
=> 19

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

ลองจับ
ข้อผิดพลาดสามารถจับได้โดยใช้ ลอง EXP จับ EXP. นิพจน์แรกถูกดำเนินการและ if
มันล้มเหลวจากนั้นที่สองจะดำเนินการกับข้อความแสดงข้อผิดพลาด ผลลัพธ์ของตัวจัดการ if
any เป็นเอาต์พุตราวกับว่ามันเป็นผลลัพธ์ของนิพจน์ที่จะลอง

พื้นที่ ลอง EXP การใช้แบบฟอร์ม ไม่มีข้อมูล เป็นตัวจัดการข้อยกเว้น

jq ´try .a catch ". ไม่ใช่วัตถุ"´
จริง
=> ". ไม่ใช่วัตถุ"

jq ´[.[]|ลอง .a]´
[{} จริง {"a":1}]
=> [null, 1]

jq ´try error("ข้อยกเว้นบางอย่าง") catch .´
จริง
=> "ข้อยกเว้นบางประการ"

หมดสภาพ ออก of ควบคุม โครงสร้าง
การใช้ try/catch ที่สะดวกคือการแยกโครงสร้างการควบคุมออก เช่น ลด, แต่ละ,
ในขณะที่, และอื่น ๆ

ตัวอย่างเช่น:

# ทำซ้ำนิพจน์จนขึ้น "break" เป็น an
# error จากนั้นหยุดทำซ้ำโดยไม่ทำให้เกิดข้อผิดพลาดซ้ำ
#แต่ถ้าเจอ error ไม่ใช่ "break" ให้ขึ้นใหม่ครับ
ลองทำซ้ำ (exp) catch .=="break" จากนั้นจึงเว้นว่างไว้

jq มีไวยากรณ์สำหรับป้ายกำกับศัพท์ที่มีชื่อเพื่อ "แตก" หรือ "ไป (ย้อนกลับ) ไปที่":

ป้าย $out | ... แบ่ง $ ออก ...

พื้นที่ ทำลาย $label_name นิพจน์จะทำให้โปรแกรมทำหน้าที่เหมือนที่ใกล้ที่สุด
(ไปทางซ้าย) ฉลาก $label_name ผลิต ไม่มีข้อมูล.

ความสัมพันธ์ระหว่าง ทำลาย และสอดคล้องกัน ฉลาก เป็นศัพท์เฉพาะ: ฉลากต้องเป็น
"มองเห็นได้" จากการหยุดพัก

ที่จะแยกออกจาก ลด, ตัวอย่างเช่น:

ป้าย $out | ลด .[] เป็น $item (null; if .==false แล้วแยก $out else ... end)

โปรแกรม jq ต่อไปนี้สร้างข้อผิดพลาดทางไวยากรณ์:

แยกเงินออก

เพราะไม่มีฉลาก $ออก สามารถมองเห็นได้

? ผู้ประกอบการ
พื้นที่ ? โอเปอเรเตอร์ ใช้ as ค่าประสบการณ์?, เป็นชวเลขสำหรับ ลอง EXP.

jq ´[.[]|(.a)?]´
[{} จริง {"a":1}]
=> [null, 1]

ปกติ การแสดงออก (พีซีอาร์อี)

jq ใช้ไลบรารีนิพจน์ทั่วไปของ Oniguruma เช่นเดียวกับ php, ruby, TextMate, Sublime Text
ฯลฯ ดังนั้นคำอธิบายที่นี่จะเน้นที่เฉพาะ jq

ตัวกรอง jq regex ถูกกำหนดเพื่อให้สามารถใช้ได้โดยใช้รูปแบบใดรูปแบบหนึ่งเหล่านี้:

STRING | ตัวกรอง ( REGEX )
STRING | ตัวกรอง ( REGEX; ธง )
STRING | ตัวกรอง ( [REGEX] )
STRING | ตัวกรอง ( [REGEX, ธง])

โดยที่: * STRING, REGEX และ FLAGS เป็นสตริง jq และอยู่ภายใต้การแก้ไขสตริง jq; *
REGEX หลังจากการแก้ไขสตริงควรเป็น PCRE regex ที่ถูกต้อง * FILTER เป็นหนึ่งใน ทดสอบ,
การจับคู่,หรือ จับตามที่อธิบายไว้ด้านล่าง

FLAGS เป็นสตริงที่ประกอบด้วยหนึ่งในแฟล็กที่รองรับ:

· g - การค้นหาทั่วโลก (ค้นหาการแข่งขันทั้งหมด ไม่ใช่แค่รายการแรก)

· i - การค้นหาตัวพิมพ์เล็กและตัวพิมพ์ใหญ่

· m - โหมดหลายบรรทัด (´.´ จะจับคู่กับการขึ้นบรรทัดใหม่)

· n - ละเว้นการแข่งขันที่ว่างเปล่า

· p - ทั้งโหมด s และ m เปิดใช้งานอยู่

· s - โหมดบรรทัดเดียว (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - ค้นหาการแข่งขันที่ยาวที่สุดเท่าที่จะเป็นไปได้

· x - รูปแบบ regex แบบขยาย (ละเว้นช่องว่างและความคิดเห็น)

หากต้องการจับคู่ช่องว่างในรูปแบบ x ให้ใช้ Escape เช่น \s, เช่น

· ทดสอบ ( "a\sb", "x")

โปรดทราบว่าอาจมีการระบุแฟล็กบางอย่างภายใน REGEX เช่น

· jq -n ´("ทดสอบ", "ทดสอบ", "teST", "ทดสอบ") | test( "(?i)te(?-i)st" )´

ประเมินเป็น: จริง, จริง, เท็จ, เท็จ

[ต้องใช้ 1.5] ทดสอบ(วาล), ทดสอบ (regex; ธง)
Like การจับคู่แต่ไม่ส่งคืนวัตถุที่ตรงกันเท่านั้น จริง or เท็จ หรือไม่ก็ตาม
regex ตรงกับอินพุต

jq ´test("foo")´
"ฟู"
=> จริง

jq ´.[] | test("abc # ช่องว่างถูกละเว้น"; "ix")´
["xabcd", "ABC"]
=> จริง จริง

[ต้องใช้ 1.5] การแข่งขัน(val), ตรงกัน (regex; ธง)
การจับคู่ ส่งออกวัตถุสำหรับการจับคู่แต่ละครั้งที่พบ การแข่งขันมีฟิลด์ต่อไปนี้:

· ชดเชย - ออฟเซ็ตในโค้ดพอยท์ UTF-8 จากจุดเริ่มต้นของอินพุต

· ความยาว - ความยาวในโค้ดพอยท์ UTF-8 ของการแข่งขัน

· เชือก - สตริงที่จับคู่

· จับ - อาร์เรย์ของวัตถุที่เป็นตัวแทนของกลุ่มการจับ

การจับวัตถุกลุ่มมีฟิลด์ต่อไปนี้:

· ชดเชย - ออฟเซ็ตในโค้ดพอยท์ UTF-8 จากจุดเริ่มต้นของอินพุต

· ความยาว - ความยาวในโค้ดพอยท์ UTF-8 ของกลุ่มการจับนี้

· เชือก - สตริงที่ถูกจับ

· ชื่อ - ชื่อกลุ่มจับ (หรือ โมฆะ หากไม่มีชื่อ)

การจับกลุ่มที่ไม่ตรงกับสิ่งใดจะคืนค่าออฟเซ็ตของ -1

jq ´match("(abc)+"; "g")´
"เอบีซี เอบีซี"
=> {"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", "name": null}]}

jq ´match("foo")´
"ฟูบาร์ฟู"
=> {"offset": 0, "length": 3, "string": "foo", "captures": []}

jq ´match(["foo", "ig"])´
"ฟูบาร์ FOO"
=> {"offset": 0, "length": 3, "string": "foo", "captures": []}, {"offset": 8, "length": 3, "string": "FOO" , "จับ": []}

jq ´match("foo (? บาร์)? foo"; "ig")´
"ฟู บาร์ ฟู ฟู ฟู"
=> {"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")] | ระยะเวลา
"เอบีซี"
=> 3

[ต้องใช้ 1.5] จับ(วาล), จับภาพ (regex; ธง)
รวบรวมการดักจับที่มีชื่อในวัตถุ JSON โดยมีชื่อของการดักจับแต่ละรายการเป็นคีย์
และสตริงที่ตรงกันเป็นค่าที่สอดคล้องกัน

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

[ต้องใช้ 1.5] สแกน (regex), สแกน (regex; ธง)
ปล่อยสตรีมของสตริงย่อยที่ไม่ทับซ้อนกันของอินพุตที่ตรงกับ regex ใน
ตามธง ถ้ามีระบุไว้ หากไม่มีการแข่งขันสตรีมคือ
ว่างเปล่า. ในการจับการจับคู่ทั้งหมดสำหรับสตริงอินพุตแต่ละรายการ ให้ใช้ idiom [ ด่วน ], เช่น [
สแกน (regex) ].

แยก (regex; ธง)
สำหรับความเข้ากันได้ย้อนหลัง แยก แยกเป็นสตริง ไม่ใช่ regex

[ต้องใช้ 1.5] แยก (regex), แยก (regex; ธง)
สิ่งเหล่านี้ให้ผลลัพธ์เช่นเดียวกับของพวกเขา แยก คู่กัน แต่เป็นลำธารแทนที่จะเป็น
แถว

[ต้องใช้ 1.5] ย่อย (regex; ทอสตริง) ย่อย (regex; สตริง; ธง)
ปล่อยสตริงที่ได้รับโดยการแทนที่การจับคู่แรกของ regex ในสตริงอินพุตด้วย
สตริง, หลังการสอดแทรก สตริง ควรเป็นสตริง jq และอาจมีการอ้างอิง
เพื่อจับชื่อ การจับที่มีชื่อมีผล นำเสนอเป็นวัตถุ JSON (เช่น
สร้างโดย จับ) มัน สตริงดังนั้นการอ้างอิงถึงตัวแปรที่จับได้ชื่อ "x" จะ
ใช้แบบฟอร์ม: "(.x)"

[ต้องใช้ 1.5] gsub(regex; สตริง) gsub(regex; สตริง; ธง)
กซบ ก็เหมือน ด้านล่าง แต่การเกิดขึ้นที่ไม่ทับซ้อนกันทั้งหมดของ regex จะถูกแทนที่ด้วย
สตริงหลังจากการแก้ไข

ADVANCED คุณลักษณะเด่น

ตัวแปรมีความจำเป็นอย่างยิ่งในภาษาโปรแกรมส่วนใหญ่ แต่ถูกลดชั้นลง
เป็น "คุณสมบัติขั้นสูง" ใน jq

ในภาษาส่วนใหญ่ ตัวแปรเป็นเพียงวิธีเดียวในการส่งผ่านข้อมูล ถ้าคุณคำนวณ a
ค่า และคุณต้องการใช้มากกว่าหนึ่งครั้ง คุณจะต้องเก็บไว้ในตัวแปร ถึง
ส่งค่าไปยังส่วนอื่นของโปรแกรม คุณจะต้องใช้ส่วนนั้นของโปรแกรมเพื่อ
กำหนดตัวแปร (เป็นพารามิเตอร์ฟังก์ชัน สมาชิกของวัตถุ หรืออะไรก็ตาม) ที่จะวาง
ข้อมูล.

นอกจากนี้ยังสามารถกำหนดฟังก์ชั่นใน jq ได้ แม้ว่านี่จะเป็นคุณสมบัติที่มีที่ใหญ่ที่สุด
การใช้งานคือการกำหนดไลบรารีมาตรฐานของ jq (ฟังก์ชัน jq มากมายเช่น แผนที่ และ พบ อยู่ในความเป็นจริง
เขียนเป็น jq)

jq มีตัวดำเนินการลดซึ่งมีประสิทธิภาพมากแต่ค่อนข้างยุ่งยาก อีกครั้งเหล่านี้คือ
ส่วนใหญ่ใช้ภายใน เพื่อกำหนดบิตที่มีประโยชน์ของไลบรารีมาตรฐานของ jq

มันอาจจะไม่ชัดเจนในตอนแรก แต่ jq นั้นเกี่ยวกับตัวสร้างทั้งหมด (ใช่ มักพบใน
ภาษาอื่น ๆ). สาธารณูปโภคบางอย่างมีไว้เพื่อช่วยจัดการกับเครื่องกำเนิดไฟฟ้า

รองรับ I/O เพียงเล็กน้อย (นอกเหนือจากการอ่าน JSON จากอินพุตมาตรฐาน และการเขียน JSON ถึง
เอาต์พุตมาตรฐาน) สามารถใช้ได้

ในที่สุดก็มีโมดูล/ระบบห้องสมุด

ตัวแปร
ใน jq ตัวกรองทั้งหมดมีอินพุตและเอาต์พุต ดังนั้นการประปาแบบแมนนวลจึงไม่จำเป็น
ส่งค่าจากส่วนหนึ่งของโปรแกรมไปยังส่วนถัดไป สำนวนมากมาย เช่น a + b,
ส่งผ่านอินพุตไปยังนิพจน์ย่อยที่แตกต่างกันสองนิพจน์ (ที่นี่ a และ b ทั้งสองผ่านเหมือนกัน
อินพุต) ดังนั้นโดยปกติไม่จำเป็นต้องใช้ตัวแปรเพื่อใช้ค่าเป็นสองเท่า

ตัวอย่างเช่น การคำนวณค่าเฉลี่ยของอาร์เรย์ของตัวเลขต้องใช้จำนวนเล็กน้อย
ตัวแปรในภาษาส่วนใหญ่ - อย่างน้อยหนึ่งตัวเพื่อเก็บอาร์เรย์ บางทีหนึ่งตัวแปรสำหรับแต่ละองค์ประกอบ
หรือสำหรับตัวนับลูป ใน jq มันง่าย เพิ่ม / ความยาว - เพิ่ม การแสดงออกจะได้รับ
อาร์เรย์และสร้างผลรวมและ ความยาว นิพจน์ได้รับอาร์เรย์และสร้าง
ความยาว.

โดยทั่วไปแล้ว มีวิธีที่สะอาดกว่าในการแก้ปัญหาส่วนใหญ่ใน jq มากกว่าการกำหนดตัวแปร
อย่างไรก็ตาม บางครั้งมันทำให้สิ่งต่าง ๆ ง่ายขึ้น ดังนั้น jq ให้คุณกำหนดตัวแปรโดยใช้
การแสดงออก as ตัวแปร $. ชื่อตัวแปรทั้งหมดขึ้นต้นด้วย $. นี่เป็นเวอร์ชั่นที่น่าเกลียดกว่าเล็กน้อย
ของตัวอย่างการเฉลี่ยอาร์เรย์:

ความยาวเท่ากับ $array_length | เพิ่ม / $array_length

เราต้องการปัญหาที่ซับซ้อนกว่านี้เพื่อค้นหาสถานการณ์ที่ใช้ตัวแปรจริงๆ
ทำให้ชีวิตของเราง่ายขึ้น

สมมติว่าเรามีบล็อกโพสต์หลายรายการ พร้อมช่อง "ผู้แต่ง" และ "ชื่อ" และอีกช่องหนึ่ง
วัตถุที่ใช้ในการจับคู่ชื่อผู้ใช้ของผู้เขียนกับชื่อจริง ข้อมูลของเราดูเหมือนว่า:

{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "บทความดีๆ", "ผู้แต่ง": "person1"}],
"realnames": {"anon": "Anonymous Coward",
"person1": "บุคคล McPherson"}}

เราต้องการสร้างโพสต์ที่มีฟิลด์ผู้เขียนที่มีชื่อจริง เช่น:

{"title": "Frist psot", "author": "Anonymous Coward"}
{"title": "บทความดีๆ", "ผู้แต่ง": "Person McPherson"}

เราใช้ตัวแปร $names เพื่อจัดเก็บอ็อบเจกต์ realnames เพื่อให้เราสามารถอ้างอิงได้ในภายหลัง
เมื่อค้นหาชื่อผู้ใช้ของผู้เขียน:

.realnames เป็น $names | .posts[] | {ชื่อผู้แต่ง: $names[.author]}

การแสดงออก ประสบการณ์ as $x | ... หมายถึง: สำหรับแต่ละค่าของนิพจน์ ประสบการณ์, เรียกใช้ส่วนที่เหลือของ
ไปป์ไลน์ที่มีอินพุตดั้งเดิมทั้งหมดและด้วย $x กำหนดเป็นค่านั้น ดังนั้น as
ทำหน้าที่เหมือนวง foreach

เช่นเดียวกับ {ฟู} เป็นวิธีที่สะดวกในการเขียน {ฟู: .ฟู}ดังนั้น {$ฟู} เป็นวิธีที่สะดวกในการเขียน
{ฟู:$ฟู}.

สามารถประกาศตัวแปรหลายตัวโดยใช้ตัวเดียว as การแสดงออกโดยให้รูปแบบ
ที่ตรงกับโครงสร้างของอินพุต (ซึ่งเรียกว่า "การทำลาย"):

. เป็น {ชื่อจริง: $names, โพสต์: [$first, $second]} | ...

การประกาศตัวแปรในรูปแบบอาร์เรย์ (เช่น . as [$แรก, $วินาที]) ผูกมัดกับ
องค์ประกอบของอาร์เรย์ในจากองค์ประกอบที่ดัชนีศูนย์ขึ้นไปตามลำดับ เมื่อไม่มี
ค่าที่ดัชนีสำหรับองค์ประกอบรูปแบบอาร์เรย์ โมฆะ ถูกผูกไว้กับตัวแปรนั้น

ตัวแปรถูกกำหนดขอบเขตไว้เหนือนิพจน์ที่เหลือที่กำหนด ดังนั้น

.realnames เป็น $names | (.posts[] | {ชื่อผู้แต่ง: $names[.author]})

จะทำงาน แต่

(.realnames เป็น $names | .posts[]) | {ชื่อผู้แต่ง: $names[.author]}

เคยชิน.

สำหรับนักทฤษฎีภาษาโปรแกรม การบอกว่าตัวแปร jq เป็น . ถูกต้องกว่า
การผูกที่มีขอบเขตคำศัพท์ โดยเฉพาะอย่างยิ่ง ไม่มีทางที่จะเปลี่ยนค่าของการผูกมัด;
ทำได้เฉพาะการผูกใหม่ที่มีชื่อเดียวกัน แต่จะมองไม่เห็นที่ไหน
อันเก่าคือ

jq ´.bar เป็น $x | .foo | . + $x´
{"foo":10, "บาร์":200}
=> 210

jq´. เป็น $i|[(.*2|. เป็น $i| $i), $i]´
5
=> [10,5]

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

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

การกำหนด ฟังก์ชั่น
คุณสามารถตั้งชื่อตัวกรองโดยใช้ไวยากรณ์ "def":

def เพิ่ม: . + 1;

นับแต่นั้นเป็นต้นมา เพิ่มขึ้น สามารถใช้เป็นตัวกรองได้เหมือนกับฟังก์ชันในตัว (อันที่จริงนี่คือ
คือวิธีการกำหนดบางส่วนของบิวด์อิน) ฟังก์ชันอาจรับอาร์กิวเมนต์:

แผนที่ def(f): [.[] | ฉ];

อาร์กิวเมนต์จะถูกส่งเป็นตัวกรอง ไม่ใช่เป็นค่า อาจมีการอ้างอิงอาร์กิวเมนต์เดียวกัน
หลายครั้งด้วยอินพุตต่างกัน (ที่นี่ f ทำงานสำหรับแต่ละองค์ประกอบของอาร์เรย์อินพุต)
อาร์กิวเมนต์ของฟังก์ชันทำงานเหมือนกับการเรียกกลับมากกว่าอาร์กิวเมนต์ค่า นี่คือ
สำคัญที่ต้องเข้าใจ พิจารณา:

def foo(ฉ): ฉ|ฉ;
5|ฟู(.*2)

ผลลัพธ์จะเป็น 20 เพราะ f is .*2และในระหว่างการวิงวอนครั้งแรกของ f . จะเป็น 5,
และครั้งที่สองจะเป็น 10 (5 * 2) ดังนั้นผลลัพธ์จะเป็น 20
เป็นตัวกรองและตัวกรองคาดหวังอินพุตเมื่อเรียกใช้

หากคุณต้องการพฤติกรรมของค่าอาร์กิวเมนต์สำหรับการกำหนดฟังก์ชันอย่างง่าย คุณสามารถใช้ a
ตัวแปร:

def addvalue(f): f เป็น $f | แผนที่(. + $f);

หรือใช้ตัวย่อ:

def เพิ่มมูลค่า($f): ...;

ด้วยคำจำกัดความอย่างใดอย่างหนึ่ง มูลค่าเพิ่ม (.foo) จะเพิ่มอินพุตปัจจุบัน´s .ฟู สนามให้แต่ละ
องค์ประกอบของอาร์เรย์

อนุญาตให้ใช้คำจำกัดความหลายคำโดยใช้ชื่อฟังก์ชันเดียวกัน นิยามใหม่แต่ละครั้งจะเข้ามาแทนที่
อันก่อนหน้าสำหรับจำนวนอาร์กิวเมนต์ฟังก์ชันเท่ากัน แต่สำหรับการอ้างอิงจาก .เท่านั้น
ฟังก์ชัน (หรือโปรแกรมหลัก) ภายหลังการนิยามใหม่

jq ´def เพิ่มค่า (f): . + [f]; แผนที่(addvalue(.[0]))´
[[1,2],[10,20]]
=> [[1,2,1], [10,20,10]]

jq ´def addvalue(f): f เป็น $x | แผนที่(. + $x); มูลค่าเพิ่ม(.[0])´
[[1,2],[10,20]]
=> [[1,2,1,2], [10,20,1,2]]

ลด
พื้นที่ ลด ไวยากรณ์ใน jq ช่วยให้คุณสามารถรวมผลลัพธ์ทั้งหมดของนิพจน์โดย
รวบรวมเป็นคำตอบเดียว ตัวอย่างเช่น เราจะผ่าน [3,2,1] สำหรับสิ่งนี้
การแสดงออก:

ลด .[] เป็น $item (0; . + $item)

สำหรับแต่ละผลลัพธ์ที่ - ผลิต, . + $รายการ คือวิ่งสะสมยอดวิ่ง
เริ่มจาก 0 ในตัวอย่างนี้ - ให้ผลลัพธ์ 3, 2 และ 1 ดังนั้น ผลลัพธ์คือ
คล้ายกับการทำงานบางอย่างเช่นนี้:

0 | (3 เป็น $item | . + $item) |
(2 เป็น $item | . + $item) |
(1 เป็น $item | . + $item)

jq ´reduce .[] เป็น $item (0; . + $item)´
[10,2,5,3]
=> 20

ขีด จำกัด (n; ประสบการณ์)
พื้นที่ จำกัด ฟังก์ชั่นแยกได้ถึง n ผลผลิตจาก ประสบการณ์.

jq ´[จำกัด(3;.[])]´
[0,1,2,3,4,5,6,7,8,9]
=> [0,1,2]

แรก (expr), ล่าสุด (expr), ที่ n (n; ประสบการณ์)
พื้นที่ แรก (expr) และ สุดท้าย (expr) ฟังก์ชันดึงค่าแรกและค่าสุดท้ายออกจาก ด่วน,
ตามลำดับ

พื้นที่ ที่ n (n; ประสบการณ์) ฟังก์ชันดึงค่าที่ n ออกโดย ด่วน. นี้สามารถกำหนดเป็น
def ที่ n (n; ประสบการณ์): สุดท้าย (จำกัด (n + 1; ประสบการณ์));. สังเกตได้ว่า ที่ n (n; ประสบการณ์) ไม่รองรับ
ค่าลบของ n.

jq ´[ครั้งแรก(ช่วง(.)) สุดท้าย(ช่วง(.)) nth(./2; ช่วง(.))]´
10
=> [0,9,5]

แรก ล่าสุด, ที่ n (n)
พื้นที่ เป็นครั้งแรก และ ล่าสุด ฟังก์ชันดึงค่าแรกและค่าสุดท้ายจากอาร์เรย์ใดๆ ที่ ..

พื้นที่ ที่ n (n) ฟังก์ชันดึงค่าที่ n ของอาร์เรย์ใดๆ ที่ ..

jq ´[ช่วง(.)]|[แรก สุดท้าย ที่ n(5)]'
10
=> [0,9,5]

แต่ละ
พื้นที่ แต่ละ ไวยากรณ์คล้ายกับ ลดแต่มีวัตถุประสงค์เพื่อให้การก่อสร้างของ จำกัด
และรีดิวเซอร์ที่ให้ผลลัพธ์ขั้นกลาง (ดูตัวอย่าง)

แบบฟอร์มคือ แต่ละ EXP as $var (ในนั้น; อัปเดต; สารสกัด). เช่น ลด, INIT ได้รับการประเมินแล้ว
หนึ่งครั้งเพื่อสร้างมูลค่าของรัฐ แล้วแต่ละผลลัพธ์ของ EXP ถูกผูกไว้กับ $var, อัพเดท is
ประเมินผลแต่ละผลลัพธ์ของ EXP ด้วยสถานะปัจจุบันและกับ $var มองเห็นได้. แต่ละค่า
เอาต์พุตโดย อัพเดท แทนที่สถานะก่อนหน้า ในที่สุด, สารสกัดจาก ถูกประเมินสำหรับแต่ละรายการใหม่
รัฐเพื่อแยกผลลัพธ์ของ แต่ละ.

ส่วนใหญ่จะมีประโยชน์สำหรับการสร้างเท่านั้น ลด- และ จำกัด- ฟังก์ชั่นเหมือน แต่มันคือ
กว้างกว่ามาก เนื่องจากช่วยลดบางส่วนได้ (ดูตัวอย่างด้านล่าง)

jq ´[foreach .[] เป็น $item ([[],[]]; ถ้า $item == null แล้ว [[],.[0]] else [(.[0] + [$item]),[ ]] end; if $item == null แล้ว .[1] else ว่างเปล่า end)]´
[1,2,3,4,null,"a","b",null]
=> [[1,2,3,4],["a","b"]]

Recursion
ตามที่อธิบายไว้ข้างต้น ฟื้น ใช้การเรียกซ้ำ และฟังก์ชัน jq ใดๆ สามารถเรียกซ้ำได้ ดิ
ในขณะที่ บิวด์อินยังถูกนำมาใช้ในแง่ของการเรียกซ้ำ

การเรียก Tail ได้รับการปรับให้เหมาะสมเมื่อใดก็ตามที่นิพจน์ทางด้านซ้ายของเอาต์พุตการโทรแบบเรียกซ้ำ
ค่าสุดท้ายของมัน ในทางปฏิบัตินี่หมายความว่านิพจน์ทางด้านซ้ายของ recursive
การโทรไม่ควรสร้างเอาต์พุตมากกว่าหนึ่งรายการสำหรับแต่ละอินพุต

ตัวอย่างเช่น:

def recurse(f): def r: ., (f | เลือก(. != null) | r); ร;

def ในขณะที่ (cond; อัปเดต):
def _ในขณะที่:
ถ้า cond แล้ว ., (อัปเดต | _while) อย่างอื่นสิ้นสุด;
_ในขณะที่;

def ซ้ำ (exp):
def _ซ้ำ:
ประสบการณ์, _repeat;
_ทำซ้ำ;

เครื่องปั่นไฟ และ วนซ้ำ
โอเปอเรเตอร์และฟังก์ชัน jq บางตัวเป็นตัวสร้างจริง ๆ ที่สามารถสร้างศูนย์ได้
อย่างน้อยหนึ่งค่าสำหรับแต่ละอินพุต เช่นเดียวกับที่เราคาดหวังในการเขียนโปรแกรมอื่น
ภาษาที่มีเครื่องกำเนิด ตัวอย่างเช่น, - สร้างค่าทั้งหมดในอินพุตของมัน
(ซึ่งต้องเป็นอาร์เรย์หรือวัตถุ) ช่วง (0; 10) สร้างจำนวนเต็มระหว่าง 0 ถึง
10 และอื่น ๆ

แม้แต่ตัวดำเนินการจุลภาคยังเป็นตัวสร้าง โดยสร้างค่าที่สร้างโดย .ก่อน
นิพจน์ทางด้านซ้ายของลูกน้ำ จากนั้นสำหรับแต่ละค่าเหล่านั้น ค่าที่สร้างโดย
นิพจน์ทางด้านขวาของเครื่องหมายจุลภาค

พื้นที่ ไม่มีข้อมูล builtin เป็นเครื่องกำเนิดที่สร้างเอาต์พุตเป็นศูนย์ ดิ ไม่มีข้อมูล ในตัว
ย้อนรอยไปยังนิพจน์ตัวสร้างก่อนหน้า

ฟังก์ชัน jq ทั้งหมดสามารถเป็นเครื่องกำเนิดไฟฟ้าได้โดยใช้เครื่องกำเนิดไฟฟ้าในตัว เป็นไปได้ด้วย
เพื่อกำหนดตัวสร้างใหม่โดยใช้การเรียกซ้ำและตัวดำเนินการจุลภาคเท่านั้น ถ้าแบบเรียกซ้ำ
การเรียกคือ "อยู่ในตำแหน่งท้าย" จากนั้นเครื่องกำเนิดไฟฟ้าจะมีประสิทธิภาพ ในตัวอย่าง
ใต้การโทรซ้ำโดย _พิสัย ตัวเองอยู่ในตำแหน่งหาง ตัวอย่างแสดงให้เห็นออก
สามหัวข้อขั้นสูง: การเรียกซ้ำส่วนท้าย การสร้างเครื่องกำเนิดไฟฟ้า และฟังก์ชันย่อย

jq ´def range(init; upto; by): def _range: if (by > 0 and . < upto) หรือ (by < 0 and . > upto) แล้ว ., ((.+by)|_range) else จบ; ถ้าโดย == 0 แล้ว init อื่น init|_range end | เลือก ((โดย > 0 และ . < ไม่เกิน) หรือ (โดย < 0 และ . > ไม่เกิน)); ช่วง (0; 10; 3)´
โมฆะ
=> 0, 3, 6, 9

jq ´def while(cond; update): def _while: if cond then ., (update | _while) อย่างอื่นสิ้นสุด; _ในขณะที่; [ในขณะที่(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

คณิตศาสตร์

ปัจจุบัน jq รองรับเฉพาะเลขทศนิยม IEEE754 double-precision (64 บิต) เท่านั้น

นอกจากตัวดำเนินการเลขคณิตอย่างง่ายเช่น +, jq ยังมีฟังก์ชันทางคณิตศาสตร์มาตรฐานส่วนใหญ่อีกด้วย
จากห้องสมุดคณิตศาสตร์ซี ฟังก์ชันคณิตศาสตร์ C ที่รับอาร์กิวเมนต์อินพุตเดียว (เช่น บาป())
มีให้ในฟังก์ชัน jq ที่ไม่มีอาร์กิวเมนต์ ฟังก์ชันคณิตศาสตร์ C ที่รับสองอินพุต
ข้อโต้แย้ง (เช่น ธาร ()) พร้อมใช้งานเป็นฟังก์ชัน jq สองอาร์กิวเมนต์ที่เพิกเฉย ..

ความพร้อมใช้งานของฟังก์ชันคณิตศาสตร์มาตรฐานขึ้นอยู่กับความพร้อมใช้งานของฟังก์ชันที่เกี่ยวข้อง
ฟังก์ชันคณิตศาสตร์ในระบบปฏิบัติการและไลบรารีคณิตศาสตร์ C ของคุณ ฟังก์ชันทางคณิตศาสตร์ไม่พร้อมใช้งาน
จะถูกกำหนดแต่จะทำให้เกิดข้อผิดพลาด

I / O

ขณะนี้ jq รองรับ I/O เพียงเล็กน้อย ส่วนใหญ่อยู่ในรูปแบบของการควบคุมเมื่อ
อินพุตถูกอ่าน มีฟังก์ชันบิวด์อินสองฟังก์ชันสำหรับสิ่งนี้ อินพุต และ ปัจจัยการผลิต, ที่อ่านว่า
จากแหล่งเดียวกัน (เช่น สเตดิน, ไฟล์ที่มีชื่อบนบรรทัดคำสั่ง) เป็น jq เอง เหล่านี้
บิวด์อินสองตัว และการดำเนินการอ่านของ jq เอง สามารถสอดแทรกซึ่งกันและกันได้

ในตัวเดียวให้ความสามารถในการส่งออกน้อยที่สุด การแก้ปัญหา. (จำได้ว่าโปรแกรม jq´s
ค่าเอาต์พุตจะถูกส่งออกเป็นข้อความ JSON เสมอ แย่.) การแก้ปัญหา ในตัวสามารถมี
ลักษณะการทำงานเฉพาะแอปพลิเคชัน เช่น สำหรับไฟล์เรียกทำงานที่ใช้ libjq C API แต่ไม่ใช่
jq ปฏิบัติการได้เอง

อินพุต
เอาต์พุตหนึ่งอินพุตใหม่

ปัจจัยการผลิต
เอาต์พุตอินพุตที่เหลือทั้งหมด ทีละรายการ

สิ่งนี้มีประโยชน์หลักสำหรับการลดอินพุตของโปรแกรม

การแก้ปัญหา
ทำให้เกิดข้อความการดีบักตามค่าอินพุตที่จะสร้าง ไฟล์ปฏิบัติการ jq wraps
ค่าอินพุตด้วย ["ดีบัก:", ] และพิมพ์สิ่งนั้นและขึ้นบรรทัดใหม่บน stderr
ดาน. นี้อาจมีการเปลี่ยนแปลงในอนาคต

input_filename
ส่งกลับชื่อของไฟล์ที่มีการกรองข้อมูลเข้า โปรดทราบว่าสิ่งนี้จะ
ทำงานได้ไม่ดีเว้นแต่ jq จะทำงานในภาษา UTF-8

input_line_number
ส่งกลับหมายเลขบรรทัดของอินพุตที่กำลังกรองอยู่

สตรีมมิ่ง

กับ --ลำธาร ตัวเลือก jq สามารถแยกวิเคราะห์ข้อความที่ป้อนในแบบสตรีมมิ่ง อนุญาตให้ jq
โปรแกรมเพื่อเริ่มประมวลผลข้อความ JSON ขนาดใหญ่ทันทีแทนที่จะใช้ parse
เสร็จสิ้น หากคุณมีข้อความ JSON เดียวที่มีขนาด 1GB การสตรีมก็จะช่วยให้คุณ
เพื่อประมวลผลได้รวดเร็วยิ่งขึ้น

อย่างไรก็ตาม การสตรีมนั้นไม่ง่ายเลยที่จะจัดการ เนื่องจากโปรแกรม jq จะมี [ ,
] (และอีกสองสามรูปแบบ) เป็นข้อมูลเข้า

มีบิวด์อินหลายตัวเพื่อให้จัดการสตรีมได้ง่ายขึ้น

ตัวอย่างด้านล่างใช้รูปแบบการสตรีมของ [0,[1]]ซึ่งเป็น
[[0],0],[[1,0],1],[[1,0]],[[1]].

แบบฟอร์มการสตรีมรวมถึง [ , ] (เพื่อระบุค่าสเกลาร์ อาร์เรย์ว่าง
หรือวัตถุว่างเปล่า) และ [ ] (เพื่อระบุจุดสิ้นสุดของอาร์เรย์หรือวัตถุ) อนาคต
เวอร์ชันของ jq รันด้วย --ลำธาร และ -seq อาจส่งออกรูปแบบเพิ่มเติมเช่น ["ข้อผิดพลาด
ข้อความ"] เมื่อข้อความที่ป้อนไม่สามารถแยกวิเคราะห์

truncate_stream(กระแส_นิพจน์)
ใช้ตัวเลขเป็นอินพุตและตัดทอนจำนวนองค์ประกอบเส้นทางที่สอดคล้องกันจาก
ด้านซ้ายของเอาต์พุตของนิพจน์การสตรีมที่กำหนด

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

จากสตรีม (stream_expression)
ค่าเอาต์พุตที่สอดคล้องกับผลลัพธ์ของนิพจน์สตรีม

jq ´fromstream(1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]]))´
โมฆะ
=> [2]

สตรีม
พื้นที่ สตรีม builtin ส่งออกรูปแบบการสตรีมของอินพุต

jq´. เป็น $dot|fromstream($dot|tostream)|.==$dot´
[0,[1,{"a":1},{"b":2}]]
=> จริง

ASSIGNMENT

Assignment ทำงานแตกต่างกันเล็กน้อยใน jq เมื่อเทียบกับภาษาโปรแกรมส่วนใหญ่ jq ไม่
แยกความแตกต่างระหว่างการอ้างอิงถึงและสำเนาของบางสิ่ง - สองอ็อบเจ็กต์หรืออาร์เรย์คือ
เท่ากันหรือไม่เท่ากัน โดยปราศจากความคิดใดๆ เพิ่มเติมว่าเป็น "วัตถุเดียวกัน" หรือ "ไม่ ."
วัตถุเดียวกัน".

ถ้าวัตถุมีสองฟิลด์ที่เป็นอาร์เรย์ .ฟู และ .คาเฟ่และคุณต่อท้ายบางสิ่งกับ
.ฟูแล้ว .คาเฟ่ จะไม่ใหญ่ขึ้น แม้ว่าคุณจะเพิ่งตั้ง .คาเฟ่ = .ฟู. หากคุณกำลังใช้
ไปเขียนโปรแกรมในภาษาต่างๆ เช่น Python, Java, Ruby, Javascript เป็นต้น คุณคิดได้
ของมันเหมือนกับว่า jq ทำสำเนาของทุกอ็อบเจกต์อย่างละเอียดก่อนที่จะทำการมอบหมาย
(สำหรับประสิทธิภาพ มันไม่ได้ทำอย่างนั้นจริงๆ แต่นั่นเป็นแนวคิดทั่วไป)

โอเปอเรเตอร์การกำหนดทั้งหมดใน jq มีนิพจน์เส้นทางทางด้านซ้ายมือ

=
ตัวกรอง .ฟู = 1 จะรับเป็นวัตถุป้อนเข้าและสร้างเป็นวัตถุส่งออกด้วย
ฟิลด์ "foo" ตั้งค่าเป็น 1 ไม่มีแนวคิดเรื่อง "การแก้ไข" หรือ "การเปลี่ยนแปลง" บางอย่างใน jq -
ค่า jq ทั้งหมดจะไม่เปลี่ยนรูป ตัวอย่างเช่น

.foo = .บาร์ | .foo.baz = 1

จะไม่มีผลข้างเคียงจากการตั้งค่า .bar.baz ให้ตั้งค่าเป็น 1 เนื่องจากหน้าตาคล้ายกัน
โปรแกรมในภาษา Javascript, Python, Ruby หรือภาษาอื่นๆ ไม่เหมือนกับภาษาเหล่านี้ (แต่
เช่น Haskell และภาษาอื่น ๆ ที่ใช้งานได้) ไม่มีแนวคิดของสองอาร์เรย์หรือ
วัตถุที่เป็น "อาร์เรย์เดียวกัน" หรือ "วัตถุเดียวกัน" จะเท่ากันหรือไม่เท่ากันก็ได้ แต่
ถ้าเราเปลี่ยนแปลงสิ่งใดสิ่งหนึ่งไม่ว่าในสถานการณ์ใด อีกสิ่งหนึ่งจะไม่เปลี่ยนแปลงข้างหลังเรา

ซึ่งหมายความว่าเป็นไปไม่ได้ที่จะสร้างค่าวงกลมใน jq (เช่นอาร์เรย์ที่มี
องค์ประกอบแรกคือตัวเอง) นี่เป็นความตั้งใจจริง ๆ และรับรองว่าสิ่งใด ๆ ที่ jq
โปรแกรมที่สามารถผลิตได้สามารถแสดงเป็น JSON

โปรดทราบว่าด้านซ้ายมือของ ´=´ หมายถึงค่าใน .. ดังนั้น $var.foo = 1 จะไม่ทำงาน
อย่างที่คาดไว้ ($var.foo ไม่ใช่นิพจน์เส้นทางที่ถูกต้องหรือมีประโยชน์ใน .); ใช้ $var | .ฟู = 1
แทน.

หากทางขวามือของ ´=´ สร้างค่าได้หลายค่า ดังนั้น สำหรับแต่ละค่านั้น jq will
ตั้งค่าเส้นทางทางด้านซ้ายมือเป็นค่าแล้วมันจะส่งออกการแก้ไข ..
ตัวอย่างเช่น (.ก,.ข)=พิสัย(2) เอาท์พุท {"a":0,"b":0}แล้ว {"a":1,"b":1}. "การปรับปรุง"
แบบฟอร์มการมอบหมาย (ดูด้านล่าง) อย่าทำเช่นนี้

สังเกตด้วยว่า .a,.b=0 ไม่ได้ตั้งค่า .a และ .bแต่ (.ก,.ข)=0 ชุดทั้งสอง

|=
เช่นเดียวกับโอเปอเรเตอร์การกำหนด ´=´ jq ให้โอเปอเรเตอร์ "อัปเดต" ´|=´ ซึ่ง
ใช้ตัวกรองทางด้านขวามือและหาค่าใหม่สำหรับคุณสมบัติของ .
ถูกกำหนดโดยการเรียกใช้ค่าเก่าผ่านนิพจน์นี้ ตัวอย่างเช่น .foo |=
.+1 จะสร้างวัตถุโดยตั้งค่าฟิลด์ "foo" เป็น "foo" ของอินพุต บวก 1

ตัวอย่างนี้ควรแสดงความแตกต่างระหว่าง ´=´ และ ´|=´:

ป้อนข้อมูล ´{"a": {"b": 10}, "b": 20}´ ให้กับโปรแกรม:

.a = .b .a |= .b

อดีตจะตั้งค่าฟิลด์ "a" ของอินพุตเป็นฟิลด์ "b" ของอินพุต และสร้าง
ผลลัพธ์ {"a": 20} หลังจะตั้งค่าฟิลด์ "a" ของอินพุตเป็นฟิลด์ "a"'s
ฟิลด์ "b" สร้าง {"a": 10}

ด้านซ้ายมือสามารถเป็นนิพจน์เส้นทางทั่วไปใดๆ ดู เส้นทาง().

โปรดทราบว่าด้านซ้ายมือของ ´|=´ หมายถึงค่าใน .. ดังนั้น $var.foo |= . + 1 เคยชิน
ทำงานตามที่คาดไว้ ($var.foo ไม่ใช่นิพจน์เส้นทางที่ถูกต้องหรือมีประโยชน์ใน .); ใช้ $var | .ฟู
|= . + 1 แทน.

หากด้านขวาส่งออกค่าหลายค่า ระบบจะใช้เฉพาะค่าสุดท้ายเท่านั้น

jq ´(..|select(type=="boolean")) |= ถ้า แล้วก็ 1 อื่น 0 end´
[จริง,เท็จ,[5,จริง,[จริง,[เท็จ]],เท็จ]]
=> [1,0,[5,1,[1,[0]],0]]

- - - - - // =
jq มีโอเปอเรเตอร์สองสามตัวของฟอร์ม a สหกรณ์= bซึ่งทั้งหมดเทียบเท่ากับ a |= . op b. ดังนั้น,
+= 1 สามารถใช้เพื่อเพิ่มค่าได้

jq '.foo += 1'
{"ฟู": 42}
=> {"foo": 43}

ซับซ้อน ที่ได้รับมอบหมาย
อนุญาตให้ทำสิ่งต่างๆ ทางด้านซ้ายมือของการกำหนด jq ได้มากกว่าในหลายๆ อย่าง
ภาษา เราเห็นช่องธรรมดาทางด้านซ้ายมือแล้ว และไม่ใช่
แปลกใจที่การเข้าถึงอาร์เรย์ใช้งานได้เช่นกัน:

.posts[0].title = "คู่มือ JQ"

สิ่งที่น่าประหลาดใจก็คือนิพจน์ทางด้านซ้ายอาจก่อให้เกิดผลคูณ
ผลลัพธ์ที่อ้างถึงจุดต่าง ๆ ในเอกสารอินพุต:

.posts[].comments |= + ["ดีมาก"]

ตัวอย่างนั้นต่อท้ายสตริง "นี้ดีมาก" ต่อท้ายอาร์เรย์ "ความคิดเห็น" ของแต่ละโพสต์ใน
อินพุต (โดยที่อินพุตเป็นวัตถุที่มีฟิลด์ "โพสต์" ซึ่งเป็นอาร์เรย์ของโพสต์)

เมื่อ jq พบการมอบหมายเช่น ´a = b´ จะบันทึก "เส้นทาง" ที่ใช้เพื่อเลือก a
ส่วนหนึ่งของเอกสารอินพุตขณะดำเนินการ เส้นทางนี้ใช้เพื่อค้นหาว่าส่วนใดของ
อินพุตที่จะเปลี่ยนแปลงขณะดำเนินการมอบหมาย สามารถใช้ฟิลเตอร์ใดก็ได้บน
ด้านซ้ายมือของเท่ากับ - เส้นทางใดก็ตามที่เลือกจากอินพุตจะเป็นตำแหน่งที่
มีการมอบหมายงาน

นี่เป็นการดำเนินการที่ทรงพลังมาก สมมติว่าเราต้องการเพิ่มความคิดเห็นในโพสต์บล็อกโดยใช้
อินพุต "บล็อก" เดียวกันด้านบน ครั้งนี้ขอแสดงความคิดเห็นเฉพาะโพสต์ที่เขียนโดย
"สเตโดแลน" เราสามารถค้นหาโพสต์เหล่านั้นได้โดยใช้ฟังก์ชัน "เลือก" ที่อธิบายไว้ก่อนหน้านี้:

.posts[] | เลือก (.author == "sedolan")

เส้นทางที่ดำเนินการโดยการดำเนินการนี้ชี้ไปที่แต่ละโพสต์ที่ "stedolan" เขียนและ
เราสามารถแสดงความคิดเห็นเกี่ยวกับแต่ละรายการในลักษณะเดียวกับที่เราทำก่อนหน้านี้:

(.posts[] | select(.author == "stedolan") | .comments) |=
. + ["แย่มาก"]

โมดูล

jq มีระบบไลบรารี/โมดูล โมดูลคือไฟล์ที่มีชื่อลงท้ายด้วย .jq.

โมดูลที่นำเข้าโดยโปรแกรมจะถูกค้นหาในเส้นทางการค้นหาเริ่มต้น (ดูด้านล่าง) ดิ
นำเข้า และ ประกอบด้วย คำสั่งอนุญาตให้ผู้นำเข้าเปลี่ยนเส้นทางนี้

เส้นทางในเส้นทางการค้นหาอาจมีการแทนที่ต่างๆ

สำหรับพาธที่ขึ้นต้นด้วย "~/" โฮมไดเร็กทอรีของผู้ใช้จะถูกแทนที่ด้วย "~"

สำหรับพาธที่ขึ้นต้นด้วย "$ORIGIN/" พาธของไฟล์เรียกทำงาน jq จะถูกแทนที่ด้วย
"$ ต้นกำเนิด"

สำหรับพาธที่ขึ้นต้นด้วย "./" หรือพาธที่เป็น "." พาธของไฟล์รวมคือ
แทน "." สำหรับโปรแกรมระดับบนสุดที่กำหนดในบรรทัดคำสั่ง ค่าปัจจุบัน
ใช้ไดเร็กทอรี

คำสั่งนำเข้าสามารถเลือกระบุเส้นทางการค้นหาที่จะผนวกค่าเริ่มต้นไว้

เส้นทางการค้นหาเริ่มต้นคือเส้นทางการค้นหาที่กำหนดให้กับ -L ตัวเลือกบรรทัดคำสั่ง else
["~/.jq", "$ORIGIN/../lib/jq", "$ต้นกำเนิด/../ lib"].

องค์ประกอบเส้นทางสตริงว่างและว่างเปล่าจะยุติการประมวลผลเส้นทางการค้นหา

การพึ่งพาที่มีพาธสัมพัทธ์ "foo/bar" จะถูกค้นหาใน "foo/bar.jq" และ
"foo/bar/bar.jq" ในเส้นทางการค้นหาที่กำหนด มีวัตถุประสงค์เพื่อให้วางโมดูลได้
ในไดเร็กทอรี เช่น ไฟล์ควบคุมเวอร์ชัน ไฟล์ README เป็นต้น
แต่ยังอนุญาตให้ใช้โมดูลไฟล์เดียว

ส่วนประกอบที่มีชื่อเดียวกันติดต่อกันไม่ได้รับอนุญาตให้หลีกเลี่ยงความกำกวม (เช่น
"foo/foo")

ตัวอย่างเช่นด้วย -L$HOME/.jq โมดูล foo สามารถพบได้ใน $HOME/.jq/foo.jq และ
$HOME/.jq/foo/foo.jq.

ถ้า "$HOME/.jq" เป็นไฟล์ แสดงว่าไฟล์นั้นมาจากโปรแกรมหลัก

นำเข้า RelativePathString as ชื่อ [ ];
นำเข้าโมดูลที่พบในเส้นทางที่กำหนดซึ่งสัมพันธ์กับไดเรกทอรีในเส้นทางการค้นหา เอ ".jq"
คำต่อท้ายจะถูกเพิ่มในสตริงพาธสัมพัทธ์ สัญลักษณ์ของโมดูลนำหน้าด้วย
"ชื่อ::".

ข้อมูลเมตาที่เป็นทางเลือกต้องเป็นนิพจน์ jq คงที่ ควรเป็นวัตถุที่มีคีย์
เช่น "หน้าแรก" เป็นต้น ในขณะนี้ jq ใช้เฉพาะคีย์ / ค่า "ค้นหา" ของ
ข้อมูลเมตา ข้อมูลเมตายังให้บริการแก่ผู้ใช้ผ่านทาง โมดูลเมตา สร้างขึ้น

คีย์ "ค้นหา" ในข้อมูลเมตา หากมี ควรมีค่าสตริงหรืออาร์เรย์ (array
ของสตริง); นี่คือเส้นทางการค้นหาที่จะนำหน้าไปยังเส้นทางการค้นหาระดับบนสุด

ประกอบด้วย RelativePathString [ ];
นำเข้าโมดูลที่พบในเส้นทางที่กำหนดซึ่งสัมพันธ์กับไดเรกทอรีในเส้นทางการค้นหาราวกับว่ามัน
ถูกรวมอยู่ในสถานที่ ส่วนต่อท้าย ".jq" จะถูกเพิ่มลงในสตริงพาธสัมพัทธ์ ดิ
สัญลักษณ์ของโมดูลถูกนำเข้าไปยังเนมสเปซของผู้โทรราวกับว่าเนื้อหาของโมดูลมี
รวมโดยตรง

ข้อมูลเมตาที่เป็นทางเลือกต้องเป็นนิพจน์ jq คงที่ ควรเป็นวัตถุที่มีคีย์
เช่น "หน้าแรก" เป็นต้น ในขณะนี้ jq ใช้เฉพาะคีย์ / ค่า "ค้นหา" ของ
ข้อมูลเมตา ข้อมูลเมตายังให้บริการแก่ผู้ใช้ผ่านทาง โมดูลเมตา สร้างขึ้น

นำเข้า RelativePathString as $ชื่อ [ ];
นำเข้าไฟล์ JSON ที่พบในเส้นทางที่กำหนดซึ่งสัมพันธ์กับไดเรกทอรีในเส้นทางการค้นหา อา
ส่วนต่อท้าย ".json" จะถูกเพิ่มลงในสตริงพาธสัมพัทธ์ ข้อมูลของไฟล์จะเป็น
ใช้ได้เป็น $ชื่อ::ชื่อ.

ข้อมูลเมตาที่เป็นทางเลือกต้องเป็นนิพจน์ jq คงที่ ควรเป็นวัตถุที่มีคีย์
เช่น "หน้าแรก" เป็นต้น ในขณะนี้ jq ใช้เฉพาะคีย์ / ค่า "ค้นหา" ของ
ข้อมูลเมตา ข้อมูลเมตายังให้บริการแก่ผู้ใช้ผ่านทาง โมดูลเมตา สร้างขึ้น

คีย์ "ค้นหา" ในข้อมูลเมตา หากมี ควรมีค่าสตริงหรืออาร์เรย์ (array
ของสตริง); นี่คือเส้นทางการค้นหาที่จะนำหน้าไปยังเส้นทางการค้นหาระดับบนสุด

โมดูล ;
คำสั่งนี้เป็นทางเลือกทั้งหมด ไม่จำเป็นสำหรับการทำงานที่เหมาะสม มันทำหน้าที่
เฉพาะวัตถุประสงค์ในการให้ข้อมูลเมตาที่สามารถอ่านได้ด้วย โมดูลเมตา สร้างขึ้น

ข้อมูลเมตาต้องเป็นนิพจน์ jq คงที่ ควรเป็นวัตถุที่มีปุ่มเช่น
"หน้าแรก". ในขณะนี้ jq ไม่ได้ใช้ข้อมูลเมตานี้ แต่ให้บริการแก่ผู้ใช้
เมื่อ โมดูลเมตา สร้างขึ้น

โมดูลเมตา
ใช้ชื่อโมดูลเป็นอินพุตและส่งออกข้อมูลเมตาของโมดูลเป็นอ็อบเจ็กต์ โดย
การนำเข้าของโมดูล (รวมถึงข้อมูลเมตา) เป็นค่าอาร์เรย์สำหรับคีย์ "deps"

โปรแกรมสามารถใช้สิ่งนี้เพื่อสืบค้นข้อมูลเมตาของโมดูล ซึ่งพวกเขาสามารถใช้เพื่อ
ตัวอย่าง ค้นหา ดาวน์โหลด และติดตั้งการขึ้นต่อกันที่ขาดหายไป

ใช้ jq ออนไลน์โดยใช้บริการ onworks.net