jq - онлайн у хмарі

ПРОГРАМА:

ІМ'Я

jq - Процесор командного рядка JSON

СИНТАКСИС

jq [опції...] фільтрувати [файли...]

jq може перетворювати JSON різними способами, вибираючи, повторюючи, зменшуючи тощо
переробка документів JSON. Наприклад, запуск команди jq ´map(.price) | додати´ волі
візьміть масив об’єктів JSON як вхідні дані та поверне суму їхніх полів «ціна».

jq також може приймати введення тексту, але за замовчуванням, jq читає потік сутностей JSON
(включаючи числа та інші літерали) від stdin. Пробіли потрібні лише для розділення
сутності, такі як 1 і 2, а також істинні і хибні. Один або кілька файли може бути зазначено, в якому
випадок jq замість цього читатиме введені дані.

Команда опції описані в ЗАКЛЮЧЕННЯ JQ розділ; вони здебільшого стосуються входу та виходу
форматування. фільтрувати написаний мовою jq і вказує, як трансформувати
вхідний файл або документ.

ФІЛЬТРИ

Програма jq є «фільтром»: вона приймає вхідні дані і виробляє вихід. Є багато
вбудовані фільтри для вилучення певного поля об’єкта або перетворення числа в
рядок або інші стандартні завдання.

Фільтри можна комбінувати різними способами - ви можете передати вихід одного фільтра
інший фільтр, або зібрати вихідні дані фільтра в масив.

Деякі фільтри дають кілька результатів, наприклад, є один, який дає всі
елементи його вхідного масиву. Підключення цього фільтра до другого запускає другий фільтр
кожен елемент масиву. Загалом, речі, які можна зробити за допомогою циклів та ітерацій
іншими мовами це робиться шляхом склеювання фільтрів у jq.

Важливо пам’ятати, що кожен фільтр має вхід і вихід. Навіть літерали
як "привіт" або 42 є фільтрами - вони беруть вхідні дані, але завжди виробляють той самий литерал, що і
вихід. Операції, які об’єднують два фільтри, як-от додавання, зазвичай подають один і той же вхід
до обох і поєднати результати. Отже, ви можете реалізувати фільтр усереднення як додавати /
- живлення вхідного масиву як до додавати фільтр і фільтрувати, а потім виконувати
підрозділ.

Але це забігає вперед. :) Почнемо з чогось простішого:

ЗАКЛЮЧЕННЯ JQ

jq-фільтри працюють на потоці даних JSON. Вхід до jq аналізується як послідовність
Розділені пробілами значення JSON, які передаються через наданий фільтр один на a
час. Вихід(и) фільтра записуються в стандартний вихід, знову ж таки як послідовність
дані JSON, розділені пробілами.

Примітка: важливо пам’ятати про правила цитування оболонки. Як правило, найкраще
Завжди цитуйте (з одинарними лапками) програму jq, оскільки із занадто великою кількістю символів
Особливе значення для jq також мають мета-символи оболонки. Наприклад, jq "foo" зазнає невдачі
більшість оболонок Unix, тому що це буде те саме, що jq Foo, що загалом зазнає невдачі
оскільки Foo is НЕ певний. Під час використання командної оболонки Windows (cmd.exe) найкраще
використовуйте подвійні лапки навколо вашої програми jq, коли вона вводиться в командному рядку (замість -f
програмний файл параметр), але тоді подвійні лапки в програмі jq потребують екранування зворотної косої риски.

Ви можете вплинути на те, як jq читає та записує свої вхідні та вихідні дані, використовуючи деякий командний рядок
опції:

· -- версія:

Вивести версію jq і вийти з нулем.

· --наступ:

Використовувати додаток/json-seq Схема типу MIME для розділення текстів JSON у вводі jq
і вихід. Це означає, що символ ASCII RS (роздільник записів) друкується раніше
кожне значення на виводі та ASCII LF (переведення рядка) друкуються після кожного виводу. Вхідні дані
Тексти JSON, які не вдалося проаналізувати, ігноруються (але про них попереджають), усі відкидаються
наступне введення до наступного RS. Це більше також аналізує вихід jq без
--наступ варіант.

· --потік:

Проаналізуйте вхідні дані в потоковому режимі, виводячи масиви значень шляхів і лівої частини
(скаляри і порожні масиви або порожні об'єкти). Наприклад, "A" стає [[],"a"] та
[[],"a",["b"]] стає [[0],[]], [[1],"a"] та [[1,0],"b"].

Це корисно для обробки дуже великих вхідних даних. Використовуйте це разом з
фільтрації та зменшити та для кожного синтаксис для поступового зменшення великих входів.

· -- хлюпання/-s:

Замість того, щоб запускати фільтр для кожного об’єкта JSON у вхідних даних, прочитайте весь вхідний файл
передайте у великий масив і запустіть фільтр лише один раз.

· --raw-введення/-R:

Не аналізуйте введення як JSON. Замість цього кожен рядок тексту передається фільтру як a
рядок. Якщо поєднується з -- хлюпання, тоді весь вхідний сигнал передається фільтру як a
одна довга струна.

· --нульовий вхід/-n:

Взагалі не читайте жодного введення! Натомість фільтр запускається один раз нулю як вхід.
Це корисно під час використання jq як простого калькулятора або для створення даних JSON
нуля.

· -- компактний вихід / -c:

За замовчуванням jq pretty друкує вихідні дані JSON. Використання цієї опції призведе до більше
компактний вихід, замість цього розміщуючи кожен об’єкт JSON в одному рядку.

· --вкладка:

Використовуйте вкладку для кожного рівня відступу замість двох пробілів.

· --відступ n:

Використовуйте вказану кількість пробілів (не більше 8) для відступу.

· --кольоровий вихід / -C та --монохромний вихід / -M:

За замовчуванням jq виводить кольоровий JSON, якщо записує на термінал. Ви можете змусити це
виробляти колір, навіть якщо записувати в канал або файл за допомогою -Cі вимкніть колір за допомогою -M.

· --ascii-вихід / -a:

jq зазвичай виводить кодові точки Unicode, відмінні від ASCII, як UTF-8, навіть якщо вказано
їх як escape-послідовності (наприклад, "\u03bc"). Використовуючи цю опцію, ви можете змусити jq
вивести чистий ASCII-символ із заміною кожного символу, відмінного від ASCII, на еквівалент
вихідна послідовність.

· --небуферизовані

Очищайте вихідні дані після друку кожного об’єкта JSON (корисно, якщо ви передаєте повільно
джерело даних у jq і передача виводу jq в інше місце).

· --клавіші сортування / -S:

Виведіть поля кожного об’єкта з ключами в упорядкованому порядку.

· --сирий вихід / -r:

За допомогою цієї опції, якщо результатом фільтра є рядок, він буде записаний безпосередньо
на стандартний вихід, а не форматований як рядок JSON з лапками. Це може
бути корисним для того, щоб фільтри jq спілкувалися з системами, не заснованими на JSON.

· --приєднання-виведення / -j:

Люблю -r але jq не друкуватиме новий рядок після кожного виводу.

· -f ім'я файлу / --з-файлу ім'я файлу:

Читайте фільтр із файлу, а не з командного рядка, як-от параметр awk -f. ти
також можна використовувати ´#´, щоб коментувати.

· -Lкаталог / -L каталог:

Попередньо каталог до списку пошуку модулів. Якщо використовується ця опція, то ні
використовується вбудований список пошуку. Дивіться розділ про модулі нижче.

· -e / -- статус виходу:

Встановлює статус виходу jq на 0, якщо останні вихідні значення не були жодним false ні нулю,
1, якщо останнє вихідне значення було будь-яким false or нулюабо 4, якщо дійсних результатів не було
вироблено. Зазвичай jq виходить з 2, якщо виникла проблема з використанням або системна помилка, 3
якщо сталася помилка компіляції програми jq, або 0, якщо програма jq запущена.

· --арг ім'я значення:

Ця опція передає значення програмі jq як попередньо визначену змінну. Якщо ви запускаєте jq
з --арг Foo бар, То $foo доступна в програмі і має значення "бар".
Зверніть увагу, що значення буде розглядатися як рядок, тому --арг Foo 123 зв'яже $foo до "123".

· --argjson ім'я JSON-текст:

Ця опція передає закодоване JSON значення до програми jq як попередньо визначену змінну. Якщо
ви запускаєте jq з --argjson Foo 123, То $foo доступний у програмі та має
значення 123.

· --slurpfile ім'я змінної ім'я файлу:

Ця опція читає всі тексти JSON у названому файлі та пов’язує масив файлів
проаналізував значення JSON до заданої глобальної змінної. Якщо ви запускаєте jq з --файл arg Foo бар,
потім $foo доступний у програмі і має масив, елементи якого відповідають
тексти у файлі з іменем бар.

· --файл arg ім'я змінної ім'я файлу:

Не використовувати. Використовуйте --slurpfile замість цього.

(Цей варіант схожий на --slurpfile, але якщо у файлі є лише один текст, то це так
використовується, інакше використовується масив текстів, як у --slurpfile.)

· --виконання тестів [ім'я файлу]:

Виконує тести у заданому файлі або стандартному введенні. Це має бути останній варіант
і не відповідає всім попереднім параметрам. Вхідні дані складаються з рядків коментарів, порожніх
рядків і рядків програми, за якими слідує один рядок введення, стільки рядків виведення
очікуваний (один на вихід) і кінцевий порожній рядок. Тести невдач компіляції
почніть з рядка, що містить лише "%%FAIL", потім рядка, що містить програму для
compile, потім рядок із повідомленням про помилку для порівняння з фактичним.

Зауважте, що цей параметр може змінюватися несумісно.

BASIC ФІЛЬТРИ

.
Абсолютно найпростішим (і найменш цікавим) фільтром є .. Це фільтр, який приймає своє
вхідних даних і видає його незмінним як вихід.

Оскільки jq за замовчуванням досить друкує весь вихід, ця тривіальна програма може бути корисним способом
форматування виводу JSON, скажімо, витися.

jq ´.´
"Привіт Світ!"
=> "Привіт, світ!"

.foo, .foo.bar
Найпростіший корисний фільтр є .foo. Коли надано об’єкт JSON (він же словник або хеш) як
введення, він створює значення за ключем "foo", або нуль, якщо його немає.

Якщо ключ містить спеціальні символи, його потрібно взяти в лапки, наприклад
це: "foo$".

Фільтр форми .foo.bar еквівалентна .foo|.bar.

jq ´.foo´
{"foo": 42, "bar": "менш цікаві дані"}
=> 42

jq ´.foo´
{"notfoo": правда, "alsonotfoo": false}
=> нульовий

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

.foo?
Так само, як .foo, але не виводить навіть помилку, коли . не є масивом чи об’єктом.

jq ´.foo?´
{"foo": 42, "bar": "менш цікаві дані"}
=> 42

jq ´.foo?´
{"notfoo": правда, "alsonotfoo": false}
=> нульовий

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

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

.[[] ], [2], [10:15]
Ви також можете шукати поля об’єкта за допомогою синтаксису, наприклад .["foo"] (.foo вище є a
скорочена версія цього). Це також працює для масивів, якщо ключ є цілим числом.
Масиви засновані на нулях (наприклад, javascript). . [2] повертає третій елемент масиву.

Команда [10:15] Синтаксис можна використовувати для повернення підмасиву масиву або підрядка рядка.
Масив, який повертає [10:15] матиме довжину 5 і містить елементи з індексу 10
(включно) до індексу 15 (включно). Будь-який індекс може бути негативним (у цьому випадку він зараховується
назад від кінця масиву) або пропущено (у цьому випадку він відноситься до початку або
кінець масиву).

Команда . [2] Синтаксис можна використовувати для повернення елемента за заданим індексом. Негативні показники є
дозволено, при цьому -1 відноситься до останнього елемента, -2 відноситься до передостаннього елементу,
і так далі.

Команда .foo Синтаксис працює лише для простих клавіш, тобто ключів, які є буквено-цифровими символами.
.[[] ] працює з клавішами, які містять спеціальні символи, такі як двокрапки та крапки. Для
приклад .["foo::bar"] та .["foo.bar"] працювати поки .foo::bar та .foo.bar не буде.

Команда ? "оператор" також можна використовувати з оператором зрізу, як у [10:15]?, який виводить
значення, де вхідні дані можна розділити.

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

jq ´.[2]´
[{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> нульовий

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

[]
Якщо ви використовуєте .[індекс] синтаксису, але повністю опустіть індекс, він повернеться всі в
елементи масиву. Біг [] з введенням [1,2,3] видасть числа як три
окремі результати, а не як один масив.

Ви також можете використовувати це для об’єкта, і він поверне всі значення об’єкта.

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

jq ´.[]´
[]
=>

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

.[]?
Люблю [], але жодних помилок не буде виведено, якщо . не є масивом чи об’єктом.

,
Якщо два фільтри розділені комою, то вхід буде подано в обидва і туди
буде кілька виходів: по-перше, всі вихідні дані, вироблені лівим виразом, і
тоді всі результати, вироблені правом. Наприклад, фільтрувати .foo, .Кафе, виробляє
як поля "foo", так і поля "bar" як окремі вихідні дані.

jq ´.foo, .bar´
{"foo": 42, "bar": "щось інше", "baz": true}
=> 42, "щось інше"

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

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

|
| Оператор об’єднує два фільтри, передаючи вихід(и) одного зліва в
введення праворуч. Це майже те саме, що труба оболонки Unix, якщо
ти звик до цього.

Якщо той, що ліворуч, дає кілька результатів, буде запущено той, що праворуч
кожен із цих результатів. Отже, вираз [] | .foo отримує поле "foo" кожного
елемент вхідного масиву.

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

ВИДИ І ЗНАЧЕННЯ

jq підтримує той самий набір типів даних, що й JSON - числа, рядки, логічні значення, масиви,
об'єкти (які в JSON-speak є хешами лише з рядковими ключами) і "null".

Логічні значення, null, рядки та числа записуються так само, як і в javascript. Так як
все інше в jq, ці прості значення беруть вхідні дані і виводять вихідні дані - 42 це
дійсний вираз jq, який приймає вхідні дані, ігнорує їх і замість цього повертає 42.

масив будівництво - []
Як і в JSON, [] використовується для побудови масивів, як в [1,2,3]. Елементи масивів можуть
будь-який вираз jq. Збираються всі результати, отримані всіма виразами
в один великий масив. Ви можете використовувати його для створення масиву з відомої кількості значень
(як в [.foo, .bar, .baz]) або «збирати» всі результати фільтра в масив (як
in [.items[].name])

Коли ви зрозумієте оператор ",", ви зможете подивитися на синтаксис масиву jq в іншому
світло: вираз [1,2,3] не використовує вбудований синтаксис для масивів, розділених комами,
але замість цього застосовує [] оператор (збирати результати) до виразу 1,2,3 (який
дає три різні результати).

Якщо у вас є фільтр X що дає чотири результати, потім вираз [X] буде виробляти
єдиний результат, масив із чотирьох елементів.

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

Об'єкти - {}
Як і JSON, {} призначений для побудови об’єктів (він же словників або хешів), як у: {"a": 42,
"б": 17/XNUMX/XNUMX}.

Якщо клавіші «розумні» (усі символи алфавіту), лапки можна залишити.
Значенням може бути будь-який вираз (хоча вам може знадобитися загорнути його в дужки, якщо це
складний), який застосовується до введення виразу {} (запам’ятайте, усі фільтри
мають вхід і вихід).

{foo: .bar}

створить об’єкт JSON {"foo": 42/XNUMX/XNUMX} якщо надано об’єкт JSON {"bar":42, "баз":43}.
Ви можете використовувати це для вибору окремих полів об’єкта: якщо вхідним є об’єкт з
поля "user", "title", "id" і "content", і ви просто хочете "user" і "title", ви можете
запис

{користувач: .user, назва: .title}

Оскільки це так часто, є синтаксис швидкого доступу: {користувач, титул}.

Якщо один із виразів дає кілька результатів, буде кілька словників
вироблено. Якщо вхідні дані

{"user":"stedolan","titles":["JQ Primer", "Більше JQ"]}

потім вираз

{користувач, назва: .titles[]}

дасть два виходи:

{"user":"stedolan", "title": "JQ Primer"}
{"user":"stedolan", "title": "Більше JQ"}

Розміщення ключа в дужках означає, що він буде оцінюватися як вираз. З
той самий вхід, що і вище,

{(.user): .titles}

випускає

{"stedolan": ["JQ Primer", "Більше JQ"]}

jq ´{користувач, заголовок: .titles[]}´
{"user":"stedolan","titles":["JQ Primer", "Більше JQ"]}
=> {"user":"stedolan", "title": "JQ Primer"}, {"user":"stedolan", "title": "Більше JQ"}

jq ´{(.user): .titles}´
{"user":"stedolan","titles":["JQ Primer", "Більше JQ"]}
=> {"stedolan": ["JQ Primer", "Більше JQ"]}

Вбудований ОПЕРАТОРИ І ФУНКЦІЇ

Деякий оператор jq (наприклад, +) роблять різні речі залежно від їх типу
аргументи (масиви, числа тощо). Однак jq ніколи не виконує неявні перетворення типів. Якщо
ви спробуєте додати рядок до об'єкта, ви отримаєте повідомлення про помилку, але результату немає.

Доповнення - +
Оператор + приймає два фільтри, застосовує їх обидва до одного входу та додає
результати разом. Що означає «додавання», залежить від залучених типів:

· Номери додаються звичайною арифметикою.

· Масиви додаються шляхом об’єднання в більший масив.

· Рядки додаються шляхом об’єднання в більший рядок.

· Об'єкти додаються шляхом об’єднання, тобто вставлення всіх пар ключ-значення з обох
об'єктів в єдиний об'єднаний об'єкт. Якщо обидва об’єкти містять однакове значення
ключ, об'єкт праворуч від + перемоги. (Для рекурсивного злиття використовуйте * оператор.)

нулю можна додати до будь-якого значення, а інше значення повертає без змін.

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

Віднімання - -
Як і звичайне арифметичне віднімання чисел, - Оператор можна використовувати для масивів
щоб видалити всі елементи другого масиву з першого масиву.

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

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

множення, поділ, модуль - *, /, та %
Ці інфіксні оператори поводяться належним чином, якщо їм задані два числа. Ділення на нуль підвищує
помилка. x % y обчислює x за модулем y.

Помноження рядка на число призводить до конкатенації цього рядка
раз. "х" * 0 випускає нулю.

Поділ рядка на інший розбиває перший, використовуючи другий як роздільники.

Помноження двох об’єктів призведе до їх рекурсивного злиття: це працює як додавання, але якщо обидва
об’єкти містять значення для одного ключа, а значення є об’єктами, вони об’єднані
з такою ж стратегією.

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

jq ´. / ", "´
"а, б, в, г, д"
=> ["a","b,c,d","e"]

jq ´{"k": {"a": 1, "b": 2}} * {"k": {"a": 0,"c": 3}}´
нулю
=> {"k": {"a": 0, "b": 2, "c": 3}}

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


Вбудована функція отримує довжину різних типів значень:

· Довжина a рядок - кількість кодових точок Unicode, які він містить (яка буде
така ж, як і його довжина, закодована JSON у байтах, якщо це чистий ASCII).

· Довжина an масив - кількість елементів.

· Довжина an об'єкт – кількість пар ключ-значення.

· Довжина нулю дорівнює нулю.

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

ключі, keys_unsorted
Вбудована функція ключі, коли дається об’єкт, повертає його ключі в масиві.

Ключі відсортовані «за алфавітом» за порядком кодових точок Юнікоду. Це не наказ
це має особливий сенс у будь-якій конкретній мові, але ви можете розраховувати на те, що це є
однаково для будь-яких двох об’єктів з однаковим набором ключів, незалежно від налаштувань мовного стандарту.

Коли ключі якщо задано масив, він повертає дійсні індекси для цього масиву: цілі числа
від 0 до довжини-1.

Команда keys_unsorted функція так само, як ключі, але якщо вхід є об’єктом, то ключі
не буде відсортовано, замість цього ключі будуть приблизно в порядку вставки.

jq «клавіші».
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Foo", "abc", "abcd"]

jq «клавіші».
[42,3,35]
=> [0,1,2]

має (ключ)
Вбудована функція має повертає, чи має об’єкт введення даний ключ, чи вхід
масив має елемент із заданим індексом.

має ($ключ) має такий самий ефект, як і перевірка чи $key є членом поверненого масиву
by ключі, Хоча має буде швидше.

jq ´map(has("foo"))´
[{"foo": 42}, {}]
=> [правда, неправда]

jq ´map(має(2))'
[[0,1], ["a","b","c"]]
=> [неправда, правда]

in
Вбудована функція in повертає вхідний ключ у даному об’єкті або вхідний індекс
відповідає елементу в даному масиві. По суті, це зворотна версія
має.

jq ´.[] | in({"foo": 42})´
["foo", "bar"]
=> правда, неправда

jq ´map(in([0,1]))´
[2, 0]
=> [неправда, правда]

шлях (вираз_шляху)
Виводить уявлення масиву заданого виразу шляху .. Вихідними є масиви
рядки (ключі в об’єктах 0 та/або числах (індекси масиву.

Вирази шляху - це вирази jq .a, Але і []. Існує два типи шляхів
вирази: ті, які можуть точно збігатися, і ті, які ні. Наприклад, .abc є
точна відповідність виразу шляху, while .a[].b не.

шлях(точний_шлях_вираз) створить представлення масиву виразу шляху
навіть якщо він не існує в ., Якщо . is нулю або масив або об'єкт.

шлях (шаблон) створить представлення масивів шляхів, що відповідають модель якщо
шляхи існують в ..

Зауважте, що вирази шляху не відрізняються від звичайних виразів. Вираз
шлях(..|select(type=="boolean")) виводить всі шляхи до логічних значень у ., і тільки
ті шляхи.

jq ´шлях(.a[0].b)´
нулю
=> ["a",0,"b"]

jq ´[шлях(..)]´
{"a":[{"b":1}]}
=> [[],["a"],["a",0],["a",0,"b"]]

del (вираз_шляху)
Вбудована функція Дель видаляє ключ і відповідне йому значення з об’єкта.

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

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

to_entries, from_entries, with_entries
Ці функції здійснюють перетворення між об’єктом і масивом пар ключ-значення. Якщо до_записів
передається об’єкт, потім для кожного k: v запис у вхідному, вихідний масив включає
{"ключ": k, "цінність": v}.

із_записів здійснює протилежне перетворення, і with_entries(foo) - це стенограма для
до_записів | карта (foo) | із_записів, корисний для виконання деяких операцій з усіма клавішами і
значення об'єкта. із_записів приймає ключ, ключ, ім’я, значення та значення як ключі.

jq «до_записів».
{"a": 1, "b": 2}
=> [{"key":"a", "value":1}, {"key":"b", "value":2}]

jq «з_записів».
[{"key":"a", "value":1}, {"key":"b", "value":2}]
=> {"a": 1, "b": 2}

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

вибрати (логічний_вираз)
Функція вибрати (foo) видає свій вхід незмінним, якщо Foo повертає true для цього входу,
і не дає жодного результату в іншому випадку.

Це корисно для фільтрації списків: [1,2,3] | карта (вибрати (. >= 2)) дасть вам [2,3].

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

jq ´.[] | select(.id == "другий")´
[{"id": "перший", "val": 1}, {"id": "другий", "val": 2}]
=> {"id": "другий", "val": 2}

масиви, об'єкти, ітерації, логічні значення, номери, нормальні, кінцеві, струни, нульові значення, значення,
скалярів
Ці вбудовані модулі вибирають лише вхідні дані, які є масивами, об’єктами, ітераторами (масивами або
об'єкти), логічні значення, числа, нормальні числа, скінченні числа, рядки, нульові значення, ненульові
значення та неітеровані відповідно.

jq ´.[]|числа´
[[],{},1,"foo",null,true,false]
=> 1

порожній
порожній не повертає результатів. Взагалі жодного. Навіть не нулю.

Це корисно іноді. Ви дізнаєтесь, чи потрібно це :)

jq ´1, порожній, 2´
нулю
=> 1, 2

jq ´[1,2,пусто,3]´
нулю
=> [1,2,3]

помилка(повідомлення)
Видає помилку, як .a застосовується до значень, відмінних від null, а об’єкти будуть, але
із зазначеним повідомленням як значенням помилки.

$__loc__
Створює об’єкт із ключем «файл» і ключем «рядок», з ім’ям файлу та номером рядка
де $__loc__ зустрічається як значення.

jq ´пробувати помилку("\($__loc__)") catch .´
нулю
=> "{\"файл\":\" \",\"рядок\":1}"

карта (x), map_values(x)
Для будь-якого фільтра x, карта (x) запустить цей фільтр для кожного елемента вхідного масиву, і
вивести новий масив. карта (.+1) збільшуватиме кожен елемент масиву
числа.

Крім того, map_values(x) запустить цей фільтр для кожного елемента, але поверне an
об’єкт, коли об’єкт передається.

карта (x) еквівалентна [[] | x]. Насправді це так і визначається. так само,
map_values(x) визначається як [] |= x.

jq «карта (.+1)».
[1,2,3]
=> [2,3,4]

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

шляхи, шляхи (node_filter), leaf_paths
стежки виводить шляхи до всіх елементів у вхідних даних (за винятком того, що він не виводить файл
порожній список, що представляє . сама по собі).

шляхи (f) виводить шляхи до будь-яких значень, для яких f правда. Тобто, шляхи (числа)
виводить шляхи до всіх числових значень.

leaf_paths є псевдонімом шляхи (скаляри); leaf_paths is не підтримується і буде видалено в
наступний великий випуск.

jq ´[шляхи]´
[1,[[],{"a":2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]

jq ´[шляхи(скаляри)]´
[1,[[],{"a":2}]]
=> [[0],[1,1,"a"]]

додавати
Фільтр додавати приймає в якості вхідних даних масив і видає елементи масиву як вихідні дані
складені разом. Це може означати підсумовування, об’єднання або злиття залежно від типів
елементи вхідного масиву - правила такі ж, як і для + оператор
(описано вище).

Якщо вхідним є порожній масив, додавати Умови повернення нулю.

jq «додати».
["a","b","c"]
=> "abc"

jq «додати».
[1, 2, 3]
=> 6

jq «додати».
[]
=> нульовий

будь-який, будь-який (умова), будь-який (генератор; хвороба)
Фільтр будь-який приймає як вхідний масив логічних значень і створює правда як вихід, якщо
будь-який з елементів масиву є правда.

Якщо вхідним є порожній масив, будь-який Умови повернення false.

Команда будь-який (умова) form застосовує задану умову до елементів вхідного масиву.

Команда будь-який (генератор; хвороба) форма застосовує задану умову до всіх виходів
даний генератор.

jq «будь-який».
[правда, неправда]
=> правда

jq «будь-який».
[неправда, неправда]
=> хибно

jq «будь-який».
[]
=> хибно

все, все (умова), все (генератор; хвороба)
Фільтр всі приймає як вхідний масив логічних значень і створює правда як вихід, якщо
всі елементи масиву є правда.

Команда все (умова) form застосовує задану умову до елементів вхідного масиву.

Команда все (генератор; хвороба) форма застосовує задану умову до всіх виходів
даний генератор.

Якщо вхідним є порожній масив, всі Умови повернення правда.

jq ´всі´
[правда, неправда]
=> хибно

jq ´всі´
[правда-правда]
=> правда

jq ´всі´
[]
=> правда

[Вимагає 1.5] сплющити, сплющити (глибина)
Фільтр сплющити приймає як вхідні дані масив вкладених масивів і створює плоский масив
всі масиви всередині вихідного масиву були рекурсивно замінені своїми значеннями.
Ви можете передати йому аргумент, щоб указати, скільки рівнів вкладеності потрібно вирівняти.

сплющити(2) це як сплющити, але піднявшись лише до двох рівнів глибини.

jq «зрівняти».
[1, [2], [[3]]]
=> [1, 2, 3]

jq ´сплющити(1)´
[1, [2], [[3]]]
=> [1, 2, [3]]

jq «зрівняти».
[[]]
=> []

jq «зрівняти».
[{"foo": "bar"}, [{"foo": "baz"}]]
=> [{"foo": "bar"}, {"foo": "baz"}]

діапазон (до), діапазон (від;до) діапазон (від;до;по)
Команда діапазон функція створює діапазон чисел. діапазон (4;10) видає 6 чисел, з 4
(включно) до 10 (виключно). Цифри виробляються як окремі виходи. Використовуйте
[діапазон(4;10)] щоб отримати діапазон у вигляді масиву.

Форма з одним аргументом генерує числа від 0 до заданого числа з приростом
1.

Форма з двома аргументами генерує числа з від до аж до із збільшенням 1.

Форма трьох аргументів генерує числа від до аж до з приростом на by.

jq ´діапазон(2;4)´
нулю
=> 2, 3

jq ´[діапазон(2;4)]´
нулю
=> [2,3]

jq ´[діапазон(4)]´
нулю
=> [0,1,2,3]

jq ´[діапазон(0;10;3)]´
нулю
=> [0,3,6,9]

jq ´[діапазон(0;10;-1)]´
нулю
=> []

jq ´[діапазон(0;-5;-1)]´
нулю
=> [0,-1,-2,-3,-4]

пол
Команда пол функція повертає поверхню свого числового введення.

jq «підлога».
3.14159
=> 3

кв
Команда кв функція повертає квадратний корінь її числового введення.

jq ´sqrt´
9
=> 3

номер тону
Команда номер тону функція аналізує свій вхід як число. Він перетворить у правильному форматі
рядків до їх числового еквіваленту, залиште числа в спокої і вкажіть помилку для всіх інших
Вхід

jq ´.[] | номер тону´
[1, "1"]
=> 1, 1

tostring
Команда tostring функція друкує свій вхід у вигляді рядка. Рядки залишаються без змін, і все
інші значення закодовані JSON.

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

тип
Команда тип функція повертає тип свого аргументу у вигляді рядка, який має значення null,
логічне значення, число, рядок, масив або об'єкт.

jq «карта (тип)».
[0, false, [], {}, null, "привіт"]
=> ["число", "логічне значення", "масив", "об'єкт", "нуль", "рядок"]

нескінченний, нан, нескінченний, Існан, нескінченний, ненормально
Деякі арифметичні операції можуть давати нескінченність і значення «не число» (NaN). The
нескінченний вбудований повертає правда якщо його вхід нескінченний. The існан вбудований повертає правда
якщо його вхідним є NaN. The нескінченний вбудована повертає позитивне нескінченне значення. The бабуся
вбудований повертає NaN. The ненормально Вбудована повертає значення true, якщо введене звичайне число.

Зверніть увагу, що ділення на нуль викликає помилку.

На даний момент більшість арифметичних операцій, що працюють над нескінченностями, NaN і субнормальними, не виконують
підняти помилки.

jq ´.[] | (нескінченна * .) < 0´
[-1, 1]
=> правда, неправда

jq ´нескінченний, nan | тип´
нулю
=> "число", "число"

сортувати, сортувати за (вираз_шляху)
Команда сортувати functions сортує вхідні дані, які мають бути масивом. Значення сортуються в
наступний порядок:

· нулю

· false

· правда

· числа

· рядки в алфавітному порядку (за значенням кодової точки Unicode)

· масиви, у лексичному порядку

· об'єкти

Упорядкування об’єктів дещо складне: спочатку їх порівнюють, порівнюючи їх
набори ключів (як масиви в упорядкованому порядку), і якщо їх ключі рівні, то значення є
порівнювати ключ за ключем.

сортувати може використовуватися для сортування за певним полем об’єкта або шляхом застосування будь-якого фільтра jq.

sort_by (foo) порівнює два елементи, порівнюючи результат Foo на кожному елементі.

jq «сортувати».
[8,3,нуль,6]
=> [null,3,6,8]

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

group_by (вираз_шляху)
group_by(.foo) приймає як вхідний масив масив, групує елементи, що мають однакові .foo поле
на окремі масиви і створює всі ці масиви як елементи більшого масиву,
відсортований за значенням .foo поле.

Будь-який вираз jq, а не просто доступ до поля, може використовуватися замість .foo. Сортування
порядок такий же, як описано в сортувати функція вище.

jq ´group_by(.foo)´
[{"foo":1, "bar":10}, {"foo":3, "bar":100}, {"foo":1, "bar":1}]
=> [[{"foo":1, "bar":10}, {"foo":1, "bar":1}], [{"foo":3, "bar":100}]]

min, max, min_by(path_exp), max_by(path_exp)
Знайдіть мінімальний або максимальний елемент вхідного масиву.

Команда min_by(path_exp) та max_by(path_exp) функції дозволяють вказати певну
поле або властивість для перевірки, напр min_by(.foo) знаходить предмет з найменшим Foo
поле.

jq ´хв´
[5,4,2,7]
=> 2

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

унікальний, унікальний_за (шлях_дослідження)
Команда створеного функція приймає в якості вхідних даних масив і створює масив з тих самих елементів, in
відсортований порядок, з вилученими дублікатами.

Команда унікальний_за (шлях_дослідження) функція зберігатиме лише один елемент для кожного значення, отриманого
застосування аргументу. Думайте про це як створення масиву, вилучаючи по одному елементу з кожного
група виробництва група.

jq «унікальний».
[1,2,5,3,5,3,1,3]
=> [1,2,3,5]

jq ´unique_by(.foo)´
[{"foo": 1, "bar": 2}, {"foo": 1, "bar": 3}, {"foo": 4, "bar": 5}]
=> [{"foo": 1, "bar": 2}, {"foo": 4, "bar": 5}]

jq ´unique_by (довжина)´
["коренят", "бекон", "кошеня", "цикада", "спаржа"]
=> ["бекон", "кусняшка", "спаржа"]

зворотний
Ця функція повертає масив.

jq «зворотний».
[1,2,3,4]
=> [4,3,2,1]

містить (елемент)
Фільтр містить (b) видасть true, якщо b повністю міститься у вхідних даних. А
рядок B міститься в рядку A, якщо B є підрядком A. Масив B міститься в
масив A, якщо всі елементи в B містяться в будь-якому елементі в A. Об’єкт B є
міститься в об’єкті A, якщо всі значення в B містяться у значенні в A з
той самий ключ. Всі інші типи вважаються такими, що містяться один в одному, якщо вони рівні.

jq ´містить("бар")´
"foobar"
=> правда

jq ´містить(["baz", "bar"])´
["foobar", "foobaz", "blarp"]
=> правда

jq ´містить(["bazzzzz", "bar"])´
["foobar", "foobaz", "blarp"]
=> хибно

jq ´містить({foo: 12, bar: [{barp: 12}]})´
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> правда

jq ´містить({foo: 12, bar: [{barp: 15}]})´
{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}
=> хибно

індекси
Виводить масив, що містить індекси в . де s відбувається. Вхідним може бути масив, in
який випадок, якщо s є масивом, то на виході будуть індекси, де всі елементи в .
відповідати тим з s.

jq ´індекси(", ")´
"a, b, cd, efg, hijk"
=> [3,7,12]

jq ´індекси(1)´
[0,1,2,1,3,1,4]
=> [1,3,5]

jq ´індекси([1,2])´
[0,1,2,3,1,4,2,5,1,2,6,7]
=> [1,8]

індекс(и), індекс(и)
Виводить індекс першого (індекс) або останній (індекс) поява s у вхідному.

jq ´індекс(", ")´
"a, b, cd, efg, hijk"
=> 3

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

всередині
Фільтр всередині (b) видасть true, якщо вхідні дані повністю містяться в b. Це
є, по суті, зворотною версією містить.

jq ´inside("foobar")´
"бар"
=> правда

jq ´inside(["foobar", "foobaz", "blarp"])´
["баз", "бар"]
=> правда

jq ´inside(["foobar", "foobaz", "blarp"])´
["bazzzzz", "бар"]
=> хибно

jq ´inside({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"foo": 12, "bar": [{"barp": 12}]}
=> правда

jq ´inside({"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]})´
{"foo": 12, "bar": [{"barp": 15}]}
=> хибно

починається з(str)
Виходи правда якщо . починається з заданого рядкового аргументу.

jq ´[.[]|startswith("foo")]´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [неправда, правда, неправда, правда, неправда]

закінчується (str)
Виходи правда якщо . закінчується заданим рядковим аргументом.

jq ´[.[]|endswith("foo")]´
["foobar", "barfoo"]
=> [неправда, правда]

комбінації, комбінації (n)
Виводить всі комбінації елементів масивів у вхідному масиві. Якщо дано
аргумент n, він виводить усі комбінації n повторення вхідного масиву.

jq «комбінації».
[[1,2], [3, 4]]
=> [1, 3], [1, 4], [2, 3], [2, 4]

jq ´комбінації(2)´
[0, 1]
=> [0, 0], [0, 1], [1, 0], [1, 1]

ltrimstr(str)
Виводить свій вхід з видаленим рядком префікса, якщо він починається з нього.

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

rtrimstr(str)
Виводить свій вхідний рядок із вилученим суфіксом, якщо він на нього закінчується.

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

вибухнути
Перетворює вхідний рядок у масив чисел кодових точок рядка.

jq «вибухнути».
"foobar"
=> [102,111,111,98,97,114]

імплоду
Зворотне значення explode.

jq «вибухнути».
[65, 66, 67]
=> "ABC"

розкол
Розділяє вхідний рядок на аргумент роздільника.

jq ´split(", ")´
"а, б, в, г, е, "
=> ["a","b,c,d","e",""]

приєднатися (str)
Об’єднує масив елементів, поданих як вхідні дані, використовуючи аргумент як роздільник. Це
зворотний до розкол: тобто біг split("foo") | join("foo") над будь-яким вхідним рядком
повертає вказаний вхідний рядок.

jq ´join(", ")´
["a","b,c,d","e"]
=> "а, б, в, г, е"

ascii_downcase, ascii_upcase
Створіть копію вхідного рядка з його алфавітними символами (az і AZ), перетвореними в
зазначений випадок.

while(cond; оновлення)
Команда while(cond; оновлення) Функція дозволяє багаторазово застосовувати оновлення до . до кондиц
неправдиво.

Зверніть увагу, що while(cond; оновлення) внутрішньо визначається як рекурсивна функція jq. Рекурсивний
дзвінки всередині в той час як не буде споживати додаткову пам'ять, якщо оновлення виробляє не більше одного
вихід для кожного входу. Дивіться розширені теми нижче.

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

доки (cond; наступний)
Команда доки (cond; наступний) функція дозволяє багаторазово застосовувати вираз наступний,
спочатку до . потім до власного виходу, поки кондиц правда. Наприклад, цим можна скористатися
для реалізації факторної функції (див. нижче).

Зверніть увагу, що доки (cond; наступний) внутрішньо визначається як рекурсивна функція jq. Рекурсивний
дзвінки всередині поки() не буде споживати додаткову пам'ять, якщо наступний виробляє не більше одного
вихід для кожного входу. Дивіться розширені теми нижче.

jq ´[.,1]|доки(.[0] < 1; [.[0] - 1, .[1] * .[0]])|.[1]´
4
=> 24

рекурс (f), повторення, рекурс (f; хвороба), recurse_down
Команда рекурс (f) функція дозволяє здійснювати пошук у рекурсивній структурі та витягувати
цікаві дані з усіх рівнів. Припустимо, що введені дані представляють файлову систему:

{"ім'я": "/", "діти": [
{"ім'я": "/ bin", "діти": [
{"ім'я": "/bin/ls", "діти": []},
{"ім'я": "/ Бен / ш", "діти": []}]},
{"ім'я": "/ Головна", "діти": [
{"ім'я": "/home/stephen", "діти": [
{"ім'я": "/home/stephen/jq", "діти": []}]}]}]}

Тепер припустимо, що ви хочете витягти всі наявні імена файлів. Вам потрібно отримати . Ім'я,
.діти[].ім'я, .children[].children[].name, і так далі. Ви можете зробити це за допомогою:

recurse(.children[]) | .ім'я

Коли дзвонять без суперечок, рецидивувати еквівалентна рекурс (.[]?).

рекурс (f) тотожне рекурс (f; . != нуль) і можна використовувати без побоювань щодо
глибина рекурсії.

рекурс (f; хвороба) є генератором, який починається з випромінювання . а потім випромінює по черзі
.|f, .|f|f, .|f|f|f, ... до тих пір, поки обчислене значення задовольняє умову. Для
Наприклад, щоб генерувати всі цілі числа, принаймні в принципі, можна було б написати рекурсія(.+1;
правда).

З причин спадщини, recurse_down існує як псевдонім для виклику рецидивувати без аргументів.
Цей псевдонім вважається не підтримується і буде видалено в наступному великому випуску.

Рекурсивний виклик рецидивувати не споживатиме додаткової пам'яті f виробляє на
більшість вихідних даних для кожного входу.

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

jq «рекурс».
{"a":0,"b":[1]}
=> {"a":0,"b":[1]}, 0, [1], 1

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

..
Скорочений для рецидивувати без аргументів. Це має бути схоже на XPath //
оператор. Зауважте, що ..а не працює; використання ..|а замість цього. У наведеному нижче прикладі ми використовуємо
..|.a? щоб знайти всі значення ключів об'єктів "a" в будь-якому об'єкті, знайденому "нижче" ..

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

env
Виводить об'єкт, що представляє середовище jq.

jq ´env.PAGER´
нулю
=> "менше"

транспонувати
Транспонувати, можливо, нерівну матрицю (масив масивів). Рядки заповнюються нульовими значеннями, щоб
результат завжди прямокутний.

jq «транспонувати».
[[1], [2,3]]
=> [[1,2],[null,3]]

пошук (x)
bsearch(x) виконує двійковий пошук x у вхідному масиві. Якщо вхідні дані відсортовані і
містить x, то bsearch(x) поверне свій індекс у масиві; інакше, якщо масив є
відсортований, він поверне (-1 - ix), де ix є точкою вставки, так що масив буде
все ще буде відсортовано після вставки x у ix. Якщо масив не відсортований, bsearch(x)
поверне ціле число, яке, ймовірно, не цікавить.

jq ´bsearch(0)´
[0,1]
=> 0

jq ´bsearch(0)´
[1,2,3]
=> -1

jq ´bsearch(4) як $ix | якщо $ix < 0, то .[-(1+$ix)] = 4 else . кінець´
[1,2,3]
=> [1,2,3,4]

рядок інтерполяція - \(фу)
Усередині рядка можна помістити вираз у круглі дужки після зворотної косої риски. Незалежно від того
Повернення виразу буде інтерпольовано в рядок.

jq ´"Вхідні дані були \(.), що на одиницю менше, ніж \(.+1)"´
42
=> "Введено 42, що на один менше 43"

Конвертувати до / з JSON
Команда tojson та fromjson вбудовані дампують значення як тексти JSON або аналізують тексти JSON
цінності, відповідно. Вбудована функція tojson відрізняється від tostring тим, що повертає tostring
рядки незмінені, тоді як tojson кодує рядки як рядки JSON.

jq ´[.[]|торядок]´
[1, "foo", ["foo"]]
=> ["1","foo","[\"foo\"]"]

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

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

сформований струни та втеча
Команда @foo синтаксис використовується для форматування та екранування рядків, що корисно для створення URL-адрес,
документи такими мовами, як HTML або XML тощо. @foo можна використовувати як фільтр на
власні, можливі втечі:

@текст:

Виклики tostring, дивіться цю функцію для деталей.

@json:

Серіалізує вхід як JSON.

@html:

Застосовує екранування HTML/XML шляхом зіставлення символів <>&´" до свого суб'єкта
еквіваленти <, >, &, ', ".

@uri:

Застосовує відсоткове кодування, зіставляючи всі зарезервовані символи URI на a %XX послідовність.

@csv:

Вхідні дані мають бути масивом і відображаються як CSV з подвійними лапками для
рядки та лапки, які не повторюються.

@tsv:

Вхідні дані мають бути масивом і відображаються як TSV (значення, розділені табуляторами). Кожен
вхідний масив буде надруковано як один рядок. Поля розділені однією вкладкою
(ascii 0x09). Символи введення рядка (ascii 0x0a), каретка-повернення (ascii
0x0d), вкладка (ascii 0x09) і зворотну косу риску (ascii 0x5c) буде виведено як вихід
послідовності \n, \r, \t, \\ відповідно.

@sh:

Вхідні дані екрануються, придатні для використання в командному рядку для оболонки POSIX. Якщо
вхід – це масив, а на виході буде серія рядків, розділених пробілом.

@base64:

Вхідні дані перетворюються на base64, як зазначено в RFC 4648.

Цей синтаксис можна поєднати з інтерполяцією рядків у корисний спосіб. Ви можете стежити за а
@foo маркер із рядковим літералом. Вміст рядкового літералу буде НЕ втекти.
Однак усі інтерполяції, зроблені всередині цього рядкового літералу, будуть екрановані. Наприклад,

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

видасть наступний вихід для входу {"search":"що is jq?"}:

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

Зауважте, що косі риски, знак питання тощо в URL-адресі не екрануються, оскільки вони були частиною
рядкового літералу.

jq ´@html´
"Це працює, якщо x < y"
=> "Це працює, якщо x < y"

jq ´@sh "ехо \(.)"´
"О'Хара'с Ель"
=> "echo ´O´\\´´Hara´\\´´s Ale´"

Дати
jq надає деякі основні функції обробки дати, з деякими високорівневими та низькорівневими
вбудовані. У всіх випадках ці вбудовані модулі мають справу виключно з часом у UTC.

Команда від dateiso8601 вбудований аналізує дату і час у форматі ISO 8601 до кількості секунд
з епохи Unix (1970-01-01T00:00:00Z). The сьогодні iso8601 вбудована робить зворотне.

Команда від дати вбудований аналізує рядки дати і часу. Наразі від дати підтримує лише ISO 8601
рядки datetime, але в майбутньому він намагатиметься розібрати рядки datetime в більшій кількості
форматах.

Команда сьогодні вбудований є псевдонімом для сьогодні iso8601.

Команда зараз вбудована виводить поточний час у секундах з епохи Unix.

Також надаються низькорівневі інтерфейси jq до функцій часу бібліотеки C: strptime,
strftime, mktime та gmtime. Зверніться до документації вашої операційної системи
рядки формату, які використовуються strptime та strftime. Примітка: вони не обов’язково є стабільними
інтерфейси в jq, зокрема щодо їхньої функціональності локалізації.

Команда gmtime вбудована споживає кілька секунд з часів епохи Unix і виводить "зламаний
простою» представлення часу у вигляді масиву чисел, що представляють (у такому порядку):
рік, місяць (з нуля), день місяця, година доби, хвилина
годину, секунду хвилини, день тижня і день року - все
на одній основі, якщо не зазначено інше.

Команда mktime вбудований споживає "розбитий час" уявлення часу, що виводиться gmtime
та strptime.

Команда strptime(fmt) Вбудований аналізує вхідні рядки, що відповідають fmt аргумент. Вихід входить
уявлення "зламаного часу", яке споживає gmtime і вивести шляхом mktime.

Команда strftime(fmt) вбудований форматує час із заданим форматом.

Рядки формату для strptime та strftime описані в типовій бібліотеці C
документація. Рядок формату для ISO 8601 datetime є "%Y-%m-%dT%H:%M:%SZ".

jq може не підтримувати деякі або всі ці функції дати в деяких системах.

jq «від дати».
"2015-03-05T23:51:47Z"
=> 1425599507

jq ´strptime("%Y-%m-%dT%H:%M:%SZ")´
"2015-03-05T23:51:47Z"
=> [2015,2,5,23,51,47,4,63]

jq ´strptime("%Y-%m-%dT%H:%M:%SZ")|mktime´
"2015-03-05T23:51:47Z"
=> 1425599507

УМОВИ І ПОРІВНЯННЯ

==, !=
Вираз ´a == b´ виведе ´true´, якщо результати a та b рівні (тобто,
якщо вони представляють еквівалентні документи JSON) і «false» в іншому випадку. Зокрема, струни
ніколи не вважаються рівними числам. Якщо ви використовуєте Javascript, jq´s == схоже
Javascript´s === - значення вважають рівними лише тоді, коли вони мають однаковий тип
те саме значення.

!= "не дорівнює", а ´a != b´ повертає протилежне значення ´a == b´

jq ´.[] == 1´
[1, 1.0, "1", "банан"]
=> правда, правда, неправда, неправда

якщо-то-інше
if A потім B ще C кінець буде діяти так само, як B if A створює значення, відмінне від false або
нульові, але діють так само, як C інакше.

Перевірка на false або null є більш простим поняттям "істинність", ніж в Javascript
або Python, але це означає, що іноді вам доведеться більш чітко говорити про умову
ви хочете: ви не можете перевірити, чи є, наприклад, рядок порожнім, використовуючи if . Ім'я потім A ще B кінець,
вам знадобиться щось більше схоже if (.ім'я | довжина) > 0 потім A ще B кінець замість цього.

Якщо умова A дає кілька результатів, вона вважається «істинною», якщо будь-який з них
результати не є помилковими або нульовими. Якщо результат нульовий, це вважається хибним.

Більше випадків можна додати до якщо використовується Еліф A потім B синтаксис

jq ´якщо . == 0 тоді

"нульова" elif . == 1 потім "один", інакше "багато" закінчується´ 2 => "багато"

>, >=, <=, <
Оператори порівняння >, >=, <=, < повернути, чи є їхній лівий аргумент більшим за,
більше або дорівнює, менше або дорівнює або менше їхнього правильного аргументу
(відповідно).

Порядок такий самий, як описано для сортувати, вище.

jq ´. < 5´
2
=> правда

та/або/ні
jq підтримує звичайні логічні оператори та/або/ні. У них однаковий стандарт істини
ніби вирази - false і null вважаються "помилковими значеннями", а все інше - це a
«справжня вартість».

Якщо операнд одного з цих операторів дає кілька результатів, сам оператор
видасть результат для кожного введення.

НЕ насправді є вбудованою функцією, а не оператором, тому вона називається фільтром до
які речі можна передавати по конвейеру, а не за допомогою спеціального синтаксису, як в .foo та .Кафе | НЕ.

Ці три створюють лише значення "true" і "false", і тому корисні лише для справжніх
Булеві операції, а не звичайна ідіома Perl/Python/Ruby
"value_that_may_be_null або default". Якщо ви хочете використовувати цю форму «або», вибирайте між
два значення, а не оцінювання умови, див. оператор "//" нижче.

jq ´42 і "рядок"´
нулю
=> правда

jq ´(істинно, хибно) або false´
нулю
=> правда, неправда

jq ´(правда, правда) і (правда, неправда)´
нулю
=> правда, неправда, правда, неправда

jq ´[правда, неправда | ні]´
нулю
=> [неправда, правда]

Alternative оператор - //
Фільтр форми a // b дає ті ж результати, що і a, Якщо a дає результати інші
ніж false та нулю. Інакше a // b дає ті ж результати, що і b.

Це корисно для надання значень за замовчуванням: .foo // 1 оцінюватиме до 1 якщо немає .foo
елемент у вході. Це схоже на те, як or іноді використовується в Python (jq´s or оператор
зарезервовано для строго булевих операцій).

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

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

спробувати-зловити
Помилки можна виявити за допомогою намагатися EXP зловити EXP. Виконується перший вираз, а якщо
він не вдається, тоді виконується другий із повідомленням про помилку. Вихід обробника, якщо
any, виводиться так, ніби це був висновок виразу для спроби.

Команда намагатися EXP використання форми порожній як обробник винятків.

jq «спробуйте .a catch «. не є об'єктом»´
правда
=> ". не є об'єктом"

jq ´[.[]|спробуйте .a]´
[{}, правда, {"a":1}]
=> [нуль, 1]

jq ´пробувати помилку("деяке виключення") catch .´
правда
=> "деяке виключення"

Розрив з of контроль структур
Зручне використання try/catch – це вийти з-під контролю структур, наприклад зменшити, для кожного,
в той час як, І так далі.

Наприклад:

# Повторюйте вираз до тих пір, поки він не викличе слово "break".
# помилка, а потім припиніть повторення без повторного виклику помилки.
# Але якщо спіймана помилка не є "break", то повторіть її.
спробуйте repeat(exp) catch .=="break" then empty else error;

jq має синтаксис для іменованих лексичних міток для "розриву" або "повернення (назад) до":

мітка $out | ... вирватися ...

Команда перерву $label_name вираз призведе до того, що програма буде діяти як найближчий
(зліва) етикетка $label_name вироблений порожній.

Відносини між перерву і відповідний етикетка є лексичним: ярлик має бути
«видимий» з розриву.

Щоб вирватися з a зменшити, наприклад:

мітка $out | зменшити .[] як $item (нуль; якщо .==false, то розірвати $out else ... end)

Наступна програма jq видає синтаксичну помилку:

вирватися $out

тому що немає етикетки $ out видно.

? оператор
Команда ? оператор, використовується як EXP?, є скороченням від намагатися EXP.

jq ´[.[]|(.a)?]´
[{}, правда, {"a":1}]
=> [нуль, 1]

РЕГУЛЯРНА ВИРАЗИ (PCRE)

jq використовує бібліотеку регулярних виразів Oniguruma, як і php, ruby, TextMate, Sublime Text,
тощо, тому опис тут буде зосереджено на особливостях jq.

Фільтри регулярних виразів jq визначені так, що їх можна використовувати за допомогою одного з цих шаблонів:

STRING | ФІЛЬТР (РЕГУЛЬНИЙ ВИРАЖЕНЬ)
STRING | FILTER( REGEX; FLAGS)
STRING | ФІЛЬТР ( [РЕГ. ВЕКСИ] )
STRING | ФІЛЬТР( [РЕГІСТРАЦІЙНИЙ вираз, прапори] )

де: * STRING, REGEX і FLAGS є рядками jq і підлягають інтерполяції рядків jq; *
REGEX після інтерполяції рядка має бути дійсним регулярним виразом PCRE; * ФІЛЬТР є одним із тест,
матчабо захоплення, як описано нижче.

FLAGS — це рядок, що складається з одного з кількох підтримуваних прапорів:

· g - Глобальний пошук (знайти всі збіги, а не тільки перше)

· i - Пошук без урахування регістру

· m - Багаторядковий режим (´.´ буде відповідати новим рядкам)

· n - Ігноруйте порожні сірники

· p - Увімкнено режими s і m

· s - Режим однієї лінії (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - Знайдіть максимально довгі збіги

· x - Розширений формат регулярного виразу (ігнорувати пробіли та коментарі)

Щоб узгодити пробіли у шаблоні x, використовуйте escape, наприклад \s, наприклад

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

Зауважте, що певні прапори також можуть бути вказані в REGEX, наприклад

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

оцінює як: істина, правда, неправда, хибна.

[Вимагає 1.5] тест (val), тест (регулярний вираз; прапори)
Люблю матч, але не повертає лише об’єкти відповідності правда or false для того, чи ні
регулярний вираз відповідає введеному.

jq ´test("foo")´
"foo"
=> правда

jq ´.[] | test("abc # пробіли ігноруються"; "ix")´
["xabcd", "ABC"]
=> правда, правда

[Вимагає 1.5] матч(val), відповідність (регулярний вираз; прапори)
матч виводить об’єкт для кожного знайденого збігу. Матчі мають такі поля:

· зсув - зміщення в кодових точках UTF-8 від початку введення

· - довжина в кодових точках UTF-8 матчу

· рядок - рядок, якому він відповідав

· захвати - масив об'єктів, що представляють групи захоплення.

Об'єкти групи захоплення мають такі поля:

· зсув - зміщення в кодових точках UTF-8 від початку введення

· - довжина в кодових точках UTF-8 цієї групи захоплення

· рядок - струна, яка була захоплена

· ім'я - назва групи захоплення (або нулю якщо він був безіменним)

Захоплення груп, які нічого не збігаються, повертає зміщення -1

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

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

jq ´match(["foo", "ig"])´
"foo bar FOO"
=> {"offset": 0, "length": 3, "string": "foo", "captures": []}, {"offset": 8, "length": 3, "string": "FOO ", "знімає": []}

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

jq ´[ відповідність ("."; "g")] | довжина´
"abc"
=> 3

[Вимагає 1.5] захоплення (val), захоплення (регулярний вираз; прапори)
Збирає названі захоплення в об’єкт JSON з назвою кожного захоплення як ключем,
і відповідний рядок як відповідне значення.

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

[Вимагає 1.5] сканування (регулярний вираз), сканувати (регулярний вираз; прапори)
Випускати потік неперекриваються підрядків введення, які відповідають регулярному виразу в
відповідно до прапорів, якщо такі були вказані. Якщо немає відповідності, потік є
порожній. Щоб отримати всі збіги для кожного вхідного рядка, використовуйте ідіому [ експр ], напр [
сканувати (регулярний вираз) ].

split(регулярний вираз; прапори)
Для зворотної сумісності, розкол розбиває на рядок, а не на регулярний вираз.

[Вимагає 1.5] розбиття (регулярний вираз), розщеплення (регулярний вираз; прапори)
Вони дають ті ж результати, що і їхні розкол відповідники, але як потік замість an
масив.

[Вимагає 1.5] під(регулярний вираз; нанизувати) під(регулярний вираз; рядок; прапори)
Видати рядок, отриманий шляхом заміни першого збігу регулярного виразу у вхідному рядку на
tostring, після інтерполяції. tostring має бути рядком jq і може містити посилання
до названих захоплень. Названі захоплення, по суті, представлені як об’єкт JSON (як
побудований захоплення), Щоб tostring, тому посилання на захоплену змінну з іменем "x" буде
мати вигляд: "(.x)".

[Вимагає 1.5] gsub(регулярний вираз; рядок), gsub(регулярний вираз; рядок; прапори)
gsub це як нижче але всі не перекриваються входження регулярного виразу замінюються на
рядок після інтерполяції.

ADVANCED ОСОБЛИВОСТІ

Змінні є абсолютною необхідністю в більшості мов програмування, але вони віднесені
до "розширеної функції" в jq.

У більшості мов змінні є єдиним засобом передачі даних. Якщо обчислити а
значення, і ви хочете використовувати його більше одного разу, вам потрібно буде зберегти його у змінній. До
передати значення іншій частині програми, вам знадобиться ця частина програми
визначте змінну (як параметр функції, член об’єкта чи що завгодно), в яку потрібно розмістити
дані.

Також можна визначити функції в jq, хоча це найбільша функція
використання визначає стандартну бібліотеку jq (багато функцій jq, наприклад карта та знаходити насправді є
написано в jq).

jq має оператори скорочення, які дуже потужні, але дещо складні. Знову ж таки, це такі
в основному використовується внутрішньо для визначення деяких корисних бітів стандартної бібліотеки jq.

Спочатку це може бути неочевидним, але jq - це все про генератори (так, як часто зустрічається в
інші мови). Деякі утиліти надаються, щоб допомогти впоратися з генераторами.

Деяка мінімальна підтримка введення-виводу (крім читання JSON зі стандартного введення та запису JSON у
стандартний вихід).

Нарешті, існує модульна/бібліотечна система.

Змінні
У jq всі фільтри мають вхід і вихід, тому вручну вводити сантехніку не потрібно
передати значення з однієї частини програми в іншу. Багато виразів, наприклад a + b,
передати свій вхід до двох різних підвиразів (тут a та b обидва передаються однаково
input), тому змінні зазвичай не потрібні, щоб використовувати значення двічі.

Наприклад, для обчислення середнього значення масиву чисел потрібно кілька
змінні в більшості мов - принаймні одна для утримання масиву, можливо, одна для кожного елемента
або для лічильника циклів. У jq це просто додавати / - додавати дається вираз
масив і видає його суму, і вираз отримує масив і створює його
довжина.

Отже, як правило, існує більш чистий спосіб вирішення більшості проблем у jq, ніж визначення змінних.
Проте іноді вони полегшують роботу, тому jq дозволяє визначати змінні за допомогою
вираз as $змінна. Усі імена змінних починаються з $. Ось трохи потворніша версія
прикладу усереднення масиву:

довжина як $array_length | додати / $array_length

Нам знадобиться складніша задача, щоб знайти ситуацію, коли фактично використовуємо змінні
полегшує наше життя.

Припустимо, у нас є масив дописів у блозі з полями «автор» і «назва», а також
об’єкт, який використовується для зіставлення імен користувачів авторів із справжніми іменами. Наш вхід виглядає так:

{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "Добре написана стаття", "author": "person1"}],
"справжні імена": {"anon": "Анонімний трус",
"person1": "Person McPherson"}}

Ми хочемо створити повідомлення з полем автора, яке містить справжнє ім’я, наприклад:

{"title": "Frist psot", "author": "Анонімний трус"}
{"title": "Добре написана стаття", "author": "Person McPherson"}

Ми використовуємо змінну $names для зберігання об’єкта realnames, щоб ми могли звернутися до нього пізніше
під час пошуку імен користувачів авторів:

.realnames як $names | .posts[] | {назва, автор: $names[.author]}

Вираз ехр as $x | ... означає: для кожного значення виразу ехр, запустіть решту
конвеєр з усім вихідним входом, і с $x встановити це значення. Таким чином as
функціонує як щось на кшталт циклу foreach.

Коли {foo} це зручний спосіб письма {foo: .foo}, так {$foo} це зручний спосіб письма
{foo:$foo}.

Кілька змінних можуть бути оголошені за допомогою однієї as вираження шляхом надання шаблону
який відповідає структурі введення (це відомо як "деструктуризація"):

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

Оголошення змінних у шаблонах масивів (наприклад, . as [$по-перше, $друга]) прив’язати до
елементи масиву в від елемента з нульовим індексом вгору, по порядку. Коли немає
значення в індексі для елемента шаблону масиву, нулю прив’язаний до цієї змінної.

Змінні мають область дії над рештою виразу, який їх визначає, отже

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

спрацює, але

(.realnames як $names | .posts[]) | {назва, автор: $names[.author]}

не буде.

Для теоретиків мови програмування точніше сказати, що jq змінні
прив’язки з лексичною областю дії. Зокрема, немає способу змінити значення прив'язки;
можна лише налаштувати нове прив’язування з такою ж назвою, але яке не буде видно де
старий був.

jq ´.bar як $x | .foo | . + $x´
{"foo":10, "bar":200}
=> 210

jq ´. як $i|[(.*2|. як $i| $i), $i]´
5
=> [10,5]

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

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

Визначення Функції
Ви можете дати фільтру назву за допомогою синтаксису "def":

приріст def: . + 1;

З тих пір, приріст можна використовувати як фільтр, як і вбудовану функцію (насправді це
так визначаються деякі вбудовані модулі). Функція може приймати аргументи:

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

Аргументи передаються як фільтри, а не як значення. На той самий аргумент можна посилатися
кілька разів з різними входами (тут f виконується для кожного елемента вхідного масиву).
Аргументи функції працюють більше як зворотні виклики, ніж як аргументи значення. Це
важливо зрозуміти. Розглянемо:

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

Результат буде 20 тому що f is .*2, і під час першого виклику f . буде 5,
а вдруге це буде 10 (5 * 2), тож результат буде 20. Аргументи функції
є фільтрами, і фільтри очікують введення при виклику.

Якщо вам потрібна поведінка значення-аргумент для визначення простих функцій, ви можете просто використовувати a
змінна:

def addvalue(f): f як $f | map(. + $f);

Або використовуйте скорочення:

def addvalue($f): ...;

З будь-яким визначенням, addvalue(.foo) додасть поточний вхід .foo поле кожному
елемент масиву.

Допускається кілька визначень, що використовують одне й те саме ім’я функції. Кожне повторне визначення замінює
попередній для такої ж кількості аргументів функції, але лише для посилань з
функції (або головна програма) після повторного визначення.

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

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

Зменшити
Команда зменшити Синтаксис у jq дозволяє об’єднати всі результати виразу by
збираючи їх в одну відповідь. Як приклад, ми пройдемо [3,2,1] до цього
вираз:

зменшити .[] як $item (0; . + $item)

Для кожного результату що [] виробляє, . + $item запускається для накопичення поточної суми,
починаючи з 0. У цьому прикладі [] дає результати 3, 2 і 1, отже, ефект є
схоже на запуск чогось на кшталт цього:

0 | (3 як $item | . + $item) |
(2 як $item | . + $item) |
(1 як $item | . + $item)

jq ´зменшити .[] як $item (0; . + $item)´
[10,2,5,3]
=> 20

межа(n; досвід)
Команда обмежувати функція витягує до n виходи з ехр.

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

перший (вираз), останній (вираз), n-й (n; вираз)
Команда перший (вираз) та останній (вираз) функції витягують перше та останнє значення з експр,
відповідно.

Команда n-й (n; вираз) функція витягує n-е значення, виведене за допомогою експр. Це можна визначити як
захист n-й (n; вираз): останній(ліміт(н + 1; вираз));. Зверніть увагу на це n-й (n; вираз) не підтримує
від'ємні значення n.

jq ´[перший(діапазон(.)), останній(діапазон(.)), nth(./2; діапазон(.))]´
10
=> [0,9,5]

перший, останній, n-й (n)
Команда перший та останній функції витягують перше та останнє значення з будь-якого масиву at ..

Команда n-й (n) функція витягує n-е значення будь-якого масиву at ..

jq ´[діапазон(.)]|[перший, останній, n-й(5)]´
10
=> [0,9,5]

для кожного
Команда для кожного синтаксис схожий на зменшити, але призначений для того, щоб дозволити будівництво обмежувати
і редуктори, які дають проміжні результати (див. приклад).

Форма є для кожного EXP as $ вар (У ЦЬОМУ; ОНОВЛЕННЯ; ЕКСТРАКТ), Як зменшити, INIT оцінюється
один раз, щоб створити значення стану, потім кожен вихід EXP обов'язково $ вар, ОНОВЛЕННЯ is
оцінюється для кожного виходу EXP з поточним станом і с $ вар видимий. Кожне значення
вихід за допомогою ОНОВЛЕННЯ замінює попередній стан. нарешті, ВИТЯГ оцінюється для кожного нового
стан, щоб отримати вихід для кожного.

Це в основному корисно лише для будівництва зменшити- І обмежувати-подібні функції. Але це
набагато загальніше, оскільки допускає часткові скорочення (див. приклад нижче).

jq ´[foreach .[] як $item ([[],[]]; якщо $item == null, то [[],.[0]] ще [(.[0] + [$item]),[] ]] кінець; якщо $item == нуль, то .[1] інакше порожній кінець)]´
[1,2,3,4,null,"a","b",null]
=> [[1,2,3,4],["a","b"]]

Рекурсія
Як описано вище, рецидивувати використовує рекурсію, і будь-яка функція jq може бути рекурсивною. The
в той час як вбудована також реалізована в термінах рекурсії.

Хвостові виклики оптимізуються щоразу, коли виводиться вираз ліворуч від рекурсивного виклику
його останнє значення. На практиці це означає, що вираз зліва від рекурсивного
виклик не повинен давати більше одного виходу для кожного входу.

Наприклад:

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

def while(cond; update):
def _while:
if cond then ., (оновлення | _while) інакше порожній кінець;
_поки;

def repeat(exp):
def _repeat:
exp, _repeat;
_повторити;

Генератори та ітератори
Деякі оператори та функції jq насправді є генераторами, оскільки вони можуть створювати нуль,
одне або більше значень для кожного входу, як можна було б очікувати в іншому програмуванні
мови, які мають генератори. Наприклад, [] генерує всі значення у вхідних даних
(який має бути масивом або об'єктом), діапазон(0; 10) генерує цілі числа від 0 до
10 тощо.

Навіть оператор коми є генератором, який спочатку генерує значення, згенеровані
вираз ліворуч від коми, а потім для кожного з них значення, створені за допомогою
вираз праворуч від коми.

Команда порожній вбудований - це генератор, який виробляє нульовий вихід. The порожній вбудований
повертається до попереднього виразу генератора.

Усі функції jq можуть бути генераторами лише за допомогою вбудованих генераторів. Це також можливо
щоб визначити нові генератори, використовуючи лише рекурсію та оператор коми. Якщо рекурсивна
виклик(и) є(є) "у хвостовому положенні", тоді генератор буде ефективним. У прикладі
нижче рекурсивного виклику by _діапазон до себе знаходиться в положенні хвоста. Приклад показовий
три розширені теми: хвостова рекурсія, побудова генератора та підфункції.

jq ´def range(init; upto; by): def _range: якщо (на > 0 і . < upto) або (на < 0 і . > до), то ., ((.+by)|_range) else . кінець; якщо by == 0, то init else init|_range end | select((на > 0 і . < до) або (на < 0 та . > до)); діапазон(0; 10; 3)´
нулю
=> 0, 3, 6, 9

jq ´def while(cond; update): def _while: якщо cond then ., (оновлення | _while) інакше порожній кінець; _поки; [поки (.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

МАТИ

jq наразі підтримує лише число з плаваючою комою IEEE754 з подвійною точністю (64-розрядні).

Крім простих арифметичних операторів, таких як +, jq також має більшість стандартних математичних функцій
з математичної бібліотеки C. Математичні функції C, які беруть один вхідний аргумент (наприклад, гріх())
доступні як функції jq з нульовим аргументом. Математичні функції C, які беруть два вхідні дані
аргументи (наприклад, пуд ()) доступні як функції jq з двома аргументами, які ігнорують ..

Наявність стандартних математичних функцій залежить від наявності відповідних
математичні функції у вашій операційній системі та математичній бібліотеці C. Недоступні математичні функції
буде визначено, але викличе помилку.

I / O

На даний момент jq має мінімальну підтримку вводу-виводу, переважно у формі контролю над тим, коли
вхідні дані зчитуються. Для цього передбачено дві вбудовані функції, вхід та витрати, що читали
з тих самих джерел (наприклад, stdin, файли, названі в командному рядку) як сам jq. Ці
дві вбудовані модулі та власні дії читання jq можуть перемежовуватися один з одним.

Один вбудований модуль забезпечує мінімальні можливості виведення, відлагоджувати. (Згадайте, що програма jq's
вихідні значення завжди виводяться як текст JSON stdout.) відлагоджувати вбудований може мати
поведінка конкретної програми, наприклад для виконуваних файлів, які використовують libjq C API, але не
сам виконуваний файл jq.

вхід
Виводить один новий вхід.

витрати
Виводить всі інші вхідні дані по одному.

Це в першу чергу корисно для скорочень над входами програми.

відлагоджувати
Викликає повідомлення про налагодження на основі вхідного значення. Виконуваний файл jq обертається
введене значення з ["ВІДЛАГОДЖУВАТИ:", ] і друкує це та новий рядок на stderr,
компактно. Це може змінитися в майбутньому.

ім'я_вхідного_файлу
Повертає ім’я файлу, введення якого зараз фільтрується. Зауважте, що це буде
не працює добре, якщо jq не працює в мові UTF-8.

номер_рядка введення
Повертає номер рядка вхідних даних, які зараз фільтруються.

ПІДТРИМКА

З --потік Параметр jq може аналізувати введені тексти потоковим способом, дозволяючи jq
програми, щоб почати обробку великих текстів JSON відразу, а не після розбору
завершує. Якщо у вас є один текст JSON розміром 1 ГБ, потокова передача дозволить вам
обробляти це набагато швидше.

Однак з потоковим передаванням справитися непросто, оскільки програма jq матиме це [ ,
] (та кілька інших форм) як вхідні дані.

Для полегшення роботи з потоками передбачено кілька вбудованих модулів.

У наведених нижче прикладах використовується потокова форма [0, [1]], Яка є
[[0],0],[[1,0],1],[[1,0]],[[1]].

Потокові форми включають [ , ] (щоб вказати будь-яке скалярне значення, порожній масив,
або порожній об'єкт), і [ ] (щоб позначити кінець масиву або об’єкта). Майбутнє
версії jq запускаються з --потік та -посл може виводити додаткові форми, наприклад ["помилка
повідомлення"] коли не вдається проаналізувати введений текст.

truncate_stream(stream_expression)
Споживає число як вхідні дані та обрізає відповідну кількість елементів шляху
ліворуч від вихідних даних даного потокового виразу.

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

fromstream(stream_expression)
Виводить значення, що відповідають виходам виразу потоку.

jq ´fromstream(1|truncate_stream([[0],1],[[1,0],2],[[1,0]],[[1]]))´
нулю
=> [2]

tostream
Команда tostream вбудована виводить потокову форму свого входу.

jq ´. як $dot|fromstream($dot|tostream)|.==$dot´
[0,[1,{"a":1},{"b":2}]]
=> правда

НАДАННЯ

Присвоєння працює в jq трохи інакше, ніж у більшості мов програмування. jq не робить
розрізняти посилання на щось і копії - це два об'єкти або масиви
або рівний, або нерівний, без будь-якого подальшого поняття «той самий об’єкт» чи «не».
той самий об’єкт».

Якщо об’єкт має два поля, які є масивами, .foo та .Кафе, і ви щось додаєте
.foo, То .Кафе не стане більшим. Навіть якщо ви щойно налаштували .Кафе = .foo. Якщо ви звикли
до програмування на таких мовах, як Python, Java, Ruby, Javascript тощо, тоді ви можете подумати
це так, ніби jq робить повну глибоку копію кожного об'єкта перед виконанням призначення
(щодо продуктивності це насправді не робиться, але це загальна ідея).

Усі оператори присвоєння в jq мають вирази шляху зліва.

=
Фільтр .foo = 1 візьме об'єкт як вхідні дані і виведе як вихідний об'єкт з
Поле "foo" встановлено на 1. У jq немає поняття "модифікувати" чи "змінювати" щось -
всі значення jq незмінні. Наприклад,

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

не матиме побічного ефекту встановлення для .bar.baz значення 1, оскільки схожий вигляд
програма на Javascript, Python, Ruby або інших мовах. На відміну від цих мов (але
як Haskell та деякі інші функціональні мови), немає поняття про два масиви або
об'єкти є "той самий масив" або "той самий об'єкт". Вони можуть бути рівними, або не рівними, але
якщо ми змінимо одну з них ні в якому разі не зміниться інший за нашою спиною.

Це означає, що неможливо побудувати кругові значення в jq (наприклад, масив якого
першим елементом є він сам). Це цілком навмисно і гарантує, що будь-що jq
програма може бути представлена ​​в JSON.

Зауважте, що ліва частина ´=´ відноситься до значення в .. Таким чином $var.foo = 1 не працюватиме
як і очікувалося ($var.foo не є дійсним або корисним виразом шляху в .); використання $ вар | .foo = 1
замість цього.

Якщо права частина ´=´ дає кілька значень, то для кожного такого значення jq буде
встановіть шляхи ліворуч на значення, а потім виведе змінене ..
Наприклад, (.a,.b)=діапазон(2) виходи {"a":0,"b":0}, То {"a":1,"b":1}. "оновлення"
форми завдання (див. нижче) цього не роблять.

Зверніть увагу і на це .a,.b=0 не встановлюється .a та .b, Але (.a,.b)=0 встановлює обидва.

|=
Окрім оператора присвоєння ´=´, jq забезпечує оператор «оновлення» ´|=´, який
бере фільтр у правій частині та визначає нове значення властивості .
призначається шляхом виконання старого значення через цей вираз. Наприклад, .foo |=
.+1 створить об’єкт із полем «foo», встановленим на «foo» плюс 1 для входу.

Цей приклад повинен показати різницю між ´=´ і ´|=´:

Введіть ´{"a": {"b": 10}, "b": 20}´ до програм:

.a = .b .a |= .b

Перший встановить поле "a" введення на поле "b" введення і виведе
вихід {"a": 20}. Останній встановить поле "a" введення на поле "a".
поле "b", що створює {"a": 10}.

Ліва частина може бути будь-яким загальним виразом шляху; подивитися шлях().

Зауважте, що ліва частина ´|=´ відноситься до значення в .. Таким чином $var.foo |= . + 1 не буде
працювати як очікується ($var.foo не є дійсним або корисним виразом шляху в .); використання $ вар | .foo
|= . + 1 замість цього.

Якщо праворуч виводить кілька значень, буде використано лише останнє.

jq ´(..|select(type=="boolean")) |= якщо . потім 1 ще 0 закінчується´
[правда, неправда, [5, вірно, [правда, [хибно]], неправда]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, /=, %=, // =
jq має кілька операторів виду a op= b, які всі еквівалентні a |= . op b. Тому,
+= 1 можна використовувати для збільшення значень.

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

Комплекс Призначення
У лівій частині присвоєння jq дозволено набагато більше речей, ніж у більшості
мови. Ми вже бачили простий доступ до поля з лівого боку, і це ні
дивно, що доступ до масиву працює так само добре:

.posts[0].title = "Посібник JQ"

Що може стати несподіванкою, так це те, що вираз ліворуч може викликати кілька
результати, посилаючись на різні пункти у вхідному документі:

.posts[].comments |= . + ["це чудово"]

Цей приклад додає рядок "це чудово" до масиву "коментарі" кожної публікації
вхід (де вхідним є об'єкт з полем "posts", яке є масивом постів).

Коли jq зустрічає призначення, як-от ´a = b´, він записує «шлях», пройдений для вибору
частина вхідного документа під час виконання a. Потім цей шлях використовується для пошуку частини
вхідні дані, які потрібно змінити під час виконання завдання. Для цього можна використовувати будь-який фільтр
ліва частина дорівнює - будь-який шлях, який він вибере з вхідних даних, буде місцем
завдання виконується.

Це дуже потужна операція. Припустимо, ми хочемо додати коментар до публікацій блогу, використовуючи
той самий "блог" введений вище. Цього разу ми хочемо прокоментувати лише повідомлення, написані автором
"стедолан". Ми можемо знайти ці дописи за допомогою функції "вибрати", описаної раніше:

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

Шляхи, передбачені цією операцією, вказують на кожну з публікацій, які написав "stedolan", і
ми можемо коментувати кожну з них так само, як і раніше:

(.posts[] | select(.author == "stedolan") | .comments) |=
. + ["жахливо."]

МОДУЛІ

jq має систему бібліотек/модулів. Модулі — це файли, імена яких закінчуються на .jq.

Модулі, імпортовані програмою, шукаються за умовчанням (див. нижче). The
імпорт та включати директиви дозволяють імпортеру змінювати цей шлях.

Шляхи в шляху пошуку піддаються різним замінам.

Для шляхів, які починаються з "~/", домашній каталог користувача замінюється на "~".

Для шляхів, які починаються з "$ORIGIN/", шлях до виконуваного файлу jq замінюється на
"$ORIGIN".

Для шляхів, які починаються з "./" або шляхів, які є ".", шлях до включаючого файлу є
замінити на ".". Для програм верхнього рівня, заданих у командному рядку, поточний
використовується каталог.

Директиви імпорту можуть додатково вказати шлях пошуку, до якого буде додано значення за замовчуванням.

Шлях пошуку за замовчуванням – це шлях пошуку, заданий для -L параметр командного рядка, інакше
["~/.jq", "$ORIGIN/../lib/jq", "$ORIGIN/../ lib"].

Нульові та пусті елементи шляху рядка завершують обробку шляху пошуку.

Залежність з відносним шляхом "foo/bar" буде шукатися в "foo/bar.jq" і
"foo/bar/bar.jq" у заданому шляху пошуку. Це призначено для того, щоб дозволити розмістити модулі
у каталозі разом із, наприклад, файлами контролю версій, файлами README тощо,
але також допускати однофайлові модулі.

Послідовні компоненти з однаковою назвою не допускаються, щоб уникнути двозначності (наприклад,
"foo/foo").

Наприклад, с -L$HOME/.jq модуль Foo можна знайти в $HOME/.jq/foo.jq та
$HOME/.jq/foo/foo.jq.

Якщо «$HOME/.jq» є файлом, він надходить у головну програму.

імпорт RelativePathString as ІМ'Я [ ];
Імпортує модуль, знайдений за заданим шляхом, відносно каталогу в шляху пошуку. A ".jq"
суфікс буде додано до рядка відносного шляху. Символи модуля мають префікс
"NAME::".

Необов’язкові метадані мають бути постійним виразом jq. Це має бути предмет із ключами
як "домашня сторінка" тощо. На даний момент jq використовує лише ключ/значення "пошуку".
метадані. Метадані також доступні користувачам через modulemeta вбудований.

Ключ «пошук» у метаданих, якщо він присутній, повинен мати рядок або значення масиву (масив
струн); це шлях пошуку, який має бути префіксом шляху пошуку верхнього рівня.

включати RelativePathString [ ];
Імпортує модуль, знайдений за заданим шляхом, відносно каталогу в шляху пошуку, як ніби він
були включені на місце. До рядка відносного шляху буде додано суфікс ".jq". The
символи модуля імпортуються в простір імен абонента, як якщо б вміст модуля мав
було включено безпосередньо.

Необов’язкові метадані мають бути постійним виразом jq. Це має бути предмет із ключами
як "домашня сторінка" тощо. На даний момент jq використовує лише ключ/значення "пошуку".
метадані. Метадані також доступні користувачам через modulemeta вбудований.

імпорт RelativePathString as $NAME [ ];
Імпортує файл JSON, знайдений за заданим шляхом, відносно каталогу в шляху пошуку. А
Суфікс ".json" буде додано до рядка відносного шляху. Дані файлу будуть
доступний як $NAME::NAME.

Необов’язкові метадані мають бути постійним виразом jq. Це має бути предмет із ключами
як "домашня сторінка" тощо. На даний момент jq використовує лише ключ/значення "пошуку".
метадані. Метадані також доступні користувачам через modulemeta вбудований.

Ключ «пошук» у метаданих, якщо він присутній, повинен мати рядок або значення масиву (масив
струн); це шлях пошуку, який має бути префіксом шляху пошуку верхнього рівня.

Модулі ;
Ця директива є абсолютно необов'язковою. Це не потрібно для правильної роботи. Це служить
лише з метою надання метаданих, які можна прочитати за допомогою modulemeta вбудований.

Метадані мають бути постійним виразом jq. Це має бути об’єкт із такими ключами
«домашня сторінка». Наразі jq не використовує ці метадані, але вони доступні для користувачів
чЕРЕЗ modulemeta вбудований.

modulemeta
Приймає ім’я модуля як вхідні дані та виводить метадані модуля як об’єкт за допомогою
імпорт модуля (включаючи метадані) як значення масиву для ключа "deps".

Програми можуть використовувати це для запиту метаданих модуля, для яких вони потім можуть використовувати
наприклад, пошук, завантаження та встановлення відсутніх залежностей.

Використовуйте jq онлайн за допомогою служб onworks.net