Html đầu vào được phân tách bằng dấu phẩy

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. Có rất nhiều bộ lọc dựng sẵn để 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

Show

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 này sang một bộ lọc khác hoặc thu thập đầu ra của một bộ lọc thành một mảng

Một số bộ lọc tạo ra nhiều kết quả, chẳng hạn, 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ó. Đặt bộ lọc đó thành bộ lọc thứ hai 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à phép lặp 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 cũng là các bộ lọc - chúng lấy một đầu vào nhưng luôn tạo ra cùng một chữ như đầu ra. Các hoạt động kết hợp hai bộ lọc, chẳng hạn như phép cộng, 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 lấy trung bình là

recurse(.children[]) | .name
50 - cung cấp mảng đầu vào cho cả bộ lọc
recurse(.children[]) | .name
51 và bộ lọc
recurse(.children[]) | .name
52, sau đó thực hiện phép chia

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

Các toán tử và hàm dựng sẵn

Một số toán tử jq (ví dụ:

recurse(.children[]) | .name
53) làm những việc khác nhau tùy thuộc vào loại đối số của chúng (mảng, số, v.v. ). Tuy nhiên, jq không bao giờ thực hiện chuyển đổi kiểu ẩn. Nếu 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ả

Phép cộng. recurse(.children[]) | .name 53

Toán tử

recurse(.children[]) | .name
53 lấy hai bộ lọc, áp dụng cả hai cho cùng một đầu vào và cộng các kết quả lại với nhau. "Thêm" nghĩa là gì tùy thuộc vào các loại liên quan

  • Các số được thêm bằng số học bình thường

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

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

  • Các đối tượng được thêm 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 đối tượng vào một đối tượng kết hợp duy nhất. Nếu cả hai đối tượng chứa một giá trị cho cùng một khóa, thì đối tượng bên phải của

    recurse(.children[]) | .name
    
    53 sẽ thắng. (Đối với hợp nhất đệ quy, hãy sử dụng toán tử
    recurse(.children[]) | .name
    
    1. )

recurse(.children[]) | .name
2 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

ví dụ

jq'. a + 1'Input{"a". 7}Đầu ra8jq '. một +. b'Input{"a". [1,2], "b". [3,4]}Đầu ra[1,2,3,4]jq '. a + null'Input{"a". 1}Đầu ra1jq '. a + 1'Input{}Output1jq '{a. 1} + {b. 2} + {c. 3} + {a. 42}'InputnullOutput{"a". 42, "b". 2, "c". 3}

phép trừ. recurse(.children[]) | .name 3

Cũng như phép trừ số học thông thường trên các số, toán tử

recurse(.children[]) | .name
3 có thể được sử dụng trên mảng để loại bỏ 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 thứ nhất

ví dụ

jq '4 -. a'Input{"a". 3}Đầu ra1jq '. - ["xml", "yaml"]'Input["xml", "yaml", "json"]Output["json"]

Nhân, chia, modulo. recurse(.children[]) | .name 1, recurse(.children[]) | .name 6 và recurse(.children[]) | .name 7

Các toán tử trung tố này hoạt động như mong đợi khi được cung cấp hai số. Chia cho số 0 gây ra lỗi.

recurse(.children[]) | .name
8 tính x modulo y

Nhân một chuỗi với một số sẽ tạo ra phép nối của chuỗi đó nhiều lần.

recurse(.children[]) | .name
9 tạo ra giá trị rỗng

Chia một chuỗi cho một chuỗi khác sẽ phân tách 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 theo cách đệ quy. điều này hoạt động giống như phép cộng nhưng nếu cả hai đối tượng chứa một giá trị cho cùng một khóa và các giá trị là đối tượng, thì cả hai sẽ được hợp nhất với cùng một chiến lược

ví dụ

jq '10 /. * 3'Input5Output6jq'. / ", "'Đầu vào"a, b,c,d, e"Đầu ra["a","b,c,d","e"]jq '{"k". {"một". 1, "b". 2}} * {"k". {"một". 0,"c". 3}}'InputnullOutput{"k". {"một". 0, "b". 2, "c". 3}}jq '. []. (1/. )?'Input[1,0,-1]Output1-1

recurse(.children[]) | .name 52

Hàm dựng sẵn

recurse(.children[]) | .name
52 lấy độ dài của nhiều loại giá trị khác nhau

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

  • Độ dài của mảng là số phần tử

  • Độ dài của một đối tượng là số cặp khóa-giá trị

  • Độ dài của null bằng không

Thí dụ

jq'. []. length'Input[[1,2], "chuỗi", {"a". 2}, null]Đầu ra2610

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

Hàm dựng sẵn

@uri "https://www.google.com/search?q=\(.search)"
2 xuất ra số byte được sử dụng để mã hóa một chuỗi trong UTF-8

Thí dụ

jq 'utf8bytelength'Input"\u03bc"Output2

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

Hàm dựng sẵn

@uri "https://www.google.com/search?q=\(.search)"
4, khi được cung cấp một đối tượng, sẽ trả về các khóa của nó trong một mảng

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

Khi

@uri "https://www.google.com/search?q=\(.search)"
4 được cung cấp một mảng, nó sẽ trả về các chỉ số hợp lệ cho mảng đó. các số nguyên từ 0 đến độ dài-1

Hàm

@uri "https://www.google.com/search?q=\(.search)"
5 giống như hàm
@uri "https://www.google.com/search?q=\(.search)"
4, 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 phím sẽ được sắp xếp đại khái theo thứ tự chèn

ví dụ

jq 'keys'Input{"abc". 1, "abcd". 2, "Phốc". 3}Đầu ra["Foo", "abc", "abcd"]jq 'keys'Input[42,3,35]Output[0,1,2]

recurse(.children[]) | .name 70

Hàm dựng sẵn

recurse(.children[]) | .name
71 trả về liệu đối tượng đầu vào có khóa đã cho hay mảng đầu vào có phần tử tại chỉ mục đã cho

recurse(.children[]) | .name
72 có tác dụng tương tự như kiểm tra xem
recurse(.children[]) | .name
73 có phải là thành viên của mảng được trả về bởi
@uri "https://www.google.com/search?q=\(.search)"
4 hay không, mặc dù
recurse(.children[]) | .name
71 sẽ nhanh hơn

ví dụ

jq 'map(has("foo"))'Input[{"foo". 42}, {}]Đầu ra[true, false]jq 'map(has(2))'Input[[0,1], ["a","b","c"]]Đầu ra[false, true]

recurse(.children[]) | .name 76

Hàm dựng sẵn

recurse(.children[]) | .name
76 trả về khóa đầu vào có trong đối tượng đã cho hay không 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
recurse(.children[]) | .name
71

ví dụ

jq'. []. trong ({"foo". 42})'Input["foo", "bar"]Outputtruefalsejq 'map(in([0,1]))'Input[2, 0]Output[false, true]

recurse(.children[]) | .name 79, recurse(.children[]) | .name 500

Đối với bất kỳ bộ lọc nào

recurse(.children[]) | .name
501,
recurse(.children[]) | .name
79 sẽ chạy bộ lọc đó cho từng phần tử của mảng đầu vào và trả về kết quả đầu ra trong một mảng mới.
recurse(.children[]) | .name
503 sẽ tăng từng phần tử của một dãy số

Tương tự,

recurse(.children[]) | .name
500 sẽ chạy bộ lọc đó cho từng phần tử, nhưng nó sẽ trả về một đối tượng khi một đối tượng được truyền vào

recurse(.children[]) | .name
79 tương đương với
recurse(.children[]) | .name
506. Trên thực tế, đây là cách nó được định nghĩa. Tương tự,
recurse(.children[]) | .name
500 được định nghĩa là
recurse(.children[]) | .name
508

ví dụ

jq 'bản đồ (. +1)'Input[1,2,3]Output[2,3,4]jq 'map_values(. +1)'Đầu vào{"a". 1, "b". 2, "c". 3}Đầu ra{"a". 2, "b". 3, "c". 4}

recurse(.children[]) | .name 509

Xuất ra các biểu diễn mảng của biểu thức đường dẫn đã cho trong

recurse(.children[]) | .name
510. Đầu ra là các mảng chuỗi (khóa đối tượng) và/hoặc số (chỉ số mảng)

Biểu thức đường dẫn là các biểu thức jq như

recurse(.children[]) | .name
511, nhưng cũng có thể là
recurse(.children[]) | .name
512. Có hai loại biểu thức đường dẫn. những cái có thể khớp chính xác và những cái không thể. Ví dụ:
recurse(.children[]) | .name
513 là biểu thức đường dẫn khớp chính xác, trong khi
recurse(.children[]) | .name
514 thì không

recurse(.children[]) | .name
515 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
recurse(.children[]) | .name
510, nếu
recurse(.children[]) | .name
510 là
recurse(.children[]) | .name
2 hoặc một mảng hoặc một đối tượng

recurse(.children[]) | .name
519 sẽ tạo ra các biểu diễn mảng của các đường dẫn phù hợp với
recurse(.children[]) | .name
520 nếu các đường dẫn tồn tại trong
recurse(.children[]) | .name
510

Lưu ý rằng các biểu thức đường dẫn không khác với các biểu thức bình thường. Biểu thức

recurse(.children[]) | .name
522 xuất ra tất cả các đường dẫn đến các giá trị boolean trong
recurse(.children[]) | .name
510 và chỉ những đường dẫn đó

ví dụ

jq 'đường dẫn (. một[0]. b)'InputnullOutput["a",0,"b"]jq '[đường dẫn(. )]'Đầu vào{"a". [{"b". 1}]}Đầu ra[[],["a"],["a",0],["a",0,"b"]]

recurse(.children[]) | .name 524

Hàm dựng sẵn

recurse(.children[]) | .name
525 xóa một khóa và giá trị tương ứng của nó khỏi một đối tượng

ví dụ

jq 'del(. foo)'Input{"foo". 42, "thanh". 9001, "baz". 42}Đầu ra{"thanh". 9001, "baz". 42}jq 'del(. [1, 2])'Input["foo", "bar", "baz"]Output["foo"]

recurse(.children[]) | .name 526

Hàm dựng sẵn

recurse(.children[]) | .name
527 xuất các giá trị trong
recurse(.children[]) | .name
510 được tìm thấy tại mỗi đường dẫn trong
recurse(.children[]) | .name
529

ví dụ

jq 'getpath(["a","b"])'InputnullOutputnulljq '[getpath(["a","b"], ["a","c"])]'Input{"a". {"b". 0, "c". 1}}Đầu ra[0, 1]

recurse(.children[]) | .name 530

Hàm dựng sẵn

recurse(.children[]) | .name
531 đặt
recurse(.children[]) | .name
529 trong
recurse(.children[]) | .name
510 thành
recurse(.children[]) | .name
534

ví dụ

jq 'setpath(["a","b"]; 1)'InputnullOutput{"a". {"b". 1}}jq 'setpath(["a","b"]; 1)'Input{"a". {"b". 0}}Đầu ra{"a". {"b". 1}}jq 'setpath([0,"a"]; 1)'InputnullOutput[{"a". 1}]

recurse(.children[]) | .name 535

Hàm dựng sẵn

recurse(.children[]) | .name
536 đặt
recurse(.children[]) | .name
529 trong
recurse(.children[]) | .name
510.
recurse(.children[]) | .name
529 phải là một mảng các đường dẫn, trong đó mỗi đường dẫn là một mảng các chuỗi và số

Thí dụ

jq 'delpaths([["a","b"]])'Input{"a". {"b". 1},"x". {"y". 2}}Đầu ra{"a". {},"x". {"y". 2}}

recurse(.children[]) | .name 530, recurse(.children[]) | .name 531, recurse(.children[]) | .name 532

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

recurse(.children[]) | .name
530 được truyền một đối tượng, thì với mỗi mục nhập
recurse(.children[]) | .name
534 trong đầu vào, mảng đầu ra bao gồm
recurse(.children[]) | .name
535

recurse(.children[]) | .name
531 thực hiện chuyển đổi ngược lại và
recurse(.children[]) | .name
537 là cách viết tắt của
recurse(.children[]) | .name
538, hữu ích để thực hiện một số thao tác đối với tất cả các khóa và giá trị của một đối tượng.
recurse(.children[]) | .name
531 chấp nhận khóa, Khóa, tên, Tên, giá trị và Giá trị làm khóa

ví dụ

jq 'to_entries'Input{"a". 1, "b". 2}Đầu ra[{"key". "một giá trị". 1}, {"phím". "b", "giá trị". 2}]jq 'from_entries'Input[{"key". "một giá trị". 1}, {"phím". "b", "giá trị". 2}]Đầu ra{"a". 1, "b". 2}jq 'with_entries(. Chìa khóa. = "KEY_" +. )'Đầu vào{"a". 1, "b". 2}Đầu ra{"KEY_a". 1, "KEY_b". 2}

recurse(.children[]) | .name 530

Hàm

recurse(.children[]) | .name
531 tạo ra đầu vào không thay đổi nếu
recurse(.children[]) | .name
532 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.

recurse(.children[]) | .name
533 sẽ cung cấp cho bạn
recurse(.children[]) | .name
534

ví dụ

jq 'bản đồ (chọn (. >= 2))'Đầu vào[1,5,3,0,7]Đầu ra[5,3,7]jq '. []. lựa chọn(. id == "giây")'Input[{"id". "đầu tiên", "val". 1}, {"id". "thứ hai", "val". 2}]Đầu ra{"id". "thứ hai", "val". 2}

recurse(.children[]) | .name 535, recurse(.children[]) | .name 536, recurse(.children[]) | .name 537, recurse(.children[]) | .name 538, recurse(.children[]) | .name 539, recurse(.children[]) | .name 00, recurse(.children[]) | .name 01, recurse(.children[]) | .name 02, recurse(.children[]) | .name 03, recurse(.children[]) | .name 04, recurse(.children[]) | .name 05

Các phần bổ sung tích hợp này chỉ chọn các đầu vào là mảng, đối tượng, có thể lặp lại (mảng hoặc đối tượng), booleans, số, số bình thường, số hữu hạn, chuỗi, null, giá trị không null và không thể lặp lại, tương ứng

Thí dụ

jq'. []. số'Input[[],{},1,"foo",null,true,false]Output1

recurse(.children[]) | .name 06

recurse(.children[]) | .name
06 không trả về kết quả nào. Không có gì cả. Thậm chí không
recurse(.children[]) | .name
2

Nó hữu ích vào dịp. Bạn sẽ biết nếu bạn cần nó. )

ví dụ

jq '1, trống, 2'InputnullOutput12jq '[1,2,trống,3]'InputnullOutput[1,2,3]

recurse(.children[]) | .name 09

Tạo ra một lỗi, giống như

recurse(.children[]) | .name
511 được áp dụng cho các giá trị khác null và các đối tượng, nhưng với thông báo đã cho là giá trị của lỗi. Có thể bắt lỗi bằng try/catch;

recurse(.children[]) | .name 11

Dừng chương trình jq mà không có thêm đầu ra nào. jq sẽ thoát với trạng thái thoát

recurse(.children[]) | .name
12

recurse(.children[]) | .name 13, recurse(.children[]) | .name 14

Dừng chương trình jq mà không có thêm đầu ra nào. Đầu vào sẽ được in trên

recurse(.children[]) | .name
15 dưới dạng đầu ra thô (i. e. , chuỗi sẽ không có dấu ngoặc kép) không có trang trí, thậm chí không có dòng mới

recurse(.children[]) | .name
16 đã cho (mặc định là
recurse(.children[]) | .name
17) sẽ là trạng thái thoát của jq

Ví dụ,

recurse(.children[]) | .name
18

recurse(.children[]) | .name 19

Tạo một đối tượng có khóa "tệp" và khóa "dòng", với tên tệp và số dòng nơi xảy ra

recurse(.children[]) | .name
19, làm giá trị

Thí dụ

jq 'thử lỗi("\($__loc__)") bắt. 'InputnullOutput"{\"file\". \"\",\"đường kẻ\". 1}"

recurse(.children[]) | .name 21, recurse(.children[]) | .name 22, recurse(.children[]) | .name 23

recurse(.children[]) | .name
21 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 cho. chính nó)

recurse(.children[]) | .name
25 xuất ra các đường dẫn đến bất kỳ giá trị nào mà đối với nó,
recurse(.children[]) | .name
26 là đúng. Nghĩa là,
recurse(.children[]) | .name
27 xuất ra các đường dẫn đến tất cả các giá trị số

recurse(.children[]) | .name
23 là bí danh của
recurse(.children[]) | .name
29;

ví dụ

jq '[đường dẫn]'Input[1,[[],{"a". 2}]]Đầu ra[[0],[1],[1,0],[1,1],[1,1,"a"]]jq '[đường dẫn(vô hướng)]'Input[1,[ . 2}]]Đầu ra[[0],[1,1,"a"]]

recurse(.children[]) | .name 51

Bộ lọc

recurse(.children[]) | .name
51 lấy đầu vào là một mảng và tạo đầu ra là các phần tử của mảng được cộng lại với nhau. Điều này có thể có nghĩa là tổng, nối hoặc hợp nhất tùy thuộc vào loại phần tử của mảng đầu vào - các quy tắc giống như quy tắc đối với toán tử
recurse(.children[]) | .name
53 (được mô tả ở trên)

Nếu đầu vào là một mảng trống,

recurse(.children[]) | .name
51 trả về
recurse(.children[]) | .name
2

ví dụ

jq 'add'Input["a","b","c"]Output"abc"jq 'add'Input[1, 2, 3]Output6jq 'add'Input[]Outputnull

recurse(.children[]) | .name 36, recurse(.children[]) | .name 37, recurse(.children[]) | .name 38

Bộ lọc

recurse(.children[]) | .name
36 lấy đầu vào là một mảng các giá trị boolean và tạo ra
recurse(.children[]) | .name
40 làm đầu ra nếu bất kỳ phần tử nào của mảng là
recurse(.children[]) | .name
40

Nếu đầu vào là một mảng trống,

recurse(.children[]) | .name
36 trả về
recurse(.children[]) | .name
43

Dạng

recurse(.children[]) | .name
37 áp dụng điều kiện cho trước cho các phần tử của mảng đầu vào

Biểu mẫu

recurse(.children[]) | .name
38 áp dụng điều kiện đã cho cho tất cả các đầu ra của trình tạo đã cho

ví dụ

jq 'any'Input[true, false]Outputtruejq 'any'Input[false, false]Outputfalsejq 'any'Input[]Outputfalse

recurse(.children[]) | .name 46, recurse(.children[]) | .name 47, recurse(.children[]) | .name 48

Bộ lọc

recurse(.children[]) | .name
46 lấy đầu vào là một mảng các giá trị boolean và tạo ra đầu ra là
recurse(.children[]) | .name
40 nếu tất cả các phần tử của mảng là
recurse(.children[]) | .name
40

Dạng

recurse(.children[]) | .name
47 áp dụng điều kiện cho trước cho các phần tử của mảng đầu vào

Biểu mẫu

recurse(.children[]) | .name
48 áp dụng điều kiện đã cho cho tất cả các đầu ra của trình tạo đã cho

Nếu đầu vào là một mảng trống,

recurse(.children[]) | .name
46 trả về
recurse(.children[]) | .name
40

ví dụ

jq 'all'Input[true, false]Outputfalsejq 'all'Input[true, true]Outputtruejq 'all'Input[]Outputtrue

recurse(.children[]) | .name 56, recurse(.children[]) | .name 57

Bộ lọc

recurse(.children[]) | .name
56 lấy đầ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 đó 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

recurse(.children[]) | .name
59 giống như
recurse(.children[]) | .name
56, nhưng chỉ đi sâu đến hai cấp độ

ví dụ

jq 'flatten'Input[1, [2], [[3]]]Output[1, 2, 3]jq 'flatten(1)'Input[1, [2], [[3]]]Output[1 . "thanh"}, [{"foo". "baz"}]]Đầu ra[{"foo". "thanh"}, {"foo". "baz"}]

recurse(.children[]) | .name 61, recurse(.children[]) | .name 62 recurse(.children[]) | .name 63

Hàm

recurse(.children[]) | .name
64 tạo ra một dãy số.
recurse(.children[]) | .name
65 ra 6 số, từ 4 (bao gồm) đến 10 (độc quyền). Các số được tạo ra dưới dạng đầu ra riêng biệt. Sử dụng
recurse(.children[]) | .name
66 để lấy phạm vi dưới dạng mảng

Một dạng đối số tạo ra các số từ 0 đến số đã cho, với số gia là 1

Dạng hai đối số tạo ra các số từ

recurse(.children[]) | .name
67 đến
recurse(.children[]) | .name
68 với số gia là 1

Dạng ba đối số tạo ra các số

recurse(.children[]) | .name
67 đến
recurse(.children[]) | .name
68 với số gia là
recurse(.children[]) | .name
71

ví dụ

jq 'range(2;4)'InputnullOutput23jq '[range(2;4)]'InputnullOutput[2,3]jq '[range(4)]'InputnullOutput[0,1,2,3]jq '[range(

recurse(.children[]) | .name 72

Hàm

recurse(.children[]) | .name
72 trả về giá trị sàn của đầu vào số của nó

Thí dụ

jq 'sàn'Input3. 14159Đầu ra3

recurse(.children[]) | .name 74

Hàm

recurse(.children[]) | .name
74 trả về căn bậc hai của đầu vào số của nó

recurse(.children[]) | .name 76

Hàm

recurse(.children[]) | .name
76 phân tích cú pháp đầu vào của nó dưới dạng số. Nó sẽ chuyển đổi các chuỗi được định dạng chính xác thành số tương đương của chúng, để yên các số và đưa ra lỗi trên tất cả các đầu vào khác

Thí dụ

jq'. []. tonumber'Input[1, "1"]Output11

recurse(.children[]) | .name 78

Hàm

recurse(.children[]) | .name
78 in đầu vào của nó dưới dạng một chuỗi. Các chuỗi không thay đổi và tất cả các giá trị khác được mã hóa JSON

Thí dụ

jq'. []. tostring'Input[1, "1", [1]]Output"1""1""[1]"

recurse(.children[]) | .name 80

Hàm

recurse(.children[]) | .name
80 trả về loại đối số của nó dưới dạng một chuỗi, là một trong số null, boolean, số, chuỗi, mảng hoặc đối tượng

Thí dụ

jq 'map(type)'Input[0, false, [], {}, null, "hello"]Output["number", "boolean", "array", "object", "null", "string"

recurse(.children[]) | .name 82, recurse(.children[]) | .name 83, ________ 084, ________ 085, ________ 086, ________ 087

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). Nội trang

recurse(.children[]) | .name
84 trả về
recurse(.children[]) | .name
40 nếu đầu vào của nó là vô hạn. The
recurse(.children[]) | .name
85 builtin returns
recurse(.children[]) | .name
40 if its input is a NaN. Nội trang
recurse(.children[]) | .name
82 trả về một giá trị vô hạn dương. The
recurse(.children[]) | .name
83 builtin returns a NaN. Nội trang
recurse(.children[]) | .name
87 trả về true nếu đầu vào của nó là một số bình thường

Note that division by zero raises an error

Currently most arithmetic operations operating on infinities, NaNs, and sub-normals do not raise errors

ví dụ

jq'. []. (vô số *. ) < 0'Input[-1, 1]Outputtruefalsejq 'vô hạn, nan. loại'InputnullOutput"số""số"

recurse(.children[]) | .name 95

Hàm

recurse(.children[]) | .name
96 sắp xếp đầu vào của nó, phải là một mảng. Các giá trị được sắp xếp theo thứ tự sau

  • recurse(.children[]) | .name
    
    2
  • recurse(.children[]) | .name
    
    43
  • recurse(.children[]) | .name
    
    40
  • con số
  • strings, in alphabetical order (by unicode codepoint value)
  • mảng, theo thứ tự từ vựng
  • các đối tượng

The ordering for objects is a little complex. trước tiên, chúng được so sánh bằng cách so sánh các bộ khóa của chúng (dưới dạng 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ị được so sánh theo từng khóa

recurse(.children[]) | .name
96 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

@uri "https://www.google.com/search?q=\(.search)"
01 so sánh hai phần tử bằng cách so sánh kết quả của
recurse(.children[]) | .name
532 trên mỗi phần tử

ví dụ

jq 'sort'Input[8,3,null,6]Output[null,3,6,8]jq 'sort_by(. foo)'Input[{"foo". 4, "thanh". 10}, {"foo". 3, "bar". 100}, {"foo". 2, "bar". 1}]Đầu ra[{"foo". 2, "thanh". 1}, {"foo". 3, "thanh". 100}, {"foo". 4, "thanh". 10}]

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

@uri "https://www.google.com/search?q=\(.search)"
04 lấy đầu vào là một mảng, nhóm các phần tử có cùng trường
@uri "https://www.google.com/search?q=\(.search)"
05 thành các mảng riêng biệt và tạo tất cả các mảng này dưới dạng các phần tử của một mảng lớn hơn, được sắp xếp theo giá trị của trường
@uri "https://www.google.com/search?q=\(.search)"
05

Bất kỳ biểu thức jq nào, không chỉ truy cập trường, có thể được sử dụng thay cho

@uri "https://www.google.com/search?q=\(.search)"
05. Thứ tự sắp xếp giống như được mô tả trong hàm
recurse(.children[]) | .name
96 ở trên

Thí dụ

jq 'group_by(. foo)'Input[{"foo". 1, "thanh". 10}, {"foo". 3, "thanh". 100}, {"foo". 1, "thanh". 1}]Đầu ra[[{"foo". 1, "thanh". 10}, {"foo". 1, "thanh". 1}], [{"foo". 3, "thanh". 100}]]

@uri "https://www.google.com/search?q=\(.search)" 09, @uri "https://www.google.com/search?q=\(.search)" 10, @uri "https://www.google.com/search?q=\(.search)" 11, @uri "https://www.google.com/search?q=\(.search)" 12

Tìm phần tử tối thiểu hoặc tối đa của mảng đầu vào

Các hàm

@uri "https://www.google.com/search?q=\(.search)"
11 và
@uri "https://www.google.com/search?q=\(.search)"
12 cho phép bạn chỉ định một trường hoặc thuộc tính cụ thể để kiểm tra, e. g.
@uri "https://www.google.com/search?q=\(.search)"
15 finds the object with the smallest
recurse(.children[]) | .name
532 field

ví dụ

jq 'min'Input[5,4,2,7]Output2jq 'max_by(. foo)'Input[{"foo". 1, "thanh". 14}, {"foo". 2, "thanh". 3}]Đầu ra{"foo". 2, "thanh". 3}

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

Hàm

@uri "https://www.google.com/search?q=\(.search)"
17 lấy đầu vào là một mảng và tạo ra một mảng gồm các phần tử giống nhau, theo thứ tự được sắp xếp, loại bỏ các phần trùng lặp

Hàm

@uri "https://www.google.com/search?q=\(.search)"
18 sẽ chỉ giữ lại một phần tử cho mỗi giá trị thu được bằng cách áp dụng đối số. Hãy nghĩ về nó như tạo một mảng bằng cách lấy một phần tử ra khỏi mỗi nhóm được tạo bởi
@uri "https://www.google.com/search?q=\(.search)"
21

ví dụ

jq 'unique'Input[1,2,5,3,5,3,1,3]Output[1,2,3,5]jq 'unique_by(. foo)'Input[{"foo". 1, "thanh". 2}, {"foo". 1, "bar". 3}, {"foo". 4, "thanh". 5}]Output[{"foo". 1, "bar". 2}, {"foo". 4, "thanh". 5}]jq 'unique_by(length)'Input["thịt xông khói", "thịt xông khói", "mèo con", "ve sầu", "măng tây"]Output["thịt lợn muối xông khói", "thịt hun khói", "măng tây"]

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

This function reverses an array

Thí dụ

jq 'reverse'Input[1,2,3,4]Output[4,3,2,1]

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

Bộ lọc

@uri "https://www.google.com/search?q=\(.search)"
24 sẽ tạo ra true nếu b được chứa hoàn toàn trong đầu vào. Xâu B được chứa trong xâu A nếu B là xâu con của A. An array B is contained in an array A if all elements in B are contained in any element in A. Một đối tượng B đượ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. All other types are assumed to be contained in each other if they are equal

ví dụ

jq 'contains("bar")'Input"foobar"Outputtruejq 'contains(["baz", "bar"])'Input["foobar", "foobaz", "blarp"]Outputtruejq 'contains(["bazzzzz", "bar"])'Input["foobar", "foobaz", "blarp"]Outputfalsejq 'contains({foo. 12, thanh. [{vỗ tay. 12}]})'Input{"foo". 12, "bar". [1,2,{"thanh". 12, "blip". 13}]}Outputtruejq 'chứa({foo. 12, bar. [{barp. 15}]})'Đầu vào{"foo". 12, "bar". [1,2,{"thanh". 12, "blip". 13}]}Outputfalse

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

Xuất ra một mảng chứa các chỉ số trong

recurse(.children[]) | .name
510 trong đó
@uri "https://www.google.com/search?q=\(.search)"
27 xảy ra. The input may be an array, in which case if
@uri "https://www.google.com/search?q=\(.search)"
27 is an array then the indices output will be those where all elements in
recurse(.children[]) | .name
510 match those of
@uri "https://www.google.com/search?q=\(.search)"
27

ví dụ

jq 'indices(", ")'Input"a,b, cd, efg, hijk"Output[3,7,12]jq 'indices(1)'Input[0,1,2,1,3,1,4]Output[1,3,5]jq 'indices([1,2])'Input[0,1,2,3,1,4,2,5,1,2,6,7]Output[1,8]

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

Outputs the index of the first (

@uri "https://www.google.com/search?q=\(.search)"
33) or last (
@uri "https://www.google.com/search?q=\(.search)"
34) occurrence of
@uri "https://www.google.com/search?q=\(.search)"
27 in the input

ví dụ

jq 'index(", ")'Input"a,b, cd, efg, hijk"Output3jq 'rindex(", ")'Input"a,b, cd, efg, hijk"Output12

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

The filter

@uri "https://www.google.com/search?q=\(.search)"
37 will produce true if the input is completely contained within b. It is, essentially, an inversed version of
@uri "https://www.google.com/search?q=\(.search)"
38

ví dụ

jq 'bên trong("foobar")'Input"bar"Outputtruejq 'bên trong(["foobar", "foobaz", "blarp"])'Input["baz", "bar"]Outputtruejq 'bên trong(["foobar" . 12, "thanh". [1,2,{"thanh". 12, "blip". 13}]})'Input{"foo". 12, "bar". [{"vỗ". 12}]}Outputtruejq 'bên trong({"foo". 12, "bar". [1,2,{"barp". 12, "đốm". 13}]})'Đầu vào{"foo". 12, "thanh". [{"vỗ". 15}]}Outputfalse

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

Kết quả đầu ra

recurse(.children[]) | .name
40 nếu. bắt đầu với đối số chuỗi đã cho

Thí dụ

jq '[. []. startedwith("foo")]'Input["fo", "foo", "barfoo", "foobar", "barfoob"]Output[false, true, false, true, false]

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

Kết quả đầu ra

recurse(.children[]) | .name
40 nếu. ends with the given string argument

Thí dụ

jq '[. []. endwith("foo")]'Input["foobar", "barfoo"]Output[false, true]

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

Xuất ra 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ố

@uri "https://www.google.com/search?q=\(.search)"
45, nó sẽ xuất ra tất cả các kết hợp của các lần lặp lại
@uri "https://www.google.com/search?q=\(.search)"
45 của mảng đầu vào

ví dụ

jq 'kết hợp'Input[[1,2], [3, 4]]Output[1, 3][1, 4][2, 3][2, 4]jq 'kết hợp(2)'Input[0,

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

Xuất đầu vào của nó với chuỗi tiền tố đã cho bị xóa, nếu nó bắt đầu bằng nó

Thí dụ

jq '[. []. ltrimstr("foo")]'Input["fo", "foo", "barfoo", "foobar", "afoo"]Output["fo","","barfoo","bar","afoo"]

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

Outputs its input with the given suffix string removed, if it ends with it

Thí dụ

jq '[. []. rtrimstr("foo")]'Input["fo", "foo", "barfoo", "foobar", "foob"]Output["fo","","bar","foobar","foob"

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

Converts an input string into an array of the string's codepoint numbers

Thí dụ

jq 'explode'Input"foobar"Output[102,111,111,98,97,114]

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

nghịch đảo của phát nổ

Thí dụ

jq 'implode'Input[65, 66, 67]Output"ABC"

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

Splits an input string on the separator argument

Thí dụ

jq 'split(", ")'Input"a, b,c,d, e, "Output["a","b,c,d","e",""]

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

Tham gia mảng các phần tử được cung cấp làm đầu vào, sử dụng đối số làm dấu phân cách. It is the inverse of

@uri "https://www.google.com/search?q=\(.search)"
53. that is, running
@uri "https://www.google.com/search?q=\(.search)"
54 over any input string returns said input string

Các số và boolean trong đầu vào được chuyển đổi thành chuỗi. Null values are treated as empty strings. Mảng và đối tượng trong đầu vào không được hỗ trợ

ví dụ

jq 'join(", ")'Input["a","b,c,d","e"]Output"a, b,c,d, e"jq 'join(" ")'Input[" . 3,true,null,false]Output"a 1 2. 3 đúng sai"

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

Phát ra một bản sao của chuỗi đầu vào với các ký tự chữ cái (a-z và A-Z) được chuyển đổi thành trường hợp cụ thể

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

Hàm

@uri "https://www.google.com/search?q=\(.search)"
57 cho phép bạn lặp đi lặp lại áp dụng biểu thức
@uri "https://www.google.com/search?q=\(.search)"
59, ban đầu cho
recurse(.children[]) | .name
510 sau đó cho đầu ra của chính nó, cho đến khi
@uri "https://www.google.com/search?q=\(.search)"
61 là true. Ví dụ: điều này có thể được sử dụng để thực hiện chức năng giai thừa (xem bên dưới)

Lưu ý rằng

@uri "https://www.google.com/search?q=\(.search)"
57 được định nghĩa nội bộ là hàm jq đệ quy. Các cuộc gọi đệ quy trong
@uri "https://www.google.com/search?q=\(.search)"
63 sẽ không tiêu tốn thêm bộ nhớ nếu
@uri "https://www.google.com/search?q=\(.search)"
59 tạo ra 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

Thí dụ

jq '[. ,1]. cho đến khi(. [0] < 1; . [0] - 1,. [1] *. [0]]). [1]'Input4Output24

@uri "https://www.google.com/search?q=\(.search)" 65, @uri "https://www.google.com/search?q=\(.search)" 66, @uri "https://www.google.com/search?q=\(.search)" 67, @uri "https://www.google.com/search?q=\(.search)" 68

The

@uri "https://www.google.com/search?q=\(.search)"
65 function allows you to search through a recursive structure, and extract interesting data from all levels. Suppose your input represents a filesystem

recurse(.children[]) | .name
90

Bây giờ, giả sử bạn muốn trích xuất tất cả các tên tệp hiện có. Bạn cần truy xuất

@uri "https://www.google.com/search?q=\(.search)"
70,
@uri "https://www.google.com/search?q=\(.search)"
71,
@uri "https://www.google.com/search?q=\(.search)"
72, v.v. You can do this with

recurse(.children[]) | .name

When called without an argument,

@uri "https://www.google.com/search?q=\(.search)"
66 is equivalent to
@uri "https://www.google.com/search?q=\(.search)"
74

@uri "https://www.google.com/search?q=\(.search)"
65 giống hệt với
@uri "https://www.google.com/search?q=\(.search)"
76 và có thể được sử dụng mà không cần lo lắng về độ sâu đệ quy

@uri "https://www.google.com/search?q=\(.search)"
67 là một máy phát điện bắt đầu bằng cách phát ra. and then emits in turn . f, . f. f, . f. f. f,. so long as the computed value satisfies the condition. For example, to generate all the integers, at least in principle, one could write
@uri "https://www.google.com/search?q=\(.search)"
78

Vì những lý do kế thừa,

@uri "https://www.google.com/search?q=\(.search)"
68 tồn tại dưới dạng bí danh để gọi
@uri "https://www.google.com/search?q=\(.search)"
66 mà không có đối số. Bí danh này được coi là không dùng nữa và sẽ bị xóa trong bản phát hành chính tiếp theo

Các cuộc gọi đệ quy trong

@uri "https://www.google.com/search?q=\(.search)"
66 sẽ không tiêu tốn thêm bộ nhớ bất cứ khi nào
recurse(.children[]) | .name
26 tạo ra nhiều nhất một đầu ra cho mỗi đầu vào

ví dụ

jq 'recurse(. foo[])'Input{"foo". [{"foo". []}, {"foo". [{"foo". []}]}]}Đầu ra{"foo". [{"foo". []},{"foo". [{"foo". []}]}]}{"foo". []}{"foo". [{"foo". []}]}{"foo". []}jq 'recurse'Input{"a". 0,"b". [1]}Đầu ra{"a". 0,"b". [1]}0[1]1jq 'recurse(. * . ;. < 20)'Input2Output2416

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

The

@uri "https://www.google.com/search?q=\(.search)"
83 function applies f recursively to every component of the input entity. When an array is encountered, f is first applied to its elements and then to the array itself; when an object is encountered, f is first applied to all the values and then to the object. In practice, f will usually test the type of its input, as illustrated in the following examples. Ví dụ đầu tiên nêu bật tính hữu ích của việc xử lý các phần tử của một mảng các mảng trước khi xử lý chính mảng đó. Ví dụ thứ hai cho thấy cách tất cả các khóa của tất cả các đối tượng trong đầu vào có thể được xem xét để thay đổi

ví dụ

jq 'walk(if type == "array" then sort else . end)'Input[[4, 1, 7], [8, 5, 2], [3, 6, 9]]Output[[1,4,7],[2,5,8],[3, . Chìa khóa. = sub( "^_+"; "") ) else . kết thúc)'Đầu vào [ { "_a". { "__b". 2 } } ]Output[{"a". {"b". 2}}]

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

@uri "https://www.google.com/search?q=\(.search)"
85 là một đối tượng đại diện cho các biến môi trường như đã đặt khi chương trình jq bắt đầu

@uri "https://www.google.com/search?q=\(.search)"
86 outputs an object representing jq's current environment

Hiện tại không có nội dung để đặt biến môi trường

ví dụ

jq '$ENV. PAGER'InputnullOutput"less"jq 'env. PAGER'InputnullOutput"less"

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

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

Thí dụ

jq 'transpose'Input[[1], [2,3]]Output[[1,2],[null,3]]

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

bsearch(x) tiến hành 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ỉ mục của nó trong mảng; . Nếu mảng không được sắp xếp, bsearch(x) sẽ trả về một số nguyên có thể không được quan tâm

ví dụ

jq 'bsearch(0)'Input[0,1]Output0jq 'bsearch(0)'Input[1,2,3]Output-1jq 'bsearch(4) dưới dạng $ix. nếu $ix < 0 thì. [-(1+$ix)] = 4 else . end'Input[1,2,3]Output[1,2,3,4]

Nội suy chuỗi - @uri "https://www.google.com/search?q=\(.search)" 91

Bên trong một chuỗi, bạn có thể đặt một biểu thức bên trong dấu ngoặc đơn sau dấu gạch chéo ngược. Whatever the expression returns will be interpolated into the string

Thí dụ

jq '"Đầu vào là \(. ), which is one less than \(. +1)"'Input42Output"The input was 42, which is one less than 43"

Chuyển đổi sang/từ JSON

The

@uri "https://www.google.com/search?q=\(.search)"
92 and
@uri "https://www.google.com/search?q=\(.search)"
93 builtins dump values as JSON texts or parse JSON texts into values, respectively. Nội trang tojson khác với tostring ở chỗ tostring trả về các chuỗi chưa sửa đổi, trong khi tojson mã hóa các chuỗi dưới dạng các chuỗi JSON

ví dụ

jq '[. []. tostring]'Input[1, "foo", ["foo"]]Output["1","foo","[\"foo\"]"]jq '[. []. tojson]'Input[1, "foo", ["foo"]]Output["1","\"foo\"","[\"foo\"]"]jq '[. []. tojson. fromjson]'Input[1,"foo", ["foo"]]Output[1,"foo",["foo"]]

Format strings and escaping

The

@uri "https://www.google.com/search?q=\(.search)"
94 syntax is used to format and escape strings, which is useful for building URLs, documents in a language like HTML or XML, and so forth.
@uri "https://www.google.com/search?q=\(.search)"
94 có thể được sử dụng riêng như một bộ lọc, khả năng thoát ra là

Cuộc gọi

recurse(.children[]) | .name
78, xem chức năng đó để biết chi tiết

Serializes the input as JSON

Áp dụng thoát HTML/XML, bằng cách ánh xạ các ký tự

@uri "https://www.google.com/search?q=\(.search)"
97 thành các thực thể tương đương của chúng
@uri "https://www.google.com/search?q=\(.search)"
98,
@uri "https://www.google.com/search?q=\(.search)"
99,
recurse(.children[]) | .name
700,
recurse(.children[]) | .name
701,
recurse(.children[]) | .name
702

Á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 chuỗi

recurse(.children[]) | .name
703

Đầ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 bằng cách lặp lại

The input must be an array, and it is rendered as TSV (tab-separated values). Each input array will be printed as a single line. Fields are separated by a single tab (ascii

recurse(.children[]) | .name
704). Input characters line-feed (ascii
recurse(.children[]) | .name
705), carriage-return (ascii
recurse(.children[]) | .name
706), tab (ascii
recurse(.children[]) | .name
704) and backslash (ascii
recurse(.children[]) | .name
708) will be output as escape sequences
recurse(.children[]) | .name
709,
recurse(.children[]) | .name
710,
recurse(.children[]) | .name
711,
recurse(.children[]) | .name
712 respectively

The input is escaped suitable for use in a command-line for a POSIX shell. 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

The input is converted to base64 as specified by RFC 4648

Nghịch đảo của

recurse(.children[]) | .name
713, đầu vào được giải mã theo quy định của RFC 4648. Ghi chú\. Nếu chuỗi đã giải mã không phải là UTF-8, kết quả sẽ không xác định

This syntax can be combined with string interpolation in a useful way. Bạn có thể theo dõi mã thông báo

@uri "https://www.google.com/search?q=\(.search)"
94 bằng một chuỗi ký tự. Nội dung của chuỗi ký tự sẽ không được thoát. Tuy nhiên, tất cả các nội suy được thực hiện bên trong chuỗi ký tự đó sẽ được thoát. Ví dụ,

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

sẽ tạo đầu ra sau cho đầu vào

recurse(.children[]) | .name
715

recurse(.children[]) | .name
7

Lưu ý rằng các dấu gạch chéo, dấu chấm hỏi, v.v. in the URL are not escaped, as they were part of the string literal

ví dụ

jq '@html'Input"This works if x < y"Output"This works if x < y"jq '@sh "echo \(. )"'Input"O'Hara's Ale"Output"echo 'O'\\''Hara'\\''s Ale'"jq '@base64'Input"Đây là tin nhắn"Output"VGhpcyBpcyBhIG1lc3NhZ2U="jq '@

SQL-Style Operators

jq provides a few SQL-style operators

  • INDEX(luồng; biểu_thức_chỉ_số)

This builtin produces an object whose keys are computed by the given index expression applied to each value from the given stream

  • JOIN($idx; stream; idx_expr; join_expr)

This builtin joins the values from the given stream to the given index. The index's keys are computed by applying the given index expression to each value from the given stream. Một mảng giá trị trong luồng và giá trị tương ứng từ chỉ mục được đưa vào biểu thức nối đã cho để tạo ra từng kết quả

  • JOIN($idx; stream; idx_expr)

Tương tự như

recurse(.children[]) | .name
716

Nội trang này nối đầu vào

recurse(.children[]) | .name
510 với chỉ mục đã cho, áp dụng biểu thức chỉ mục đã cho cho
recurse(.children[]) | .name
510 để tính khóa chỉ mục. The join operation is as described above

This builtin outputs

recurse(.children[]) | .name
40 if
recurse(.children[]) | .name
510 appears in the given stream, otherwise it outputs
recurse(.children[]) | .name
43

This builtin outputs

recurse(.children[]) | .name
40 if any value in the source stream appears in the second stream, otherwise it outputs
recurse(.children[]) | .name
43

recurse(.children[]) | .name 724

Trả về danh sách tất cả các hàm dựng sẵn ở định dạng

recurse(.children[]) | .name
725. Vì các chức năng có cùng tên nhưng khác nguồn gốc được coi là các chức năng riêng biệt, nên tất cả các hàm
recurse(.children[]) | .name
726,
recurse(.children[]) | .name
727 và
recurse(.children[]) | .name
728 sẽ có mặt trong danh sách