jq - Trực tuyến trên đám mây

CHƯƠNG TRÌNH:

TÊN

jq - Bộ xử lý JSON dòng lệnh

SYNOPSIS

jq [lựa chọn...] lọc [các tập tin...]

jq có thể chuyển đổi JSON theo nhiều cách khác nhau, bằng cách chọn, lặp lại, giảm bớt và các cách khác
mangling tài liệu JSON. Ví dụ: chạy lệnh jq ´map (.price) | cộng sẽ
lấy một mảng các đối tượng JSON làm đầu vào và trả về tổng các trường "giá" của chúng.

jq cũng có thể chấp nhận nhập văn bản, nhưng theo mặc định, jq đọc một luồng các thực thể JSON
(bao gồm số và các chữ khác) từ tiêu chuẩn. Khoảng trắng chỉ cần thiết để phân tách
các thực thể như 1 và 2, true và false. Một hoặc nhiều các tập tin có thể được chỉ định, trong đó
trường hợp jq thay vào đó sẽ đọc đầu vào từ những người đó.

Sản phẩm lựa chọn được mô tả trong KÊU GỌI JQ phần; họ chủ yếu quan tâm đến đầu vào và đầu ra
định dạng. Các lọc được viết bằng ngôn ngữ jq và chỉ định cách chuyển đổi
tập tin hoặc tài liệu đầu vào.

LỌC

Chương trình jq là một "bộ lọc": nó nhận một đầu vào và tạo ra một đầu ra. Ở đây co rât nhiêu
bộ lọc nội trang để trích xuất một trường cụ thể của một đối tượng hoặc chuyển đổi một số thành
một chuỗi hoặc nhiều tác vụ tiêu chuẩn khác.

Các bộ lọc có thể được kết hợp theo nhiều cách khác nhau - bạn có thể chuyển đầu ra của một bộ lọc vào
một bộ lọc khác hoặc thu thập đầu ra của một bộ lọc vào một mảng.

Một số bộ lọc tạo ra nhiều kết quả, chẳng hạn như có một bộ lọc tạo ra tất cả
các phần tử của mảng đầu vào của nó. Đưa bộ lọc đó vào một giây chạy bộ lọc thứ hai cho
từng phần tử của mảng. Nói chung, những thứ sẽ được thực hiện với các vòng lặp và lặp lại
trong các ngôn ngữ khác chỉ được thực hiện bằng cách dán các bộ lọc lại với nhau trong jq.

Điều quan trọng cần nhớ là mọi bộ lọc đều có đầu vào và đầu ra. Ngay cả các chữ
như "xin chào" hoặc 42 là các bộ lọc - chúng nhận một đầu vào nhưng luôn tạo ra cùng một ký tự như
đầu ra. Các hoạt động kết hợp hai bộ lọc, chẳng hạn như bổ sung, thường cung cấp cùng một đầu vào
cho cả hai và kết hợp các kết quả. Vì vậy, bạn có thể triển khai bộ lọc trung bình như thêm vào / chiều dài
- cung cấp cả mảng đầu vào cho thêm vào bộ lọc và chiều dài lọc và sau đó thực hiện
các bộ phận.

Nhưng điều đó đang vượt lên trước chính chúng ta. :) Hãy bắt đầu với một cái gì đó đơn giản hơn:

KÊU GỌI JQ

bộ lọc jq chạy trên luồng dữ liệu JSON. Đầu vào cho jq được phân tích cú pháp thành một chuỗi
Các giá trị JSON được phân tách bằng khoảng trắng được chuyển qua bộ lọc được cung cấp tại một
thời gian. (Các) đầu ra của bộ lọc được ghi theo tiêu chuẩn, một lần nữa dưới dạng một chuỗi
dữ liệu JSON được phân tách bằng khoảng trắng.

Lưu ý: điều quan trọng là phải ghi nhớ các quy tắc trích dẫn của shell. Theo nguyên tắc chung, tốt nhất là
luôn luôn trích dẫn (với các ký tự trong một dấu ngoặc kép) chương trình jq, vì quá nhiều ký tự có
ý nghĩa đặc biệt đối với jq cũng là các ký tự meta shell. Ví dụ, jq "foo" sẽ thất bại
hầu hết các shell Unix vì nó sẽ giống như jq foo, thường sẽ thất bại
bởi vì foo is không xác định. Khi sử dụng trình bao lệnh Windows (cmd.exe), tốt nhất bạn nên
sử dụng dấu ngoặc kép xung quanh chương trình jq của bạn khi được đưa ra trên dòng lệnh (thay vì -f
tập tin chương trình tùy chọn), nhưng sau đó dấu ngoặc kép trong chương trình jq cần thoát dấu gạch chéo ngược.

Bạn có thể ảnh hưởng đến cách jq đọc và ghi đầu vào và đầu ra của nó bằng một số dòng lệnh
lựa chọn:

· --phiên bản:

Xuất ra phiên bản jq và thoát bằng XNUMX.

· --seq:

Sử dụng application / json-seq Lược đồ kiểu MIME để tách văn bản JSON trong đầu vào của jq
và đầu ra. Điều này có nghĩa là một ký tự ASCII RS (dấu phân tách bản ghi) được in trước
mỗi giá trị trên đầu ra và ASCII LF (nguồn cấp dòng) được in sau mỗi đầu ra. Đầu vào
Các văn bản JSON không thể phân tích cú pháp được bỏ qua (nhưng đã được cảnh báo về), loại bỏ tất cả
đầu vào tiếp theo cho đến RS tiếp theo. Điều này cũng phân tích cú pháp đầu ra của jq mà không có
--seq tùy chọn.

· --dòng:

Phân tích cú pháp đầu vào theo kiểu truyền trực tuyến, chia nhỏ các mảng giá trị đường dẫn và lá
(vô hướng và mảng trống hoặc đối tượng trống). Ví dụ, "a" trở thành [[],"Một"]và
[[], "a", ["b"]] trở thành [[0], []], [[1], "a"]và [[1,0], "b"].

Điều này rất hữu ích để xử lý các đầu vào rất lớn. Sử dụng điều này kết hợp với
lọc và giảm và cho mỗi cú pháp để giảm dần các đầu vào lớn.

· --lurp/-s:

Thay vì chạy bộ lọc cho từng đối tượng JSON trong đầu vào, hãy đọc toàn bộ đầu vào
truyền vào một mảng lớn và chỉ chạy bộ lọc một lần.

· --đầu vào thô/-R:

Không phân tích cú pháp đầu vào dưới dạng JSON. Thay vào đó, mỗi dòng văn bản được chuyển đến bộ lọc dưới dạng
dây. Nếu kết hợp với --lurp, sau đó toàn bộ đầu vào được chuyển đến bộ lọc dưới dạng
chuỗi dài đơn.

· --null-đầu vào/-n:

Không đọc bất kỳ đầu vào nào cả! Thay vào đó, bộ lọc được chạy một lần bằng cách sử dụng vô giá trị làm đầu vào.
Điều này hữu ích khi sử dụng jq như một máy tính đơn giản hoặc để xây dựng dữ liệu JSON từ
vết trầy.

· - đầu ra compact / -c:

Theo mặc định, jq in đầu ra JSON khá đẹp. Sử dụng tùy chọn này sẽ dẫn đến nhiều hơn
đầu ra nhỏ gọn bằng cách đặt mỗi đối tượng JSON trên một dòng duy nhất.

· --chuyển hướng:

Sử dụng một tab cho mỗi mức thụt lề thay vì hai khoảng trắng.

· --entent n:

Sử dụng số khoảng trắng đã cho (không quá 8) để thụt lề.

· - màu sắc đầu ra / -C và --monochrome-đầu ra / -M:

Theo mặc định, jq xuất ra JSON có màu nếu ghi vào một thiết bị đầu cuối. Bạn có thể buộc nó phải
tạo ra màu sắc ngay cả khi ghi vào đường ống hoặc tệp bằng cách sử dụng -Cvà vô hiệu hóa màu với -M.

· --ascii-đầu ra / -a:

jq thường xuất ra mã mã Unicode không phải ASCII dưới dạng UTF-8, ngay cả khi đầu vào được chỉ định
chúng dưới dạng chuỗi thoát (như "\ u03bc"). Sử dụng tùy chọn này, bạn có thể buộc jq
tạo ra đầu ra ASCII thuần túy với mọi ký tự không phải ASCII được thay thế bằng ký tự tương đương
trình tự thoát.

· --không có bộ đệm

Xả đầu ra sau khi mỗi đối tượng JSON được in (hữu ích nếu bạn đang chạy chậm
nguồn dữ liệu vào jq và đầu ra của jq ở nơi khác).

· - phím sắp xếp / -S:

Xuất ra các trường của từng đối tượng với các khóa theo thứ tự được sắp xếp.

· --raw-đầu ra / -r:

Với tùy chọn này, nếu kết quả của bộ lọc là một chuỗi thì nó sẽ được ghi trực tiếp
thành đầu ra tiêu chuẩn thay vì được định dạng dưới dạng chuỗi JSON với dấu ngoặc kép. Cái này có thể
hữu ích để làm cho các bộ lọc jq nói chuyện với các hệ thống không dựa trên JSON.

· - tham gia đầu ra / -j:

Như -r nhưng jq sẽ không in một dòng mới sau mỗi đầu ra.

· -f tên tập tin / --from-tệp tên tập tin:

Đọc bộ lọc từ tệp thay vì từ một dòng lệnh, như tùy chọn awk´s -f. Bạn
cũng có thể sử dụng ´ # ´ để đưa ra nhận xét.

· -Thư mục / -L thư mục:

Thêm trước thư mục vào danh sách tìm kiếm các mô-đun. Nếu tùy chọn này được sử dụng thì không
danh sách tìm kiếm nội trang được sử dụng. Xem phần về mô-đun bên dưới.

· -e / --trạng thái thoát:

Đặt trạng thái thoát của jq thành 0 nếu giá trị đầu ra cuối cùng không phải là sai cũng không vô giá trị,
1 nếu giá trị đầu ra cuối cùng là sai or vô giá trị, hoặc 4 nếu không có kết quả hợp lệ nào
được sản xuất. Thông thường jq thoát với 2 nếu có bất kỳ sự cố sử dụng nào hoặc lỗi hệ thống, 3
nếu có lỗi biên dịch chương trình jq hoặc 0 nếu chương trình jq chạy.

· --arg tên giá trị:

Tùy chọn này chuyển một giá trị đến chương trình jq dưới dạng một biến được xác định trước. Nếu bạn chạy jq
với --arg foo thanhthì $ foo có sẵn trong chương trình và có giá trị "quán ba".
Lưu ý rằng giá trị sẽ được coi là một chuỗi, vì vậy --arg foo 123 sẽ ràng buộc $ foo đến "123".

· --argjson tên văn bản JSON:

Tùy chọn này chuyển một giá trị được mã hóa JSON đến chương trình jq dưới dạng một biến được xác định trước. Nếu như
bạn chạy jq với --argjson foo 123thì $ foo có sẵn trong chương trình và có
giá trị 123.

· --slurpfile tên biến tên tập tin:

Tùy chọn này đọc tất cả các văn bản JSON trong tệp được đặt tên và liên kết với một mảng
đã phân tích cú pháp các giá trị JSON thành biến toàn cục đã cho. Nếu bạn chạy jq với --argfile foo thanh,
sau đó $ foo có sẵn trong chương trình và có một mảng có các phần tử tương ứng với
văn bản trong tệp có tên thanh.

· --argfile tên biến tên tập tin:

Không được dùng. Sử dụng --slurpfile thay thế.

(Tùy chọn này giống như --slurpfile, nhưng khi tệp chỉ có một văn bản, thì đó là
được sử dụng, nếu không một mảng văn bản được sử dụng như trong --slurpfile.)

· --chạy thử nghiệm [tên tệp]:

Chạy các bài kiểm tra trong tệp đã cho hoặc đầu vào chuẩn. Đây phải là lựa chọn cuối cùng được đưa ra
và không tôn trọng tất cả các tùy chọn trước đó. Đầu vào bao gồm các dòng nhận xét, trống
dòng và dòng chương trình được theo sau bởi một dòng đầu vào, bao nhiêu dòng đầu ra
dự kiến ​​(một cho mỗi đầu ra) và một dòng trống kết thúc. Kiểm tra lỗi biên dịch
bắt đầu bằng dòng chỉ chứa "%% FAIL", sau đó là dòng chứa chương trình
biên dịch, sau đó là một dòng chứa thông báo lỗi để so sánh với thực tế.

Hãy cảnh báo rằng tùy chọn này có thể thay đổi ngược lại không tương thích.

BASIC LỌC

.
Bộ lọc tuyệt đối đơn giản nhất (và ít thú vị nhất) là .. Đây là một bộ lọc có
đầu vào và sản xuất nó không thay đổi như đầu ra.

Vì jq theo mặc định in tất cả đầu ra, chương trình tầm thường này có thể là một cách hữu ích để
định dạng đầu ra JSON từ, nói, quăn lại.

jq `.`
"Chào thế giới!"
=> "Hello, world!"

.foo, .foo.bar
Điều đơn giản nhất hữu ích bộ lọc là .foo. Khi được cung cấp một đối tượng JSON (hay còn gọi là từ điển hoặc băm) dưới dạng
đầu vào, nó tạo ra giá trị tại khóa "foo" hoặc null nếu không có.

Nếu khóa chứa các ký tự đặc biệt, bạn cần đặt khóa đó bằng dấu ngoặc kép như
điều này: . "foo $".

Một bộ lọc của biểu mẫu .foo.bar tương đương với .foo | .bar.

jq `.foo`
{"foo": 42, "bar": "dữ liệu kém thú vị hơn"}
=> 42

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

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

.foo?
Giống như .foo, nhưng không xuất hiện ngay cả lỗi khi . không phải là một mảng hoặc một đối tượng.

jq ´.foo? ´
{"foo": 42, "bar": "dữ liệu kém thú vị hơn"}
=> 42

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

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

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

. [ ], . [2], . [10:15]
Bạn cũng có thể tra cứu các trường của một đối tượng bằng cú pháp như . ["foo"] (.foo ở trên là một
phiên bản viết tắt của điều này). Điều này cũng hoạt động cho các mảng, nếu khóa là một số nguyên.
Mảng không dựa trên số XNUMX (như javascript), vì vậy [2] trả về phần tử thứ ba của mảng.

Sản phẩm . [10:15] cú pháp có thể được sử dụng để trả về một mảng con của một mảng hoặc chuỗi con của một chuỗi.
Mảng được trả về bởi . [10:15] sẽ có độ dài 5, chứa các phần tử từ chỉ mục 10
(bao gồm) đến chỉ số 15 (độc quyền). Một trong hai chỉ mục có thể âm (trong trường hợp đó nó được tính
ngược lại từ phần cuối của mảng), hoặc bị bỏ qua (trong trường hợp đó nó đề cập đến phần bắt đầu hoặc
cuối mảng).

Sản phẩm [2] cú pháp có thể được sử dụng để trả về phần tử tại chỉ mục đã cho. Các chỉ số tiêu cực là
được phép, với -1 đề cập đến phần tử cuối cùng, -2 đề cập đến phần tử tiếp theo đến phần tử cuối cùng,
và như vậy.

Sản phẩm .foo cú pháp chỉ hoạt động cho các phím đơn giản tức là các phím có tất cả các ký tự chữ và số.
. [ ] hoạt động với các phím có chứa các ký tự đặc biệt như dấu hai chấm và dấu chấm. Vì
ví dụ . ["foo :: bar"] và . ["foo.bar"] làm việc trong khi .foo :: bar và .foo.bar không muốn.

Sản phẩm ? "operator" cũng có thể được sử dụng với toán tử lát cắt, như trong . [10:15]?, kết quả đầu ra
các giá trị mà đầu vào có thể cắt.

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

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

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

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

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

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

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

. []
Nếu bạn sử dụng .[mục lục] cú pháp, nhưng bỏ qua hoàn toàn chỉ mục, nó sẽ trả về tất cả các của
các phần tử của một mảng. Đang chạy . [] với đầu vào [1,2,3] sẽ tạo ra các con số là ba
kết quả riêng biệt, thay vì dưới dạng một mảng.

Bạn cũng có thể sử dụng điều này trên một đối tượng và nó sẽ trả về tất cả các giá trị của đối tượng.

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

. []?
Như . [], nhưng không có lỗi sẽ được xuất ra nếu. không phải là một mảng hoặc đối tượng.

,
Nếu hai bộ lọc được phân tách bằng dấu phẩy, thì đầu vào sẽ được đưa vào cả hai và ở đó
sẽ là nhiều đầu ra: đầu tiên, tất cả các đầu ra được tạo bởi biểu thức bên trái, và
thì tất cả các kết quả đầu ra được tạo ra bởi quyền. Ví dụ, bộ lọc .foo, .Cafe, sản xuất
cả trường "foo" và trường "bar" dưới dạng kết quả đầu ra riêng biệt.

jq `.foo, .bar'
{"foo": 42, "bar": "something else", "baz": true}
=> 42, "cái gì đó khác"

jq ´.user, .projects [] ´
{"người dùng": "stedolan", "các dự án": ["jq", "wikiflow"]}
=> "stedolan", "jq", "wikiflow"

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

|
Các | toán tử kết hợp hai bộ lọc bằng cách đưa (các) đầu ra của bộ lọc ở bên trái vào
đầu vào của một trong những bên phải. Nó khá giống với đường ống của Unix shell, nếu
bạn đã quen với điều đó.

Nếu kết quả ở bên trái tạo ra nhiều kết quả, kết quả ở bên phải sẽ được chạy cho
mỗi kết quả đó. Vì vậy, biểu thức . [] | .foo truy xuất trường "foo" của mỗi
phần tử của mảng đầu vào.

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

LOẠI VÀ GIÁ TRỊ

jq hỗ trợ cùng một tập hợp các kiểu dữ liệu như JSON - số, chuỗi, boolean, mảng,
các đối tượng (trong JSON-speak là hàm băm chỉ có các khóa chuỗi) và "null".

Boolean, null, chuỗi và số được viết giống như trong javascript. Giống như
mọi thứ khác trong jq, những giá trị đơn giản này nhận một đầu vào và tạo ra một đầu ra - 42 là một
biểu thức jq hợp lệ nhận một đầu vào, bỏ qua nó và trả về 42 thay thế.

Mảng xây dựng - []
Như trong JSON, [] được sử dụng để tạo mảng, như trong [1,2,3]. Các phần tử của mảng có thể
là bất kỳ biểu thức jq nào. Tất cả các kết quả được tạo ra bởi tất cả các biểu thức được thu thập
thành một mảng lớn. Bạn có thể sử dụng nó để xây dựng một mảng từ một số lượng giá trị đã biết
(như trong [.foo, .quán ba, .baz]) hoặc để "thu thập" tất cả các kết quả của một bộ lọc vào một mảng (như
in [.items []. name])

Khi bạn hiểu toán tử ",", bạn có thể xem cú pháp mảng của jq theo một cách khác
ánh sáng: biểu thức [1,2,3] không sử dụng cú pháp tích hợp cho các mảng được phân tách bằng dấu phẩy,
nhưng thay vào đó là áp dụng [] toán tử (thu thập kết quả) cho biểu thức 1,2,3 (mà
tạo ra ba kết quả khác nhau).

Nếu bạn có một bộ lọc X tạo ra bốn kết quả, sau đó biểu thức [X] sẽ tạo ra một
kết quả duy nhất, một mảng bốn phần tử.

jq ´ [.user, .projects []] ´
{"người dùng": "stedolan", "các dự án": ["jq", "wikiflow"]}
=> ["stedolan", "jq", "wikiflow"]

Đối tượng - {}
Giống như JSON, {} là để xây dựng các đối tượng (còn gọi là từ điển hoặc mã băm), như trong: {"Một": 42,
"NS": Năm 17}.

Nếu các phím là "hợp lý" (tất cả các ký tự chữ cái), thì có thể bỏ dấu ngoặc kép.
Giá trị có thể là bất kỳ biểu thức nào (mặc dù bạn có thể cần đặt nó trong dấu ngoặc đơn nếu nó
phức tạp), được áp dụng cho đầu vào của {} biểu thức (hãy nhớ, tất cả các bộ lọc
có một đầu vào và một đầu ra).

{foo: .bar}

sẽ tạo ra đối tượng JSON {"foo": Năm 42} nếu được cung cấp đối tượng JSON {"thanh": 42, "baz": 43}.
Bạn có thể sử dụng điều này để chọn các trường cụ thể của một đối tượng: nếu đầu vào là một đối tượng có
các trường "người dùng", "tiêu đề", "id" và "nội dung" và bạn chỉ muốn "người dùng" và "tiêu đề", bạn có thể
viết

{người dùng: .user, title: .title}

Bởi vì điều đó quá phổ biến, có một cú pháp tắt: {người sử dụng, chức vụ}.

Nếu một trong các biểu thức tạo ra nhiều kết quả, nhiều từ điển sẽ
được sản xuất. Nếu đầu vào là

{"user": "stedolan", "title": ["JQ Primer", "Thêm JQ"]}

thì biểu thức

{người dùng, tiêu đề: .titles []}

sẽ tạo ra hai đầu ra:

{"user": "stedolan", "title": "JQ Primer"}
{"user": "stedolan", "title": "Thêm JQ"}

Đặt dấu ngoặc quanh khóa có nghĩa là nó sẽ được đánh giá như một biểu thức. Với
đầu vào tương tự như trên,

{(.user): .title}

sản xuất

{"stedolan": ["JQ Primer", "Thêm JQ"]}

jq ´ {người dùng, tiêu đề: .titles []} ´
{"user": "stedolan", "title": ["JQ Primer", "Thêm JQ"]}
=> {"user": "stedolan", "title": "JQ Primer"}, {"user": "stedolan", "title": "Thêm JQ"}

jq ´ {(. người dùng): .titles} ´
{"user": "stedolan", "title": ["JQ Primer", "Thêm JQ"]}
=> {"stedolan": ["JQ Primer", "Thêm JQ"]}

ĐƯỢC XÂY DỰNG TRONG ĐIỀU HÀNH VÀ CHỨC NĂNG

Một số toán tử jq (ví dụ: +) làm những việc khác nhau tùy thuộc vào loại
đối số (mảng, số, v.v.). Tuy nhiên, jq không bao giờ thực hiện chuyển đổi kiểu ngầm định. Nếu như
bạn cố gắng thêm một chuỗi vào một đối tượng, bạn sẽ nhận được thông báo lỗi và không có kết quả.

Ngoài ra - +
Người điều hành + sử dụng hai bộ lọc, áp dụng cả hai cho cùng một đầu vào và thêm
kết quả với nhau. "Thêm" có nghĩa là gì phụ thuộc vào các loại liên quan:

· Số được thêm vào bằng số học bình thường.

· Mảng được thêm vào bằng cách nối thành một mảng lớn hơn.

· Strings được thêm vào bằng cách nối thành một chuỗi lớn hơn.

· Đối tượng được thêm vào bằng cách hợp nhất, nghĩa là chèn tất cả các cặp khóa-giá trị từ cả hai
các đối tượng thành một đối tượng kết hợp duy nhất. Nếu cả hai đối tượng đều chứa một giá trị giống nhau
chìa khóa, đối tượng ở bên phải của + chiến thắng. (Đối với hợp nhất đệ quy, hãy sử dụng * nhà điều hành.)

vô giá trị có thể được thêm vào bất kỳ giá trị nào và trả về giá trị khác không thay đổi.

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} ´
vô giá trị
=> {"a": 42, "b": 2, "c": 3}

Trừ - -
Cũng như phép trừ số học thông thường trên các số, - toán tử có thể được sử dụng trên mảng
để xóa tất cả các lần xuất hiện của các phần tử của mảng thứ hai khỏi mảng đầu tiên.

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

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

Phép nhân, sự phân chia, hình thức - *, /, và %
Các toán tử infix này hoạt động như mong đợi khi cho hai số. Chia cho XNUMX tăng
một lỗi. x % y tính x modulo y.

Nhân một chuỗi với một số sẽ tạo ra sự nối chuỗi đó nhiều
lần. "NS" * 0 sản xuất vô giá trị.

Chia một chuỗi cho một chuỗi khác sẽ chia chuỗi đầu tiên bằng cách sử dụng chuỗi thứ hai làm dấu phân cách.

Nhân hai đối tượng sẽ hợp nhất chúng một cách đệ quy: điều này hoạt động giống như phép cộng nhưng nếu cả hai
các đối tượng chứa một giá trị cho cùng một khóa và các giá trị là các đối tượng, cả hai được hợp nhất
với cùng một chiến lược.

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}} ´
vô giá trị
=> {"k": {"a": 0, "b": 2, "c": 3}}

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

chiều dài
Hàm nội trang chiều dài nhận độ dài của nhiều loại giá trị khác nhau:

· Chiều dài của một chuỗi là số lượng mã Unicode mà nó chứa (sẽ là
giống với độ dài được mã hóa JSON của nó tính bằng byte nếu nó là ASCII thuần túy).

· Chiều dài của một mảng là số phần tử.

· Chiều dài của một vật là số cặp khóa-giá trị.

· Chiều dài của vô giá trị là số không.

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

chìa khóa, key_unsorted
Hàm nội trang phím, khi được cung cấp một đối tượng, trả về các khóa của nó trong một mảng.

Các khóa được sắp xếp theo thứ tự bảng chữ cái, theo thứ tự mã điểm unicode. Đây không phải là một đơn đặt hàng
có ý nghĩa cụ thể trong bất kỳ ngôn ngữ cụ thể nào, nhưng bạn có thể tin tưởng rằng nó là
giống nhau cho hai đối tượng bất kỳ có cùng bộ khóa, bất kể cài đặt ngôn ngữ.

Thời Gian phím được cung cấp cho một mảng, nó trả về các chỉ số hợp lệ cho mảng đó: các số nguyên
từ 0 đến length-1.

Sản phẩm key_unsorted chức năng giống như phím, nhưng nếu đầu vào là một đối tượng thì các phím
sẽ không được sắp xếp, thay vào đó các khóa sẽ gần như theo thứ tự chèn.

jq ´phím´
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Foo", "abc", "abcd"]

jq ´phím´
[42,3,35]
=> [0,1,2]

có (chìa khóa)
Hàm nội trang có trả về liệu đối tượng đầu vào có khóa đã cho hay đầu vào
mảng có một phần tử tại chỉ số đã cho.

có ($ key) có tác dụng tương tự như kiểm tra xem phím $ là một thành viên của mảng được trả về
by phím, mặc dầu có sẽ nhanh hơn.

jq ´map (has ("foo")) ´
[{"foo": 42}, {}]
=> [true, false]

jq ´map (có(2)) ´
[[0,1], ["a", "b", "c"]]
=> [sai, đúng]

in
Hàm nội trang in trả về khóa đầu vào nằm trong đối tượng đã cho hoặc chỉ mục đầu vào
tương ứng với một phần tử trong mảng đã cho. Về cơ bản, nó là một phiên bản đảo ngược của
có.

jq ´. [] | trong ({"foo": 42}) ´
["foo", "bar"]
=> true, false

jq ´map (trong ([0,1])) ´
[2, 0]
=> [sai, đúng]

path (path_expression)
Xuất ra các biểu diễn mảng của biểu thức đường dẫn đã cho trong .. Kết quả đầu ra là các mảng
chuỗi (các khóa trong đối tượng0 và / hoặc số (chỉ số mảng.

Biểu thức đường dẫn là biểu thức jq như .a, Mà còn . []. Có hai loại đường dẫn
biểu thức: những biểu thức có thể khớp chính xác và những biểu thức không thể khớp. Ví dụ, .abc là một
biểu thức đường dẫn đối sánh chính xác, trong khi .a []. b không phải là.

đường dẫn (biểu_thức_chính xác) sẽ tạo ra biểu diễn mảng của biểu thức đường dẫn
ngay cả khi nó không tồn tại trong ., Nếu . is vô giá trị hoặc một mảng hoặc một đối tượng.

đường dẫn (mẫu) sẽ tạo ra các biểu diễn mảng của các đường dẫn phù hợp Belt Hold nếu
những con đường tồn tại trong ..

Lưu ý rằng biểu thức đường dẫn không khác với biểu thức bình thường. Cách diễn đạt
path (.. | select (type == "boolean")) xuất tất cả các đường dẫn đến giá trị boolean trong ., và chỉ
những con đường đó.

jq ´path (.a [0] .b) ´
vô giá trị
=> ["a", 0, "b"]

jq ´ [đường dẫn (..)] ´
{"a": [{"b": 1}]}
=> [[], ["a"], ["a", 0], ["a", 0, "b"]]

del (path_expression)
Hàm nội trang các loại bỏ một khóa và giá trị tương ứng của nó khỏi một đối tượng.

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

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

to_entry, từ_entry, with_entries
Các hàm này chuyển đổi giữa một đối tượng và một mảng các cặp khóa-giá trị. Nếu như to_entry
được chuyển qua một đối tượng, sau đó cho mỗi k: v nhập trong đầu vào, mảng đầu ra bao gồm
{"Chìa khóa": k, "giá trị": v}.

from_entries chuyển đổi ngược lại, và with_entries (foo) là cách viết tắt của
to_entry | bản đồ (foo) | from_entries, hữu ích để thực hiện một số thao tác đối với tất cả các phím và
các giá trị của một đối tượng. from_entries chấp nhận khóa, Khóa, Tên, giá trị và Giá trị làm khóa.

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

jq ´từ_mục'
[{"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}

select (boolean_expression)
Các chức năng chọn (foo) tạo ra đầu vào của nó không thay đổi nếu foo trả về true cho đầu vào đó,
và không tạo ra đầu ra nào khác.

Nó hữu ích cho việc lọc danh sách: [1,2,3] | bản đồ (chọn (. >= 2)) sẽ cho bạn [2,3].

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

jq ´. [] | chọn (.id == "thứ hai") ´
[{"id": "first", "val": 1}, {"id": "second", "val": 2}]
=> {"id": "second", "val": 2}

mảng, các đối tượng, lặp đi lặp lại, toán tử, số, bình thường, hữu hạn, dây, không, giá trị,
vô hướng
Các tích hợp sẵn này chỉ chọn các đầu vào là mảng, đối tượng, tệp lặp (mảng hoặc
đối tượng), boolean, số, số bình thường, số hữu hạn, chuỗi, null, không null
giá trị và giá trị không lặp lại tương ứng.

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

trống
trống không trả về kết quả. Không có gì cả. Thậm chí không vô giá trị.

Đôi khi nó rất hữu ích. Bạn sẽ biết nếu bạn cần nó :)

jq ´1, trống, 2´
vô giá trị
=> 1, 2

jq ´ [1,2, trống, 3] ´
vô giá trị
=> [1,2,3]

lôi(thông điệp)
Tạo ra một lỗi, giống như .a được áp dụng cho các giá trị khác với null và các đối tượng sẽ, nhưng
với thông báo đã cho là giá trị của lỗi.

$ __ loc__
Tạo một đối tượng bằng khóa "tệp" và khóa "dòng", với tên tệp và số dòng
Ở đâu $ __ loc__ xảy ra, dưới dạng các giá trị.

jq ´try error ("\ ($ __ loc__)") bắt .´
vô giá trị
=> "{\" tệp \ ": \" \",\"dòng 1}"

bản đồ (x), map_values ​​(x)
Đối với bất kỳ bộ lọc nào x, bản đồ (x) sẽ chạy bộ lọc đó cho từng phần tử của mảng đầu vào và
tạo ra các kết quả đầu ra là một mảng mới. bản đồ (. + 1) sẽ tăng từng phần tử của một mảng
số.

Tương tự, map_values ​​(x) sẽ chạy bộ lọc đó cho từng phần tử, nhưng nó sẽ trả về
đối tượng khi một đối tượng được chuyển qua.

bản đồ (x) tương đương với [. [] | x]. Trên thực tế, đây là cách nó được định nghĩa. Tương tự,
map_values ​​(x) được định nghĩa là . [] |= x.

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

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

những con đường, đường dẫn (node_filter), lá_path
đường dẫn xuất ra các đường dẫn đến tất cả các phần tử trong đầu vào của nó (ngoại trừ nó không xuất ra
danh sách trống, đại diện. chinh no).

đường dẫn (f) xuất ra các đường dẫn đến bất kỳ giá trị nào f là đúng. Đó là, đường dẫn (số)
xuất ra các đường dẫn đến tất cả các giá trị số.

lá_path là một bí danh của đường dẫn (vô hướng); lá_path is phản đối và sẽ bị xóa trong
bản phát hành chính tiếp theo.

jq ´ [đường dẫn] ´
[1, [[], {"a": 2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]

jq ´ [đường dẫn (vô hướng)] ´
[1, [[], {"a": 2}]]
=> [[0], [1,1, "a"]]

thêm vào
Bộ lọc thêm vào nhận dưới dạng đầu vào của một mảng và sản xuất dưới dạng đầu ra các phần tử của mảng
them vao voi nhau. Điều này có thể có nghĩa là tổng hợp, nối hoặc hợp nhất tùy thuộc vào các loại
các phần tử của mảng đầu vào - các quy tắc giống như các quy tắc cho + nhà điều hành
(miêu tả trên).

Nếu đầu vào là một mảng trống, thêm vào Trả về vô giá trị.

jq ´thêm´
["a", "b", "c"]
=> "abc"

jq ´thêm´
[1, 2, 3]
=> 6

jq ´thêm´
[]
=> null

không tí nào, bất cứ điều kiện nào), bất kỳ (máy phát điện; tình trạng)
Bộ lọc bất kì nhận đầu vào là một mảng các giá trị boolean và tạo ra đúng như đầu ra nếu
bất kỳ phần tử nào của mảng là đúng.

Nếu đầu vào là một mảng trống, bất kì Trả về sai.

Sản phẩm bất cứ điều kiện nào) biểu mẫu áp dụng điều kiện đã cho cho các phần tử của mảng đầu vào.

Sản phẩm bất kỳ (máy phát điện; tình trạng) biểu mẫu áp dụng điều kiện đã cho cho tất cả các đầu ra của
máy phát điện đã cho.

jq ´bất kỳ´
[đúng sai]
=> đúng

jq ´bất kỳ´
[sai, sai]
=> sai

jq ´bất kỳ´
[]
=> sai

tất cả các, tất cả (điều kiện), tất cả (máy phát điện; tình trạng)
Bộ lọc tất cả các nhận đầu vào là một mảng các giá trị boolean và tạo ra đúng như đầu ra nếu
tất cả các phần tử của mảng là đúng.

Sản phẩm tất cả (điều kiện) biểu mẫu áp dụng điều kiện đã cho cho các phần tử của mảng đầu vào.

Sản phẩm tất cả (máy phát điện; tình trạng) biểu mẫu áp dụng điều kiện đã cho cho tất cả các đầu ra của
máy phát điện đã cho.

Nếu đầu vào là một mảng trống, tất cả các Trả về đúng.

jq 'tất cả'
[đúng sai]
=> sai

jq 'tất cả'
[đúng rồi]
=> đúng

jq 'tất cả'
[]
=> đúng

[Đòi hỏi 1.5] làm phẳng, làm phẳng (độ sâu)
Bộ lọc làm phẳng nhận đầu vào là một mảng các mảng lồng nhau và tạo ra một mảng phẳng trong
mà tất cả các mảng bên trong mảng ban đầu đã được thay thế đệ quy bằng các giá trị của chúng.
Bạn có thể truyền một đối số cho nó để chỉ định có bao nhiêu cấp độ lồng nhau để làm phẳng.

làm phẳng(2) giống như làm phẳng, nhưng chỉ đi sâu đến hai cấp độ.

jq ´làm phẳng´
[1, [2], [[3]]]
=> [1, 2, 3]

jq `làm phẳng(1) ´
[1, [2], [[3]]]
=> [1, 2, [3]]

jq ´làm phẳng´
[[]]
=> []

jq ´làm phẳng´
[{"foo": "bar"}, [{"foo": "baz"}]]
=> [{"foo": "bar"}, {"foo": "baz"}]

phạm vi (tối đa), phạm vi (từ; tối đa) phạm vi (từ; tối đa; bằng)
Sản phẩm phạm vi hàm tạo ra một loạt các số. phạm vi (4; 10) tạo ra 6 số, từ 4
(bao gồm) đến 10 (độc quyền). Các con số được tạo ra dưới dạng đầu ra riêng biệt. Sử dụng
[phạm vi (4; 10)] để nhận một phạm vi dưới dạng một mảng.

Biểu mẫu một đối số tạo ra các số từ 0 đến số đã cho, với số gia tăng là
1.

Biểu mẫu hai đối số tạo ra các số từ từ đến lên đến với số gia là 1.

Biểu mẫu ba đối số tạo ra số từ đến lên đến với sự gia tăng của by.

jq ´range (2; 4) ´
vô giá trị
=> 2, 3

jq ´ [phạm vi (2; 4)] ´
vô giá trị
=> [2,3]

jq ´ [phạm vi(4
vô giá trị
=> [0,1,2,3]

jq ´ [phạm vi (0; 10; 3)] ´
vô giá trị
=> [0,3,6,9]

jq ´ [phạm vi (0; 10; -1)] ´
vô giá trị
=> []

jq ´ [phạm vi (0; -5; -1)] ´
vô giá trị
=> [0,-1,-2,-3,-4]

sàn
Sản phẩm sàn hàm trả về tầng của đầu vào số của nó.

jq ´sàn´
3.14159
=> 3

câu hỏi
Sản phẩm câu hỏi hàm trả về căn bậc hai của đầu vào số của nó.

jq `sqrt'
9
=> 3

đến số
Sản phẩm đến số hàm phân tích cú pháp đầu vào của nó dưới dạng một số. Nó sẽ chuyển đổi được định dạng đúng
chuỗi tương đương với số của chúng, để nguyên số và đưa ra lỗi trên tất cả các
đầu vào.

jq ´. [] | đến số
[1, "1"]
=> 1, 1

xâu chuỗi
Sản phẩm xâu chuỗi hàm in đầu vào của nó dưới dạng một chuỗi. Các chuỗi được giữ nguyên và tất cả
các giá trị khác được mã hóa JSON.

jq ´. [] | xâu chuỗi´
[1, "1", [1]]
=> "1", "1", "[1]"

kiểu
Sản phẩm kiểu hàm trả về kiểu đối số của nó là một chuỗi, là một trong các giá trị null,
boolean, số, chuỗi, mảng hoặc đối tượng.

jq ´map (loại) ´
[0, false, [], {}, null, "xin chào"]
=> ["number", "boolean", "array", "object", "null", "string"]

vô hạn, nan, là vô hạn, là, vô hạn, bình thường
Một số phép toán số học có thể mang lại giá trị vô hạn và "không phải là số" (NaN). Các
là vô hạn lợi nhuận nội trang đúng nếu đầu vào của nó là vô hạn. Các isnan lợi nhuận nội trang đúng
nếu đầu vào của nó là NaN. Các vô hạn nội trang trả về một giá trị vô hạn dương. Các nan
nội trang trả về một NaN. Các bình thường nội trang trả về true nếu đầu vào của nó là một số bình thường.

Lưu ý rằng phép chia cho số XNUMX gây ra lỗi.

Hiện tại, hầu hết các phép toán số học hoạt động trên số vô hạn, NaN và số dưới chuẩn không
nêu ra những sai sót.

jq ´. [] | (vô hạn *.) <0´
[-1]
=> true, false

jq ´infinite, nan | kiểu
vô giá trị
=> "số", "số"

sắp xếp, sort_by (path_expression)
Sản phẩm loại các hàm sắp xếp đầu vào của nó, đầu vào phải là một mảng. Các giá trị được sắp xếp trong
làm theo nguyên tắc:

· vô giá trị

· sai

· đúng

· Số

· Chuỗi, theo thứ tự bảng chữ cái (theo giá trị mã điểm unicode)

· Mảng, theo thứ tự từ vựng

· các đối tượng

Thứ tự cho các đối tượng hơi phức tạp: đầu tiên chúng được so sánh bằng cách so sánh
tập hợp các khóa (dưới dạng các mảng theo thứ tự được sắp xếp) và nếu các khóa của chúng bằng nhau thì các giá trị là
từng khóa được so sánh.

loại có thể được sử dụng để sắp xếp theo một trường cụ thể của một đối tượng hoặc bằng cách áp dụng bất kỳ bộ lọc jq nào.

sort_by (foo) so sánh hai phần tử bằng cách so sánh kết quả của foo trên mỗi phần tử.

jq ´sắp xếp´
[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) nhận đầu vào là một mảng, nhóm các phần tử có cùng .foo lĩnh vực
thành các mảng riêng biệt và tạo ra tất cả các mảng này dưới dạng phần tử của một mảng lớn hơn,
được sắp xếp theo giá trị của .foo trường.

Bất kỳ biểu thức jq nào, không chỉ là truy cập trường, có thể được sử dụng thay cho .foo. Sự sắp xếp
thứ tự giống như được mô tả trong loại chức năng trên.

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

tối thiểu tối đa, min_by (path_exp), max_by (path_exp)
Tìm phần tử tối thiểu hoặc tối đa của mảng đầu vào.

Sản phẩm min_by (path_exp) và max_by (path_exp) chức năng cho phép bạn chỉ định một
lĩnh vực hoặc tài sản để kiểm tra, ví dụ: min_by (.foo) tìm đối tượng có nhỏ nhất foo
trường.

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

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

độc nhất, unique_by (path_exp)
Sản phẩm độc đáo hàm nhận đầu vào một mảng và tạo ra một mảng gồm các phần tử giống nhau, trong
sắp xếp thứ tự, với các bản sao bị loại bỏ.

Sản phẩm unique_by (path_exp) hàm sẽ chỉ giữ một phần tử cho mỗi giá trị thu được bởi
áp dụng lý lẽ. Hãy coi nó như tạo một mảng bằng cách lấy ra một phần tử trong mỗi
nhóm sản xuất bởi nhóm.

jq ´duy nhất´
[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 (chiều dài) ´
["chunky", "bacon", "kitten", "cicada", "măng tây"]
=> ["thịt xông khói", "khúc bạch", "măng tây"]

đảo ngược
Hàm này đảo ngược một mảng.

jq ´đảo ngược´
[1,2,3,4]
=> [4,3,2,1]

chứa (phần tử)
Bộ lọc chứa (b) sẽ tạo ra true nếu b hoàn toàn được chứa trong đầu vào. MỘT
chuỗi B được chứa trong một chuỗi A nếu B là một chuỗi con của A. Một mảng B được chứa trong
một mảng A nếu tất cả các phần tử trong B được chứa trong bất kỳ phần tử nào trong A. Một đối tượng B là
được chứa trong đối tượng A nếu tất cả các giá trị trong B được chứa trong giá trị trong A với
cùng một khóa. Tất cả các loại khác được giả định là chứa trong nhau nếu chúng bằng nhau.

jq ´contains ("thanh") ´
"foobar"
=> đúng

jq ´contains (["baz", "thanh"]) ´
["foobar", "foobaz", "blarp"]
=> đúng

jq ´contains (["bazzzzz", "thanh"]) ´
["foobar", "foobaz", "blarp"]
=> sai

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

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

(các) chỉ số
Xuất ra một mảng chứa các chỉ số trong . Ở đâu s xảy ra. Đầu vào có thể là một mảng, trong
trường hợp nào nếu s là một mảng thì đầu ra các chỉ số sẽ là các chỉ số mà tất cả các phần tử trong .
phù hợp với s.

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

jq `chỉ số(1) ´
[0,1,2,1,3,1,4]
=> [1,3,5]

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

(các) chỉ mục, rindex
Xuất ra chỉ mục của đầu tiên (chỉ số) hoặc cuối cùng (chỉ mục) sự xuất hiện của s trong đầu vào.

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

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

trong
Bộ lọc bên trong (b) sẽ tạo ra true nếu đầu vào hoàn toàn được chứa bên trong b. Nó
về cơ bản, là một phiên bản đảo ngược của chứa.

jq ´inside ("foobar") ´
"quán ba"
=> đúng

jq ´inside (["foobar", "foobaz", "blarp"]) ´
["baz", "thanh"]
=> đúng

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

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

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

startwith (str)
Kết quả đầu ra đúng nếu như . bắt đầu với đối số chuỗi đã cho.

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

endwith (str)
Kết quả đầu ra đúng nếu như . kết thúc bằng đối số chuỗi đã cho.

jq ´ [. [] | endwith ("foo")] ´
["foobar", "barfoo"]
=> [sai, đúng]

kết hợp, kết hợp (n)
Kết xuất tất cả các kết hợp của các phần tử của mảng trong mảng đầu vào. Nếu đưa ra một
đối số n, nó xuất ra tất cả các kết hợp của n số lần lặp lại của mảng đầu vào.

jq ´ kết hợp '
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]

jq `kết hợp(2) ´
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]

ltrimstr (str)
Kết xuất đầu vào của nó với chuỗi tiền tố đã cho đã bị loại bỏ, nếu nó bắt đầu với nó.

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

rtrimstr (str)
Kết xuất đầu vào của nó với chuỗi hậu tố đã cho đã bị loại bỏ, nếu nó kết thúc bằng nó.

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

phát nổ
Chuyển đổi một chuỗi đầu vào thành một mảng các số điểm mã của chuỗi.

jq ´bùng nổ´
"foobar"
=> [102,111,111,98,97,114]

nổ tung
Nghịch đảo của sự bùng nổ.

jq ´nổ tung´
[65, 66, 67]
=> "ABC"

chia
Tách một chuỗi đầu vào trên đối số dấu phân tách.

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

tham gia (str)
Nối mảng các phần tử đã cho dưới dạng đầu vào, sử dụng đối số làm dấu phân tách. Nó là
nghịch đảo của chia: tức là đang chạy tách ("foo") | tham gia ("foo") qua bất kỳ chuỗi đầu vào nào
trả về chuỗi đầu vào đã nói.

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

ascii_downcase, ascii_upcase
Gửi bản sao của chuỗi đầu vào với các ký tự chữ cái của nó (az và AZ) được chuyển đổi thành
trường hợp được chỉ định.

trong khi (cond; cập nhật)
Sản phẩm trong khi (cond; cập nhật) chức năng cho phép bạn liên tục áp dụng một bản cập nhật cho . cho đến khi chung cư
là sai.

Lưu ý rằng trong khi (cond; cập nhật) được định nghĩa bên trong như một hàm jq đệ quy. Đệ quy
cuộc gọi trong trong khi sẽ không tiêu tốn thêm bộ nhớ nếu cập nhật sản xuất nhiều nhất một
đầu ra cho mỗi đầu vào. Xem các chủ đề nâng cao bên dưới.

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

cho đến khi (cond; Kế tiếp)
Sản phẩm cho đến khi (cond; Kế tiếp) hàm cho phép bạn áp dụng nhiều lần biểu thức tiếp theo,
ban đầu để . sau đó đến đầu ra của chính nó, cho đến khi chung cư là đúng. Ví dụ, điều này có thể được sử dụng
để triển khai một hàm giai thừa (xem bên dưới).

Lưu ý rằng cho đến khi (cond; Kế tiếp) được định nghĩa bên trong như một hàm jq đệ quy. Đệ quy
cuộc gọi trong cho đến khi() sẽ không tiêu tốn thêm bộ nhớ nếu tiếp theo sản xuất nhiều nhất một
đầu ra cho mỗi đầu vào. Xem các chủ đề nâng cao bên dưới.

jq ´ [., 1] | cho đến khi (. [0] <1; [. [0] - 1,. [1] *. [0]]) |. [1] ´
4
=> 24

đệ quy (f), đệ quy, đệ quy (f; tình trạng), recurse_down
Sản phẩm đệ quy (f) hàm cho phép bạn tìm kiếm thông qua cấu trúc đệ quy và trích xuất
dữ liệu thú vị từ tất cả các cấp. Giả sử đầu vào của bạn đại diện cho một hệ thống tệp:

{"tên": "/", "trẻ em": [
{"Tên": "/ thùng rác", "bọn trẻ": [
{"Tên": "/ bin / ls", "bọn trẻ": []},
{"Tên": "/ Bin / sh", "bọn trẻ": []}]},
{"Tên": "/ Home", "bọn trẻ": [
{"name": "/ home / stephen", "children": [
{"name": "/ home / stephen / jq", "children": []}]}]}]}

Bây giờ, giả sử bạn muốn giải nén tất cả các tên tệp hiện có. Bạn cần lấy . Tên,
.children []. name, .children []. children []. name, và như thế. Bạn có thể làm điều này với:

recurse (.children []) | .Tên

Khi được gọi mà không có đối số, tái diễn tương đương với đệ quy (. []?).

đệ quy (f) giống hệt với đệ quy (f; . != vô giá trị) và có thể được sử dụng mà không cần lo lắng về
độ sâu đệ quy.

đệ quy (f; tình trạng) là một máy phát điện bắt đầu bằng cách phát ra. và sau đó phát ra lần lượt
. | f,. | f | f,. | f | f | f, ... miễn là giá trị tính toán thỏa mãn điều kiện. Vì
ví dụ, để tạo ra tất cả các số nguyên, ít nhất về nguyên tắc, người ta có thể viết đệ quy (. + 1;
thật).

Vì lý do kế thừa, recurse_down tồn tại như một bí danh để gọi tái diễn mà không cần đối số.
Bí danh này được coi là phản đối và sẽ bị loại bỏ trong bản phát hành chính tiếp theo.

Các cuộc gọi đệ quy trong tái diễn sẽ không sử dụng bộ nhớ bổ sung bất cứ khi nào f sản xuất tại
hầu hết một đầu ra duy nhất cho mỗi đầu vào.

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

jq 'tái diễn'
{"a": 0, "b": [1]}
=> {"a": 0, "b": [1]}, 0, [1], 1

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

..
Tay ngắn cho tái diễn mà không cần đối số. Điều này nhằm mục đích giống XPath //
nhà điều hành. Lưu ý rằng ..Một không hoạt động; sử dụng .. | a thay thế. Trong ví dụ dưới đây, chúng tôi sử dụng
.. | .a? để tìm tất cả các giá trị của khóa đối tượng "a" trong bất kỳ đối tượng nào được tìm thấy "bên dưới" ..

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

env
Xuất ra một đối tượng đại diện cho môi trường của jq.

jq `env.PAGER'
vô giá trị
=> "ít hơn"

hoán vị
Hoán vị một ma trận có thể có răng cưa (một mảng các mảng). Các hàng được đệm bằng các giá trị rỗng để
kết quả luôn là hình chữ nhật.

jq ´chuyển vị trí
[[1], [2,3]]
=> [[1,2], [null, 3]]

bsearch (x)
bsearch (x) thực hiện tìm kiếm nhị phân cho x trong mảng đầu vào. Nếu đầu vào được sắp xếp và
chứa x, thì bsearch (x) sẽ trả về chỉ số của nó trong mảng; ngược lại, nếu mảng là
đã sắp xếp, nó sẽ trả về (-1 - ix) trong đó ix là điểm chèn sao cho mảng sẽ
vẫn được sắp xếp sau khi chèn x tại ix. Nếu mảng không được sắp xếp, hãy tìm kiếm (x)
sẽ trả về một số nguyên có thể không được quan tâm.

jq `tìm kiếm(0) ´
[0,1]
=> 0

jq `tìm kiếm(0) ´
[1,2,3]
=> -1

jq `tìm kiếm(4) dưới dạng $ ix | nếu $ ix <0 thì. [- (1 + $ ix)] = 4 khác. kết thúc
[1,2,3]
=> [1,2,3,4]

Chuỗi phép nội suy - \ (foo)
Bên trong một chuỗi, bạn có thể đặt một biểu thức bên trong parens sau dấu gạch chéo ngược. Bất cứ điều gì
trả về biểu thức sẽ được nội suy vào chuỗi.

jq ´ "Đầu vào là \ (.), nhỏ hơn \ (. + 1)" ´
42
=> "Đầu vào là 42, nhỏ hơn 43"

Chuyển đổi đến từ JSON
Sản phẩm tojson và từjson nội trang kết xuất giá trị dưới dạng văn bản JSON hoặc phân tích cú pháp văn bản JSON thành
các giá trị tương ứng. Nội trang tojson khác với chuỗi ở chỗ chuỗi trả về
chuỗi không được sửa đổi, trong khi tojson mã hóa chuỗi dưới dạng chuỗi JSON.

jq ´ [. [] | chuỗi] ´
[1, "foo", ["foo"]]
=> ["1", "foo", "[\" foo \ "]"]

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

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

Định dạng dây và thoát
Sản phẩm @foo cú pháp được sử dụng để định dạng và thoát chuỗi, hữu ích cho việc xây dựng URL,
tài liệu bằng ngôn ngữ như HTML hoặc XML, v.v. @foo có thể được sử dụng như một bộ lọc trên
riêng của nó, các lối thoát có thể xảy ra là:

@chữ:

Cuộc gọi xâu chuỗi, hãy xem chức năng đó để biết chi tiết.

@json:

Tuần tự hóa đầu vào dưới dạng JSON.

@html:

Áp dụng tính năng thoát HTML / XML, bằng cách ánh xạ các ký tự <> & ´ " đến thực thể của họ
tương đương <, >, &, ', ".

@uri:

Áp dụng mã hóa phần trăm, bằng cách ánh xạ tất cả các ký tự URI dành riêng cho một % XX sự nối tiếp.

@csv:

Đầu vào phải là một mảng và nó được hiển thị dưới dạng CSV với dấu ngoặc kép cho
chuỗi và dấu ngoặc kép được thoát ra bằng cách lặp lại.

@tsv:

Đầu vào phải là một mảng và nó được hiển thị dưới dạng TSV (các giá trị được phân tách bằng tab). Mỗi
mảng đầu vào sẽ được in dưới dạng một dòng. Các trường được phân tách bằng một tab
(ascii 0x09). Nhập ký tự dòng cấp dữ liệu (ascii 0x0a), ký tự xuống dòng (ascii
0x0d), tab (ascii 0x09) và dấu gạch chéo ngược (ascii 0x5c) sẽ được xuất ra dưới dạng thoát
trình tự \n, \r, \t, \\ tương ứng.

@NS:

Đầu vào được thoát ra phù hợp để sử dụng trong dòng lệnh cho trình bao POSIX. Nếu
đầu vào là một mảng, đầu ra sẽ là một chuỗi các chuỗi được phân tách bằng dấu cách.

@ base64:

Đầu vào được chuyển đổi thành base64 như được chỉ định bởi RFC 4648.

Cú pháp này có thể được kết hợp với phép nội suy chuỗi một cách hữu ích. Bạn có thể theo dõi một
@foo mã thông báo với một chuỗi ký tự. Nội dung của chuỗi theo nghĩa đen sẽ không được trốn thoát.
Tuy nhiên, tất cả các phép nội suy được thực hiện bên trong chuỗi ký tự đó sẽ bị thoát. Ví dụ,

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

sẽ tạo ra đầu ra sau cho đầu vào {"search": "cái gì is jq? "}:

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

Lưu ý rằng dấu gạch chéo, dấu chấm hỏi, v.v. trong URL không được thoát vì chúng là một phần
của chuỗi ký tự.

jq ´ @ html´
"Điều này hoạt động nếu x <y"
=> "Điều này hoạt động nếu x <y"

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

Ngày
jq cung cấp một số chức năng xử lý ngày cơ bản, với một số cấp cao và cấp thấp
nội trang. Trong mọi trường hợp, những nội dung này chỉ xử lý theo thời gian tính theo giờ UTC.

Sản phẩm từdateiso8601 nội trang phân tích cú pháp ngày tháng ở định dạng ISO 8601 thành một số giây
kể từ kỷ nguyên Unix (1970-01-01T00: 00: 00Z). Các hôm nayiso8601 nội trang làm ngược lại.

Sản phẩm từ ngày nội trang phân tích chuỗi ngày giờ. Hiện tại từ ngày chỉ hỗ trợ ISO 8601
chuỗi ngày giờ, nhưng trong tương lai, nó sẽ cố gắng phân tích cú pháp chuỗi ngày giờ thành nhiều hơn
định dạng.

Sản phẩm cập nhật nội trang là một bí danh cho hôm nayiso8601.

Sản phẩm tại nội trang xuất ra thời gian hiện tại, tính bằng giây kể từ kỷ nguyên Unix.

Các giao diện jq cấp thấp cho các hàm thời gian của thư viện C cũng được cung cấp: thời gian,
thời gian căng thẳng, mktimevà gmtime. Tham khảo tài liệu về hệ điều hành máy chủ của bạn để biết
chuỗi định dạng được sử dụng bởi thời gian và thời gian căng thẳng. Lưu ý: những điều này không nhất thiết phải ổn định
giao diện trong jq, đặc biệt là về chức năng bản địa hóa của chúng.

Sản phẩm gmtime nội trang sử dụng một số giây kể từ kỷ nguyên Unix và xuất ra thông báo "bị hỏng
down time "đại diện cho thời gian dưới dạng một mảng số đại diện (theo thứ tự này):
năm, tháng (dựa trên số XNUMX), ngày trong tháng, giờ trong ngày, phút
giờ, giây của phút, ngày trong tuần và ngày trong năm - tất cả
một dựa trên trừ khi có quy định khác.

Sản phẩm mktime nội trang sử dụng các đại diện "thời gian chia nhỏ" của đầu ra thời gian bằng gmtime
và thời gian.

Sản phẩm strptime (fmt) nội trang phân tích cú pháp các chuỗi đầu vào khớp với fmt tranh luận. Đầu ra ở
đại diện "thời gian chia nhỏ" được sử dụng bởi gmtime và xuất ra bởi mktime.

Sản phẩm strftime (fmt) nội trang định dạng một thời gian với định dạng nhất định.

Các chuỗi định dạng cho thời gian và thời gian căng thẳng được mô tả trong thư viện C điển hình
tài liệu. Chuỗi định dạng cho ngày giờ ISO 8601 là "% Y-% m-% dT% H:% M:% SZ".

jq có thể không hỗ trợ một số hoặc tất cả chức năng ngày này trên một số hệ thống.

jq ´từ ngày'
"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

ĐIỀU KIỆN VÀ SO SÁNH

==, !=
Biểu thức ´a == b´ sẽ tạo ra ´true´ nếu kết quả của a và b bằng nhau (nghĩa là
nếu chúng đại diện cho các tài liệu JSON tương đương) và ´false´ nếu không. Đặc biệt, chuỗi
không bao giờ được coi là bằng số. Nếu bạn đến từ Javascript, jq´s == giống như
Javascript's === - chỉ xem xét các giá trị bằng nhau khi chúng có cùng loại cũng như
cùng giá trị.

! = là "không bằng" và ´a! = b´ trả về giá trị ngược lại của ´a == b´

jq ´. [] == 1´
[1, 1.0, "1", "chuối"]
=> true, true, false, false

nếu-thì-khác
if A sau đó B khác C cuối sẽ hoạt động giống như B if A tạo ra một giá trị khác với false hoặc
null, nhưng hoạt động giống như C nếu không thì.

Kiểm tra false hoặc null là một khái niệm đơn giản hơn về "tính xác thực" so với được tìm thấy trong Javascript
hoặc Python, nhưng điều đó có nghĩa là đôi khi bạn sẽ phải trình bày rõ ràng hơn về điều kiện
bạn muốn: bạn không thể kiểm tra xem liệu một chuỗi có trống hay không bằng cách sử dụng if . Tên sau đó A khác B cuối,
bạn sẽ cần một cái gì đó giống hơn if (.Tên | chiều dài) > 0 sau đó A khác B cuối thay thế.

Nếu điều kiện A tạo ra nhiều kết quả, nó được coi là "đúng" nếu bất kỳ kết quả nào
kết quả không sai hoặc không. Nếu nó tạo ra kết quả bằng không, nó được coi là sai.

Nhiều trường hợp hơn có thể được thêm vào nếu sử dụng elif A sau đó B cú pháp.

jq ´if. == 0 sau đó

"số không" elif. == 1 rồi đến "một" khác "nhiều" end´ 2 => "nhiều"

>, > =, <=, <
Các toán tử so sánh >, >=, <=, < trả về cho dù đối số bên trái của họ lớn hơn,
lớn hơn hoặc bằng, nhỏ hơn hoặc bằng hoặc nhỏ hơn đối số đúng của chúng
(tương ứng).

Thứ tự giống như được mô tả cho loại, ở trên.

jq ´. <5´
2
=> đúng

và / hoặc / không
jq hỗ trợ các toán tử Boolean bình thường và / hoặc / không. Họ có cùng tiêu chuẩn về sự thật
như thể các biểu thức - false và null được coi là "giá trị sai" và bất kỳ thứ gì khác là
"giá trị đích thực".

Nếu một toán hạng của một trong những toán tử này tạo ra nhiều kết quả, thì chính toán tử đó
sẽ tạo ra một kết quả cho mỗi đầu vào.

không thực tế là một hàm nội trang chứ không phải là một toán tử, vì vậy nó được gọi là một bộ lọc để
những thứ có thể được tạo đường dẫn thay vì theo cú pháp đặc biệt, như trong .foo và .Cafe | không.

Ba giá trị này chỉ tạo ra các giá trị "true" và "false" và do đó, chỉ hữu ích cho chính hãng
Các phép toán Boolean, thay vì thành ngữ Perl / Python / Ruby phổ biến của
"value_that_may_be_null hoặc default". Nếu bạn muốn sử dụng dạng "hoặc" này, hãy chọn giữa
hai giá trị thay vì đánh giá một điều kiện, hãy xem toán tử "//" bên dưới.

jq ´42 và "một chuỗi" ´
vô giá trị
=> đúng

jq ´ (true, false) hoặc false´
vô giá trị
=> true, false

jq ´ (đúng, đúng) và (đúng, sai) ´
vô giá trị
=> true, false, true, false

jq ´ [đúng, sai | không phải
vô giá trị
=> [sai, đúng]

Thay thế nhà điều hành - //
Một bộ lọc của biểu mẫu a // b tạo ra kết quả tương tự như a, Nếu a tạo ra kết quả khác
hơn sai và vô giá trị. Nếu không thì, a // b tạo ra kết quả tương tự như b.

Điều này hữu ích để cung cấp các giá trị mặc định: .foo // 1 sẽ đánh giá 1 nếu không có .foo
phần tử trong đầu vào. Nó tương tự như cách or đôi khi được sử dụng trong Python (jq´s or nhà điều hành
được dành riêng cho các phép toán Boolean nghiêm ngặt).

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

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

cố gắng bắt
Các lỗi có thể được phát hiện bằng cách sử dụng thử EXP bắt EXP. Biểu thức đầu tiên được thực thi và nếu
nó không thành công sau đó thứ hai được thực hiện với thông báo lỗi. Đầu ra của trình xử lý, nếu
bất kỳ, là đầu ra như thể nó là đầu ra của biểu thức để thử.

Sản phẩm thử EXP sử dụng biểu mẫu trống với tư cách là trình xử lý ngoại lệ.

jq ´try .a catch ". không phải là một đối tượng" ´
đúng
=> ". không phải là đối tượng"

jq ´ [. [] | thử .a] ´
[{}, true, {"a": 1}]
=> [null, 1]

jq ´try error ("một số ngoại lệ") bắt .´
đúng
=> "một số ngoại lệ"

Phá vỡ ra of điều khiển cấu trúc
Một cách sử dụng tiện lợi của try / catch là thoát ra khỏi các cấu trúc kiểm soát như giảm, cho mỗi,
trong khi, Và như vậy.

Ví dụ:

# Lặp lại một biểu thức cho đến khi nó tăng "break" thành một
# error, sau đó ngừng lặp lại mà không đặt lại lỗi.
# Nhưng nếu lỗi bắt được không phải là "break" thì hãy nâng lại nó.
thử lặp lại (exp) bắt. == "break" rồi làm trống lỗi khác;

jq có cú pháp cho các nhãn từ vựng được đặt tên là "break" hoặc "go (back) to":

nhãn $ out | ... thoát ra khỏi $ ...

Sản phẩm phá vỡ $ label_name biểu thức sẽ khiến chương trình hoạt động như thể gần nhất
(Qua bên trái) nhãn $ label_name sản xuất trống.

Mối quan hệ giữa phá vỡ và tương ứng nhãn là từ vựng: nhãn phải là
"có thể nhìn thấy" từ giờ nghỉ.

Để thoát ra khỏi một giảm, ví dụ:

nhãn $ out | giảm. [] dưới dạng $ item (null; nếu. == false thì ngắt $ ra else ... end)

Chương trình jq sau tạo ra lỗi cú pháp:

thoát ra khỏi $

bởi vì không có nhãn $ ra có thể nhìn thấy.

? nhà điều hành
Sản phẩm ? toán tử, được sử dụng như kinh nghiệm?, là viết tắt của thử EXP.

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

ĐỀU ĐẶN BIỂU THỨC (PCRE)

jq sử dụng thư viện biểu thức chính quy Oniguruma, cũng như php, ruby, TextMate, Sublime Text,
vv, vì vậy mô tả ở đây sẽ tập trung vào các chi tiết cụ thể của jq.

Các bộ lọc jq regex được xác định để chúng có thể được sử dụng bằng một trong các mẫu sau:

STRING | BỘ LỌC (REGEX)
STRING | BỘ LỌC (REGEX; CỜ)
STRING | BỘ LỌC ([REGEX])
STRING | BỘ LỌC ([REGEX, FLAGS])

trong đó: * STRING, REGEX và FLAGS là các chuỗi jq và tuân theo phép nội suy chuỗi jq; *
REGEX, sau khi nội suy chuỗi, phải là một PCRE regex hợp lệ; * FILTER là một trong những thử nghiệm,
phù hợp với, hoặc là nắm bắt, như mô tả dưới đây.

CỜ là một chuỗi bao gồm một trong các cờ được hỗ trợ:

· g - Tìm kiếm toàn cầu (tìm tất cả các kết quả phù hợp, không chỉ tìm kiếm đầu tiên)

· i - Tìm kiếm không phân biệt chữ hoa chữ thường

· m - Chế độ nhiều dòng (´.´ sẽ phù hợp với dòng mới)

· n - Bỏ qua các kết quả trống

· p - Cả hai chế độ s và m đều được bật

· s - Chế độ dòng đơn (´ ^ ´ -> ´ \ A´, ´ $ ´ -> ´ \ Z´)

· l - Tìm các trận đấu dài nhất có thể

· x - Định dạng regex mở rộng (bỏ qua khoảng trắng và nhận xét)

Để khớp khoảng trắng trong một mẫu x, hãy sử dụng một lối thoát, chẳng hạn như \ s, ví dụ:

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

Lưu ý rằng một số cờ nhất định cũng có thể được chỉ định trong REGEX, ví dụ:

· Jq -n ´ ("test", "TEst", "teST", "TEST") | test ("(? i) te (? - i) st") ´

đánh giá thành: true, true, false, false.

[Đòi hỏi 1.5] kiểm tra (val), kiểm tra (regex; cờ)
Như phù hợp với, nhưng không trả về các đối tượng khớp, chỉ đúng or sai cho dù có hay không
regex khớp với đầu vào.

jq ´test ("foo") ´
"foo"
=> đúng

jq ´. [] | test ("abc # dấu cách bị bỏ qua"; "ix") ´
["xabcd", "ABC"]
=> đúng, đúng

[Đòi hỏi 1.5] phù hợp (val), trận đấu (regex; cờ)
phù hợp với xuất một đối tượng cho mỗi trận đấu mà nó tìm thấy. Kết quả phù hợp có các trường sau:

· bù đắp - bù đắp trong mã điểm UTF-8 từ đầu đầu vào

· chiều dài - độ dài tính bằng mã UTF-8 của trận đấu

· chuỗi - chuỗi mà nó khớp

· chụp - một mảng các đối tượng đại diện cho các nhóm bắt.

Chụp các đối tượng trong nhóm có các trường sau:

· bù đắp - bù đắp trong mã điểm UTF-8 từ đầu đầu vào

· chiều dài - độ dài tính bằng mã UTF-8 của nhóm chụp này

· chuỗi - chuỗi đã được bắt

· tên - tên của nhóm bắt (hoặc vô giá trị nếu nó không được đặt tên)

Chụp các nhóm không khớp với bất kỳ thứ gì trả về giá trị chênh lệch -1

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

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

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

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

jq ´ [match ("."; "g")] | chiều dài
"abc"
=> 3

[Đòi hỏi 1.5] nắm bắt (val), chụp (regex; cờ)
Thu thập các ảnh chụp được đặt tên trong một đối tượng JSON, với tên của mỗi ảnh chụp làm khóa,
và chuỗi đã so khớp làm giá trị tương ứng.

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

[Đòi hỏi 1.5] quét (regex), quét (regex; cờ)
Phát ra một luồng các chuỗi con không chồng chéo của đầu vào khớp với regex trong
phù hợp với các cờ, nếu có đã được chỉ định. Nếu không có kết quả phù hợp, luồng sẽ
trống. Để nắm bắt tất cả các kết quả phù hợp cho từng chuỗi đầu vào, hãy sử dụng thành ngữ [ thể hiện ], ví dụ [
quét (regex) ].

tách (regex; cờ)
Để tương thích ngược, chia phân chia trên một chuỗi, không phải là một regex.

[Đòi hỏi 1.5] phân chia (regex), sự phân chia (regex; cờ)
Chúng cung cấp kết quả tương tự như chia đối tác, nhưng dưới dạng một luồng thay vì một
mảng.

[Đòi hỏi 1.5] phụ (regex; dây) phụ (regex; dây; cờ)
Phát ra chuỗi có được bằng cách thay thế khớp đầu tiên của regex trong chuỗi đầu vào bằng
xâu chuỗi, sau khi nội suy. xâu chuỗi phải là một chuỗi jq và có thể chứa các tham chiếu
đến các ảnh chụp được đặt tên. Trên thực tế, các ảnh chụp được đặt tên được trình bày dưới dạng một đối tượng JSON (như
xây dựng bởi nắm bắt) Để xâu chuỗi, do đó, một tham chiếu đến một biến được chụp có tên "x" sẽ
có dạng: "(.x)".

[Đòi hỏi 1.5] gsub (regex; dây), gsub (regex; dây; cờ)
gsub giống như phụ nhưng tất cả các lần xuất hiện không chồng chéo của regex được thay thế bằng
chuỗi, sau khi nội suy.

ADVANCED TÍNH NĂNG, ĐẶC ĐIỂM

Các biến là điều cần thiết tuyệt đối trong hầu hết các ngôn ngữ lập trình, nhưng chúng không được xếp hạng
sang "tính năng nâng cao" trong jq.

Trong hầu hết các ngôn ngữ, biến là phương tiện duy nhất để truyền dữ liệu. Nếu bạn tính toán một
và bạn muốn sử dụng nó nhiều lần, bạn sẽ cần phải lưu trữ nó trong một biến. Đến
chuyển một giá trị cho một phần khác của chương trình, bạn sẽ cần phần đó của chương trình để
xác định một biến (dưới dạng tham số hàm, thành viên đối tượng hoặc bất cứ thứ gì) để đặt
dữ liệu.

Cũng có thể xác định các hàm trong jq, mặc dù đây là một tính năng lớn nhất của nó
sử dụng là xác định thư viện tiêu chuẩn của jq (nhiều hàm jq chẳng hạn như bản đồ và tìm trong thực tế
viết bằng jq).

jq có các toán tử giảm, rất mạnh nhưng hơi phức tạp. Một lần nữa, đây là
chủ yếu được sử dụng trong nội bộ, để xác định một số bit hữu ích của thư viện tiêu chuẩn của jq.

Thoạt đầu có thể không rõ ràng, nhưng jq là tất cả về máy phát điện (vâng, như thường thấy trong
những ngôn ngữ khác). Một số tiện ích được cung cấp để giúp đối phó với máy phát điện.

Một số hỗ trợ I / O tối thiểu (ngoài việc đọc JSON từ đầu vào tiêu chuẩn và ghi JSON vào
đầu ra tiêu chuẩn) có sẵn.

Cuối cùng, có một hệ thống mô-đun / thư viện.

Biến
Trong jq, tất cả các bộ lọc đều có đầu vào và đầu ra, do đó, hệ thống ống nước thủ công là không cần thiết
chuyển một giá trị từ một phần của chương trình sang phần tiếp theo. Nhiều biểu thức, chẳng hạn a + b,
chuyển đầu vào của họ cho hai biểu thức con riêng biệt (tại đây a và b cả hai đều được thông qua như nhau
đầu vào), vì vậy các biến thường không cần thiết để sử dụng một giá trị hai lần.

Ví dụ: tính giá trị trung bình của một mảng số yêu cầu một vài
trong hầu hết các ngôn ngữ - ít nhất một để giữ mảng, có lẽ một cho mỗi phần tử
hoặc cho một bộ đếm vòng lặp. Trong jq, nó chỉ đơn giản là thêm vào / chiều dài - các thêm vào biểu thức được đưa ra
mảng và tạo ra tổng của nó, và chiều dài biểu thức được cung cấp cho mảng và tạo ra
chiều dài.

Vì vậy, thường có một cách rõ ràng hơn để giải quyết hầu hết các vấn đề trong jq hơn là xác định các biến.
Tuy nhiên, đôi khi chúng làm cho mọi thứ dễ dàng hơn, vì vậy jq cho phép bạn xác định các biến bằng cách sử dụng
biểu hiện as $ biến. Tất cả các tên biến đều bắt đầu bằng $. Đây là một phiên bản xấu hơn một chút
của ví dụ về tính trung bình của mảng:

chiều dài như $ array_length | thêm / $ array_length

Chúng ta sẽ cần một vấn đề phức tạp hơn để tìm ra một tình huống mà việc sử dụng các biến thực sự
làm cho cuộc sống của chúng tôi dễ dàng hơn.

Giả sử chúng ta có một loạt các bài đăng trên blog, với các trường "tác giả" và "tiêu đề", và một
đối tượng được sử dụng để ánh xạ tên người dùng của tác giả với tên thật. Đầu vào của chúng tôi trông giống như:

{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "Một bài viết hay", "author": "person1"}],
"realnames": {"anon": "Kẻ hèn nhát ẩn danh",
"person1": "Person McPherson"}}

Chúng tôi muốn tạo các bài đăng với trường tác giả có tên thật, như trong:

{"title": "Frist psot", "author": "Anonymous Coward"}
{"title": "Một bài báo viết hay", "author": "Person McPherson"}

Chúng tôi sử dụng một biến, $ names, để lưu trữ đối tượng realnames, để chúng tôi có thể tham khảo nó sau này
khi tra cứu tên người dùng của tác giả:

.realnames as $ names | .posts [] | {title, author: $ names [.author]}

Cách diễn đạt exp as $x | hữu ích. Cảm ơn ! nghĩa là: với mỗi giá trị của biểu thức exp, chạy phần còn lại của
đường dẫn với toàn bộ dữ liệu đầu vào ban đầu và với $x đặt thành giá trị đó. Như vậy as
hoạt động như một cái gì đó của một vòng lặp foreach.

Cũng như {foo} là một cách viết tiện dụng {foo: .foo}, Vì vậy {$ foo} là một cách viết tiện dụng
{foo: $ foo}.

Nhiều biến có thể được khai báo bằng cách sử dụng một as biểu hiện bằng cách cung cấp một mẫu
khớp với cấu trúc của đầu vào (điều này được gọi là "cấu trúc hủy"):

. dưới dạng {realnames: $ names, bài viết: [$ first, $ second]} | ...

Khai báo biến trong các mẫu mảng (ví dụ: . as [$ đầu tiên, $ giây]) ràng buộc với
các phần tử của mảng trong từ phần tử có chỉ số XNUMX trở lên, theo thứ tự. Khi không có
giá trị tại chỉ mục cho một phần tử mẫu mảng, vô giá trị bị ràng buộc với biến đó.

Các biến được xác định phạm vi trên phần còn lại của biểu thức xác định chúng, vì vậy

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

sẽ hoạt động, nhưng

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

đã thắng.

Đối với các nhà lý thuyết ngôn ngữ lập trình, sẽ chính xác hơn khi nói rằng các biến jq là
ràng buộc phạm vi từ vựng. Đặc biệt, không có cách nào để thay đổi giá trị của một ràng buộc;
người ta chỉ có thể thiết lập một liên kết mới có cùng tên, nhưng sẽ không hiển thị ở đâu
cái cũ là.

jq ´.bar dưới dạng $ x | .foo | . + $ x´
{"foo": 10, "bar": 200}
=> 210

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

jq ´. dưới dạng [$ 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}

Xác định Chức năng
Bạn có thể đặt tên cho bộ lọc bằng cú pháp "def":

gia số def:. + 1;

Từ đó trở đi, tăng có thể được sử dụng như một bộ lọc giống như một hàm nội trang (trên thực tế, điều này
là cách một số nội trang được xác định). Một hàm có thể nhận các đối số:

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

Các đối số được chuyển dưới dạng bộ lọc, không phải dưới dạng giá trị. Đối số tương tự có thể được tham chiếu
nhiều lần với các đầu vào khác nhau (tại đây f được chạy cho mỗi phần tử của mảng đầu vào).
Các đối số cho một hàm hoạt động giống như lệnh gọi lại hơn là đối số giá trị. Đây là
quan trọng để hiểu. Coi như:

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

Kết quả sẽ là 20 vì f is . * 2và trong lần gọi đầu tiên f . sẽ là 5,
và lần thứ hai nó sẽ là 10 (5 * 2), vì vậy kết quả sẽ là 20. Các đối số của hàm
là các bộ lọc và bộ lọc mong đợi một đầu vào khi được gọi.

Nếu bạn muốn hành vi đối số giá trị để xác định các hàm đơn giản, bạn chỉ có thể sử dụng
biến:

def addvalue (f): f as $ f | bản đồ (. + $ f);

Hoặc sử dụng tay ngắn:

def addvalue ($ f): ...;

Với một trong hai định nghĩa, addvalue (.foo) sẽ thêm đầu vào hiện tại .foo lĩnh vực cho mỗi
phần tử của mảng.

Cho phép nhiều định nghĩa sử dụng cùng một tên hàm. Mỗi định nghĩa lại thay thế
cái trước đó cho cùng một số đối số hàm, nhưng chỉ cho các tham chiếu từ
các hàm (hoặc chương trình chính) sau định nghĩa lại.

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

jq ´def addvalue (f): f as $ x | bản đồ (. + $ x); giá trị cộng (. [0]) ´
[[1,2], [10,20]]
=> [[1,2,1,2], [10,20,1,2]]

Giảm
Sản phẩm giảm cú pháp trong jq cho phép bạn kết hợp tất cả các kết quả của một biểu thức bằng
tích lũy chúng thành một câu trả lời duy nhất. Ví dụ, chúng tôi sẽ vượt qua [3,2,1] đến đây
biểu hiện:

giảm. [] dưới dạng $ item (0;. + $ item)

Đối với mỗi kết quả mà . [] sản xuất, . + $ item được chạy để tích lũy tổng số đang chạy,
bắt đầu từ 0. Trong ví dụ này, . [] tạo ra các kết quả 3, 2 và 1, vì vậy hiệu quả là
tương tự như chạy một cái gì đó như thế này:

0 | (3 dưới dạng $ item |. + $ Item) |
(2 là $ item |. + $ Item) |
(1 dưới dạng $ item |. + $ Item)

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

giới hạn (n; NS)
Sản phẩm hạn chế chức năng trích xuất lên đến n kết quả đầu ra từ exp.

jq ´ [giới hạn (3;. [])] ´
[0,1,2,3,4,5,6,7,8,9]
=> [0,1,2]

đầu tiên (expr), cuối cùng (expr), nth (n; kinh nghiệm)
Sản phẩm đầu tiên (expr) và cuối cùng (expr) các hàm trích xuất các giá trị đầu tiên và cuối cùng từ thể hiện,
tương ứng.

Sản phẩm nth (n; kinh nghiệm) hàm trích xuất giá trị thứ n đầu ra bằng thể hiện. Điều này có thể được định nghĩa là
def nth (n; kinh nghiệm): cuối cùng (giới hạn (n + 1; expr));. Lưu ý rằng nth (n; kinh nghiệm) không hỗ trợ
giá trị âm của n.

jq ´ [đầu tiên (phạm vi (.)), cuối cùng (phạm vi (.)), thứ n (./ 2; phạm vi (.))] ´
10
=> [0,9,5]

Đầu tiên, Cuối cùng, nth (n)
Sản phẩm Thành phố điện khí hóa phía tây dãy núi Rocky đầu tiên và cuối cùng các hàm trích xuất các giá trị đầu tiên và cuối cùng từ bất kỳ mảng nào tại ..

Sản phẩm nth (n) hàm trích xuất giá trị thứ n của bất kỳ mảng nào tại ..

jq ´ [phạm vi (.)] | [đầu tiên, cuối cùng, thứ n(5
10
=> [0,9,5]

cho mỗi
Sản phẩm cho mỗi cú pháp tương tự như giảm, nhưng nhằm mục đích cho phép xây dựng hạn chế
và bộ khử tạo ra kết quả trung gian (xem ví dụ).

Hình thức là cho mỗi EXP as $ var (TRONG ĐÓ; CẬP NHẬT; TRÍCH XUẤT). Như giảm, INIT được đánh giá
một lần để tạo ra một giá trị trạng thái, sau đó mỗi đầu ra của EXP là ràng buộc để $ var, CẬP NHẬT is
được đánh giá cho mỗi đầu ra của EXP với trạng thái hiện tại và với $ var có thể nhìn thấy. Mỗi giá trị
đầu ra bởi CẬP NHẬT thay thế trạng thái trước đó. Cuối cùng, TRÍCH XUẤT được đánh giá cho mỗi mới
trạng thái để trích xuất một đầu ra của cho mỗi.

Điều này chủ yếu chỉ hữu ích cho việc xây dựng giảm- Và hạn chế-như các chức năng. Nhưng nó là
tổng quát hơn nhiều, vì nó cho phép giảm một phần (xem ví dụ bên dưới).

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

Đệ quy
Như đã mô tả ở trên, tái diễn sử dụng đệ quy và bất kỳ hàm jq nào cũng có thể đệ quy. Các
trong khi nội trang cũng được thực hiện trong điều kiện đệ quy.

Các lệnh gọi đuôi được tối ưu hóa bất cứ khi nào biểu thức ở bên trái của đầu ra lệnh gọi đệ quy
giá trị cuối cùng của nó. Trong thực tế, điều này có nghĩa là biểu thức bên trái của đệ quy
lệnh gọi không được tạo ra nhiều hơn một đầu ra cho mỗi đầu vào.

Ví dụ:

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

def while (cond; update):
def _ while:
if cond then., (update | _ while) else rỗng end;
_trong khi;

lặp lại def (exp):
chắc chắn _ lặp lại:
hết hạn, _ lặp lại;
_nói lại;

Máy phát điện và người lặp lại
Một số toán tử và hàm jq thực sự là bộ tạo trong đó chúng có thể tạo ra số không,
một hoặc nhiều giá trị cho mỗi đầu vào, giống như người ta có thể mong đợi trong lập trình khác
ngôn ngữ có trình tạo. Ví dụ, . [] tạo ra tất cả các giá trị trong đầu vào của nó
(phải là một mảng hoặc một đối tượng), phạm vi (0; 10) tạo ra các số nguyên từ 0 đến
10, v.v.

Ngay cả toán tử dấu phẩy cũng là một trình tạo, tạo ra các giá trị đầu tiên được tạo bởi
biểu thức ở bên trái dấu phẩy, sau đó đối với mỗi biểu thức đó, các giá trị được tạo bởi
biểu thức bên phải dấu phẩy.

Sản phẩm trống nội trang là trình tạo không tạo ra kết quả đầu ra. Các trống được xây dựng trong
dấu lùi vào biểu thức trình tạo trước đó.

Tất cả các hàm jq có thể là trình tạo chỉ bằng cách sử dụng trình tạo nội trang. Nó cũng có thể
để định nghĩa bộ tạo mới chỉ sử dụng đệ quy và toán tử dấu phẩy. Nếu đệ quy
gọi (các) là (are) "ở vị trí đuôi" thì bộ tạo sẽ hoạt động hiệu quả. Trong ví dụ
bên dưới cuộc gọi đệ quy bởi _phạm vi đối với chính nó là ở vị trí đuôi. Ví dụ khoe
ba chủ đề nâng cao: đệ quy đuôi, cấu tạo bộ tạo và các hàm con.

jq ´def range (init; upto; by): def _range: if (by> 0 and. <upto) or (by <0 and.> upto) then., ((. + by) | _range) else. chấm dứt; if by == 0 then init else init | _range end | select ((by> 0 and. <upto) or (by <0 and.> upto)); phạm vi (0; 10; 3) ´
vô giá trị
=> 0, 3, 6, 9

jq ´def while (cond; update): def _ready: if cond then., (update | _ while) else rỗng end; _trong khi; [trong khi (. <100;. * 2)] ´
1
=> [1,2,4,8,16,32,64]

MÔN TOÁN

jq hiện chỉ có hỗ trợ số dấu phẩy động chính xác kép (754-bit) IEEE64.

Bên cạnh các toán tử số học đơn giản như +, jq cũng có hầu hết các hàm toán học tiêu chuẩn
từ thư viện toán học C. Các hàm toán học C nhận một đối số đầu vào (ví dụ: tội())
có sẵn dưới dạng các hàm jq không đối số. Các hàm toán học C nhận hai đầu vào
đối số (ví dụ: pow ()) có sẵn dưới dạng các hàm jq hai đối số bỏ qua ..

Tính khả dụng của các hàm toán học tiêu chuẩn phụ thuộc vào tính khả dụng của
các hàm toán học trong hệ điều hành và thư viện toán học C của bạn. Các hàm toán học không khả dụng
sẽ được xác định nhưng sẽ phát sinh lỗi.

I / O

Tại thời điểm này, jq có hỗ trợ tối thiểu cho I / O, chủ yếu ở dạng kiểm soát khi
đầu vào được đọc. Hai hàm nội trang được cung cấp cho việc này, đầu vào và đầu vào, đã đọc
từ các nguồn giống nhau (ví dụ: tiêu chuẩn, các tệp có tên trên dòng lệnh) như chính jq. Này
hai nội trang, và các hành động đọc riêng của jq, có thể được xen kẽ với nhau.

Một nội trang cung cấp khả năng đầu ra tối thiểu, gỡ lỗi. (Nhớ lại rằng một chương trình jq
giá trị đầu ra luôn được xuất dưới dạng văn bản JSON trên tiêu chuẩn.) Các gỡ lỗi nội trang có thể có
hành vi dành riêng cho ứng dụng, chẳng hạn như đối với các tệp thực thi sử dụng API libjq C nhưng không
bản thân tệp thực thi jq.

đầu vào
Xuất một đầu vào mới.

đầu vào
Xuất ra tất cả các đầu vào còn lại, từng đầu vào.

Điều này chủ yếu hữu ích cho việc giảm bớt đầu vào của chương trình.

gỡ lỗi
Gây ra thông báo gỡ lỗi dựa trên giá trị đầu vào được tạo. Các kết thúc thực thi jq
giá trị đầu vào với ["NỢ:", ] và in dòng đó và một dòng mới trên stderr,
gọn nhẹ. Nó có thể thay đổi tương lai.

tên_file đầu vào
Trả về tên của tệp có đầu vào hiện đang được lọc. Lưu ý rằng điều này sẽ
không hoạt động tốt trừ khi jq đang chạy trong ngôn ngữ UTF-8.

đầu vào_dòng_số
Trả về số dòng của đầu vào hiện đang được lọc.

ĐƯỜNG

Với --dòng tùy chọn jq có thể phân tích cú pháp văn bản đầu vào theo kiểu truyền trực tuyến, cho phép jq
các chương trình bắt đầu xử lý các văn bản JSON lớn ngay lập tức thay vì sau khi phân tích cú pháp
hoàn thành. Nếu bạn có một văn bản JSON duy nhất có kích thước 1GB, việc phát trực tuyến văn bản đó sẽ cho phép bạn
để xử lý nó nhanh hơn nhiều.

Tuy nhiên, việc phát trực tuyến không dễ giải quyết vì chương trình jq sẽ có [ ,
] (và một số dạng khác) làm đầu vào.

Một số nội trang được cung cấp để giúp xử lý các luồng dễ dàng hơn.

Các ví dụ dưới đây sử dụng biểu mẫu được phát trực tiếp của [0, [1]], Đó là
[[0],0],[[1,0],1],[[1,0]],[[1]].

Các hình thức phát trực tuyến bao gồm [ , ] (để chỉ ra bất kỳ giá trị vô hướng nào, mảng trống,
hoặc đối tượng trống), và [ ] (để biểu thị sự kết thúc của một mảng hoặc đối tượng). Tương lai
phiên bản của jq chạy với --dòng và -seq có thể xuất ra các dạng bổ sung như ["lỗi
nhắn"] khi một văn bản đầu vào không thể phân tích cú pháp.

truncate_stream (stream_expression)
Sử dụng một số làm đầu vào và cắt bớt số phần tử đường dẫn tương ứng từ
bên trái của các đầu ra của biểu thức phát trực tuyến đã cho.

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

fromstream (stream_expression)
Xuất ra các giá trị tương ứng với đầu ra của biểu thức luồng.

jq ´fromstream(1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]]))´
vô giá trị
=> [2]

dòng chảy
Sản phẩm dòng chảy nội trang xuất ra dạng được truyền trực tiếp của đầu vào của nó.

jq ´. dưới dạng $ dot | fromstream ($ dot | tostream) |. == $ dot´
[0, [1, {"a": 1}, {"b": 2}]]
=> đúng

CHUYỂN NHƯỢNG

Phép gán hoạt động trong jq hơi khác so với hầu hết các ngôn ngữ lập trình. jq không
phân biệt giữa các tham chiếu đến và các bản sao của một cái gì đó - hai đối tượng hoặc mảng là
hoặc bằng hoặc không bằng nhau, không có bất kỳ khái niệm nào khác là "cùng một đối tượng" hoặc "không
cùng một đối tượng ”.

Nếu một đối tượng có hai trường là mảng, .foo và .Cafevà bạn nối một cái gì đó vào
.foothì .Cafe sẽ không lớn hơn. Ngay cả khi bạn vừa mới đặt .Cafe = .foo. Nếu bạn được sử dụng
để lập trình bằng các ngôn ngữ như Python, Java, Ruby, Javascript, v.v. thì bạn có thể nghĩ
của nó như thể jq thực hiện một bản sao sâu đầy đủ của mọi đối tượng trước khi nó thực hiện nhiệm vụ
(đối với hiệu suất, nó không thực sự làm điều đó, nhưng đó là ý tưởng chung).

Tất cả các toán tử gán trong jq đều có biểu thức đường dẫn ở phía bên trái.

=
Bộ lọc .foo = 1 sẽ nhận làm đầu vào một đối tượng và sản xuất dưới dạng đầu ra một đối tượng với
trường "foo" được đặt thành 1. Không có khái niệm "sửa đổi" hoặc "thay đổi" điều gì đó trong jq -
tất cả các giá trị jq là bất biến. Ví dụ,

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

sẽ không có tác dụng phụ khi đặt .bar.baz thành 1, vì giao diện tương tự
chương trình bằng Javascript, Python, Ruby hoặc các ngôn ngữ khác sẽ. Không giống như những ngôn ngữ này (nhưng
như Haskell và một số ngôn ngữ chức năng khác), không có khái niệm về hai mảng hoặc
các đối tượng là "cùng một mảng" hoặc "cùng một đối tượng". Chúng có thể bằng nhau hoặc không bằng nhau, nhưng
nếu chúng ta thay đổi một trong số họ trong bất kỳ hoàn cảnh nào thì người kia sẽ thay đổi sau lưng chúng ta.

Điều này có nghĩa là không thể xây dựng các giá trị tròn trong jq (chẳng hạn như một mảng có
phần tử đầu tiên là chính nó). Điều này khá có chủ đích và đảm bảo rằng bất kỳ điều gì một jq
chương trình có thể sản xuất có thể được biểu diễn bằng JSON.

Lưu ý rằng phía bên trái của ´ = ´ đề cập đến một giá trị trong .. Như vậy $ var.foo = 1 không thành công
như mong đợi ($ var.foo không phải là một biểu thức đường dẫn hợp lệ hoặc hữu ích trong .); sử dụng $ var | .foo = 1
thay thế.

Nếu phía bên phải của ´ = ´ tạo ra nhiều giá trị, thì với mỗi giá trị như vậy, jq sẽ
đặt các đường dẫn ở phía bên trái thành giá trị và sau đó nó sẽ xuất ra giá trị đã sửa đổi ..
Ví dụ, (.a, .b) =phạm vi(2) kết quả đầu ra {"a": 0, "b": 0}thì {"a": 1, "b": 1}. "Cập nhật"
các biểu mẫu phân công (xem bên dưới) không làm điều này.

Lưu ý rằng .a, .b = 0 không đặt .a và .b, Nhưng (.a, .b) = 0 đặt cả hai.

|=
Cũng như toán tử gán ´ = ´, jq cung cấp toán tử "cập nhật" ´ | = ´,
có một bộ lọc ở phía bên phải và tìm ra giá trị mới cho thuộc tính của .
được gán cho bằng cách chạy giá trị cũ thông qua biểu thức này. Ví dụ: .foo | =
. + 1 sẽ xây dựng một đối tượng với trường "foo" được đặt thành "foo" của đầu vào cộng với 1.

Ví dụ này sẽ cho thấy sự khác biệt giữa ´ = ´ và ´ | = ´:

Cung cấp đầu vào ´ {"a": {"b": 10}, "b": 20} ´ cho chương trình:

.a = .b .a | = .b

Trước đó sẽ đặt trường "a" của đầu vào thành trường "b" của đầu vào và tạo ra
đầu ra {"a": 20}. Sau đó sẽ đặt trường "a" của đầu vào thành trường "a"
trường "b", tạo ra {"a": 10}.

Phía bên trái có thể là bất kỳ biểu thức đường dẫn chung nào; Thấy chưa đường dẫn().

Lưu ý rằng phía bên trái của ´ | = ´ đề cập đến một giá trị trong .. Như vậy $ var.foo |= . + 1 đã thắng
làm việc như mong đợi ($ var.foo không phải là một biểu thức đường dẫn hợp lệ hoặc hữu ích trong .); sử dụng $ var | .foo
|= . + 1 thay thế.

Nếu phía bên phải xuất ra nhiều giá trị, thì chỉ giá trị cuối cùng sẽ được sử dụng.

jq ´ (.. | select (type == "boolean")) | = if. sau đó 1 khác 0 kết thúc´
[true, false, [5, true, [true, [false]], false]]
=> [1,0,[5,1,[1,[0]],0]]

+ =, - =, * =, / =, % =, // =
jq có một vài toán tử của biểu mẫu a op = b, tất cả đều tương đương với a |= . op b. Vì thế,
+= 1 có thể được sử dụng để tăng giá trị.

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

Phức tạp bài tập
Rất nhiều thứ được phép ở bên trái của bài tập jq so với hầu hết
ngôn ngữ. Chúng tôi đã thấy các truy cập trường đơn giản ở phía bên trái, và nó không
ngạc nhiên rằng các truy cập mảng cũng hoạt động như sau:

.posts [0] .title = "Hướng dẫn sử dụng JQ"

Điều đáng ngạc nhiên là biểu thức bên trái có thể tạo ra nhiều
kết quả, đề cập đến các điểm khác nhau trong tài liệu đầu vào:

.posts []. bình luận | =. + ["cái này thật tuyệt"]

Ví dụ đó nối chuỗi "điều này thật tuyệt" vào mảng "nhận xét" của mỗi bài đăng trong
đầu vào (trong đó đầu vào là một đối tượng với trường "các bài viết" là một mảng các bài đăng).

Khi jq gặp một phép gán như ´a = b´, nó sẽ ghi lại "đường dẫn" được thực hiện để chọn một
một phần của tài liệu đầu vào trong khi thực thi a. Đường dẫn này sau đó được sử dụng để tìm phần nào của
đầu vào để thay đổi trong khi thực hiện nhiệm vụ. Bất kỳ bộ lọc nào cũng có thể được sử dụng trên
bên trái của một dấu bằng - bất kỳ đường dẫn nào nó chọn từ đầu vào sẽ là nơi
nhiệm vụ được thực hiện.

Đây là một hoạt động rất mạnh mẽ. Giả sử chúng tôi muốn thêm nhận xét vào các bài đăng trên blog, bằng cách sử dụng
cùng một đầu vào "blog" ở trên. Lần này, chúng tôi chỉ muốn nhận xét về các bài viết được viết bởi
"stedolan". Chúng tôi có thể tìm thấy những bài đăng đó bằng cách sử dụng chức năng "chọn" được mô tả trước đó:

.posts [] | chọn (.author == "stedolan")

Các đường dẫn được cung cấp bởi thao tác này trỏ đến từng bài đăng mà "stedolan" đã viết, và
chúng tôi có thể nhận xét về từng người trong số họ theo cách giống như cách chúng tôi đã làm trước đây:

(.posts [] | select (.author == "stedolan") | .comments) | =
. + ["khủng khiếp."]

MODULES

jq có một hệ thống thư viện / mô-đun. Mô-đun là các tệp có tên kết thúc bằng .jq.

Các mô-đun được chương trình nhập vào được tìm kiếm trong đường dẫn tìm kiếm mặc định (xem bên dưới). Các
nhập khẩu và bao gồm chỉ thị cho phép nhà nhập khẩu thay đổi đường dẫn này.

Các đường dẫn trong đường dẫn tìm kiếm có thể thay thế khác nhau.

Đối với các đường dẫn bắt đầu bằng "~ /", thư mục chính của người dùng được thay thế cho "~".

Đối với các đường dẫn bắt đầu bằng "$ ORIGIN /", đường dẫn của tệp thực thi jq được thay thế cho
"$ XUẤT XỨ".

Đối với các đường dẫn bắt đầu bằng "./" hoặc các đường dẫn là ".", Đường dẫn của tệp bao gồm là
Được thay thế cho ".". Đối với các chương trình cấp cao nhất được cung cấp trên dòng lệnh, hiện tại
thư mục được sử dụng.

Các chỉ thị nhập có thể tùy chọn chỉ định một đường dẫn tìm kiếm mà giá trị mặc định được thêm vào.

Đường dẫn tìm kiếm mặc định là đường dẫn tìm kiếm được cung cấp cho -L tùy chọn dòng lệnh, khác
["~ / .jq", "$ ORIGIN /../ lib / jq", "$ XUẤT XỨ / ../ lib"].

Các phần tử đường dẫn chuỗi rỗng và rỗng chấm dứt quá trình xử lý đường dẫn tìm kiếm.

Một phần phụ thuộc có đường dẫn tương đối "foo / bar" sẽ được tìm kiếm trong "foo / bar.jq" và
"foo / bar / bar.jq" trong đường dẫn tìm kiếm đã cho. Điều này nhằm mục đích cho phép các mô-đun được đặt
trong một thư mục cùng với, ví dụ: tệp kiểm soát phiên bản, tệp README, v.v.,
mà còn để cho phép các mô-đun một tệp.

Các thành phần liên tiếp có cùng tên không được phép để tránh sự mơ hồ (ví dụ:
"foo / foo").

Ví dụ với -L $ HOME / .jq một mô-đun foo có thể được tìm thấy trong $ TRANG CHỦ / .jq / foo.jq và
$ TRANG CHỦ / .jq / foo / foo.jq.

Nếu "$ HOME / .jq" là một tệp, nó sẽ được đưa vào chương trình chính.

nhập khẩu Đường dẫn tương đốiChuỗi as TÊN [ ];
Nhập một mô-đun được tìm thấy tại đường dẫn nhất định liên quan đến một thư mục trong đường dẫn tìm kiếm. A ".jq"
hậu tố sẽ được thêm vào chuỗi đường dẫn tương đối. Các ký hiệu của mô-đun được bắt đầu bằng
"TÊN::".

Siêu dữ liệu tùy chọn phải là một biểu thức jq không đổi. Nó phải là một đối tượng có chìa khóa
như "trang chủ", v.v. Tại thời điểm này jq chỉ sử dụng khóa / giá trị "tìm kiếm" của
metadata. Siêu dữ liệu cũng được cung cấp cho người dùng thông qua siêu mô-đun được xây dựng trong.

Khóa "tìm kiếm" trong siêu dữ liệu, nếu có, phải có một chuỗi hoặc giá trị mảng (mảng
của chuỗi); đây là đường dẫn tìm kiếm được đặt trước cho đường dẫn tìm kiếm cấp cao nhất.

bao gồm Đường dẫn tương đốiChuỗi [ ];
Nhập một mô-đun được tìm thấy tại đường dẫn nhất định liên quan đến một thư mục trong đường dẫn tìm kiếm như thể nó
đã được đưa vào vị trí. Hậu tố ".jq" sẽ được thêm vào chuỗi đường dẫn tương đối. Các
các ký hiệu của mô-đun được nhập vào không gian tên của người gọi như thể nội dung của mô-đun có
đã được đưa vào trực tiếp.

Siêu dữ liệu tùy chọn phải là một biểu thức jq không đổi. Nó phải là một đối tượng có chìa khóa
như "trang chủ", v.v. Tại thời điểm này jq chỉ sử dụng khóa / giá trị "tìm kiếm" của
metadata. Siêu dữ liệu cũng được cung cấp cho người dùng thông qua siêu mô-đun được xây dựng trong.

nhập khẩu Đường dẫn tương đốiChuỗi as $ NAME [ ];
Nhập tệp JSON được tìm thấy tại đường dẫn nhất định liên quan đến một thư mục trong đường dẫn tìm kiếm. MỘT
Hậu tố ".json" sẽ được thêm vào chuỗi đường dẫn tương đối. Dữ liệu của tệp sẽ là
có sẵn như $ NAME :: NAME.

Siêu dữ liệu tùy chọn phải là một biểu thức jq không đổi. Nó phải là một đối tượng có chìa khóa
như "trang chủ", v.v. Tại thời điểm này jq chỉ sử dụng khóa / giá trị "tìm kiếm" của
metadata. Siêu dữ liệu cũng được cung cấp cho người dùng thông qua siêu mô-đun được xây dựng trong.

Khóa "tìm kiếm" trong siêu dữ liệu, nếu có, phải có một chuỗi hoặc giá trị mảng (mảng
của chuỗi); đây là đường dẫn tìm kiếm được đặt trước cho đường dẫn tìm kiếm cấp cao nhất.

mô-đun ;
Chỉ thị này là hoàn toàn tùy chọn. Nó không cần thiết để hoạt động đúng. Nó phục vụ
chỉ với mục đích cung cấp siêu dữ liệu có thể đọc được với siêu mô-đun được xây dựng trong.

Siêu dữ liệu phải là một biểu thức jq không đổi. Nó phải là một đối tượng có các phím như
"trang chủ". Tại thời điểm này, jq không sử dụng siêu dữ liệu này, nhưng nó được cung cấp cho người dùng
thông qua siêu mô-đun được xây dựng trong.

siêu mô-đun
Lấy tên mô-đun làm đầu vào và đầu ra siêu dữ liệu của mô-đun dưới dạng một đối tượng, với
nhập của mô-đun (bao gồm siêu dữ liệu) dưới dạng giá trị mảng cho khóa "deps".

Các chương trình có thể sử dụng điều này để truy vấn siêu dữ liệu của mô-đun, sau đó chúng có thể sử dụng để
ví dụ, tìm kiếm, tải xuống và cài đặt các phần phụ thuộc bị thiếu.

Sử dụng jq trực tuyến bằng các dịch vụ onworks.net