jq - Интернет в облаке

ПРОГРАММА:

ИМЯ

jq - Командная строка процессора JSON

СИНТАКСИС

jq [кредита...] фильтр [файлов...]

jq может преобразовывать JSON различными способами, выбирая, повторяя, сокращая и т. д.
искажение документов JSON. Например, запустив команду jq ´map (.цена) | добавлять предусматривает
взять на вход массив объектов JSON и вернуть сумму их полей «цена».

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

" кредита описаны в ВЫЗОВ JQ раздел; в основном они касаются ввода и вывода
форматирование. В фильтр написан на языке jq и указывает, как преобразовать
входной файл или документ.

ФИЛЬТРЫ

Программа jq - это «фильтр»: она принимает входные данные и производит выходные данные. Есть много
встроенные фильтры для извлечения определенного поля объекта или преобразования числа в
строка или различные другие стандартные задачи.

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

Некоторые фильтры дают несколько результатов, например, есть один, который дает все
элементы его входного массива. Подключение этого фильтра ко второму запускает второй фильтр для
каждый элемент массива. Как правило, то, что делается с помощью циклов и итераций
на других языках это просто делается путем склейки фильтров в jq.

Важно помнить, что у каждого фильтра есть вход и выход. Даже литералы
например, "привет" или 42 - это фильтры - они принимают входные данные, но всегда производят тот же литерал, что и
вывод. Операции, которые объединяют два фильтра, например сложение, обычно используют один и тот же ввод
к обоим и объединить результаты. Итак, вы можете реализовать фильтр усреднения как /
- подача входного массива как в фильтр и фильтр, а затем выполнение
дивизион.

Но мы забегаем вперед. :) Начнем с чего попроще:

ВЫЗОВ JQ

Фильтры jq запускаются в потоке данных JSON. Вход в jq анализируется как последовательность
значения JSON, разделенные пробелами, которые проходят через предоставленный фильтр по одному в
время. Выходные данные фильтра записываются стандартно, снова как последовательность
данные JSON, разделенные пробелами.

Примечание: важно помнить правила цитирования оболочки. Как правило, лучше всего
всегда цитируйте (с одинарными кавычками) программу jq, так как слишком много символов с
особое значение для jq также имеют метасимволы оболочки. Например, jq "фу" потерпит неудачу на
большинство оболочек Unix, потому что это будет то же самое, что jq Foo, который обычно терпит неудачу
потому что Foo is определенный. При использовании командной оболочки Windows (cmd.exe) лучше всего
используйте двойные кавычки в вашей программе jq, когда они указаны в командной строке (вместо -f
программный файл option), но тогда двойные кавычки в программе jq требуют экранирования обратной косой черты.

Вы можете повлиять на то, как jq читает и записывает свой ввод и вывод, используя некоторую командную строку.
опции:

· --версия:

Выведите версию jq и выйдите с нулем.

· --seq:

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

· --транслировать:

Анализировать ввод в потоковом режиме, выводя массивы значений пути и листьев
(скаляры и пустые массивы или пустые объекты). Например, «А» становится [[], "а"]и
[[], «а», [«б»]] становится [[0], []], [[1], "а"]и [[1,0], "b"].

Это полезно для обработки очень больших входных данных. Используйте это вместе с
фильтрация и уменьшить и Еогеасп синтаксис для постепенного уменьшения больших входных данных.

· - шлепать/-s:

Вместо того, чтобы запускать фильтр для каждого объекта JSON во входных данных, прочитайте все входные данные.
поток в большой массив и запускать фильтр только один раз.

· --сырой ввод/-R:

Не анализируйте ввод как JSON. Вместо этого каждая строка текста передается фильтру как
нить. В сочетании с - шлепать, то весь ввод передается фильтру как
одиночная длинная строка.

· --null-ввод/-n:

Ни в коем случае не читайте вводимые данные! Вместо этого фильтр запускается один раз с использованием нуль как вход.
Это полезно при использовании jq в качестве простого калькулятора или для построения данных JSON из
царапина.

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

По умолчанию jq красиво печатает вывод JSON. Использование этой опции приведет к большему
компактный вывод, вместо этого помещая каждый объект JSON в одну строку.

· --вкладка:

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

· --индент n:

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

· --color-output / -C и --монохромный выход / -M:

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

· --ascii-выход / -a:

jq обычно выводит кодовые точки Unicode, отличные от ASCII, как UTF-8, даже если вход указан
их как escape-последовательности (например, «\ u03bc»). Используя эту опцию, вы можете заставить jq
производить чистый вывод ASCII с заменой каждого символа, отличного от ASCII, на эквивалент
escape-последовательность.

· - без буферизации

Сбрасывать вывод после печати каждого объекта JSON (полезно, если вы используете медленный
источник данных в jq и конвейер вывода jq в другом месте).

· --sort-keys / -S:

Выведите поля каждого объекта с ключами в отсортированном порядке.

· --raw-выход / -r:

С этой опцией, если результатом фильтра является строка, она будет записана напрямую
для стандартного вывода, а не форматируется как строка JSON с кавычками. Это может
быть полезным для того, чтобы фильтры jq взаимодействовали с системами, не основанными на JSON.

· --join-выход / -j:

Подобно -r но jq не будет печатать новую строку после каждого вывода.

· -f имя файла / --из файла имя файла:

Считайте фильтр из файла, а не из командной строки, например, параметр -f в awk. Ты
также можно использовать знак «#» для комментариев.

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

Подготовить каталог в список поиска модулей. Если используется эта опция, то нет
Используется встроенный список поиска. См. Раздел о модулях ниже.

· -e / --exit-статус:

Устанавливает статус выхода jq равным 0, если последние выходные значения не были ни тем, ни другим ложный ни нуль,
1, если последнее выходное значение было либо ложный or нуль, или 4, если действительного результата никогда не было
произведен. Обычно jq завершается с 2, если была какая-либо проблема с использованием или системная ошибка, 3
если произошла ошибка компиляции программы jq, или 0, если программа jq была запущена.

· --arg имя ценностное :

Эта опция передает значение программе jq как предопределенную переменную. Если вы запустите jq
--arg Foo бар, то $ Foo доступен в программе и имеет значение "бар".
Обратите внимание, что ценностное будет рассматриваться как строка, поэтому --arg Foo 123 свяжет $ Foo в "123".

· --argjson имя JSON-текст:

Этот параметр передает значение в кодировке JSON в программу jq как предопределенную переменную. Если
вы запускаете jq с --argjson Foo 123, то $ Foo доступен в программе и имеет
ценностное 123.

· --slurpfile имя-переменной имя файла:

Эта опция считывает все тексты JSON в названном файле и связывает массив
проанализировал значения JSON для данной глобальной переменной. Если вы запустите jq с --argfile Foo бар,
тогда $ Foo доступен в программе и имеет массив, элементы которого соответствуют
тексты в файле с именем бар.

· --argfile имя-переменной имя файла:

Не используй. Использовать --slurpfile .

(Этот вариант похож на --slurpfile, но если в файле всего один текст, то это
используется, иначе используется массив текстов, как в --slurpfile.)

· --run-тесты [имя файла]:

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

Имейте в виду, что этот параметр может быть изменен обратно несовместимо.

BASIC ФИЛЬТРЫ

.
Самый простой (и наименее интересный) фильтр - это .. Это фильтр,
ввод и производит его без изменений как вывод.

Поскольку jq по умолчанию красиво печатает весь вывод, эта тривиальная программа может быть полезным способом
форматирование вывода JSON, скажем, виться.

jq '.'
"Привет мир!"
=> «Привет, мир!»

.фу, .foo.bar
Простейший полезный фильтр .foo. При задании объекта JSON (он же словарь или хеш) как
input, он выдает значение по ключу "foo" или null, если его нет.

Если ключ содержит специальные символы, вам нужно заключить его в двойные кавычки, например
это: . "foo $".

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

jq «.foo»
{"foo": 42, "bar": "менее интересные данные"}
=> 42

jq «.foo»
{"notfoo": правда, "alsonotfoo": ложь}
=> ноль

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

.фу?
Так же, как .foo, но не выводит даже ошибку, когда . не является массивом или объектом.

jq ´.foo? ´
{"foo": 42, "bar": "менее интересные данные"}
=> 42

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

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

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

. [ ], . [2], . [10:15]
Вы также можете искать поля объекта, используя синтаксис вроде . ["фу"] (.foo выше - это
сокращенная версия этого). Это также работает для массивов, если ключ является целым числом.
Массивы начинаются с нуля (например, 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"]
=> ["а", "б", "в"]

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», так и поля «bar» как отдельные выходные данные.

jq «.foo, .bar»
{"foo": 42, "bar": "что-то еще", "baz": правда}
=> 42, «что-то еще»

jq ´.user, .projects [] ´
{"пользователь": "стедолан", "проекты": ["jq", "wikiflow"]}
=> «stedolan», «jq», «wikiflow»

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

|
| оператор объединяет два фильтра, подавая выходные данные одного (-ых) слева в
вход того, что справа. Это почти то же самое, что и конвейер оболочки Unix, если
ты к этому привык.

Если результат слева дает несколько результатов, то результат справа будет запущен для
каждый из этих результатов. Итак, выражение . [] | .foo извлекает поле "foo" каждого
элемент входного массива.

jq ´. [] | .название
[{"name": "JSON", "good": true}, {"name": "XML", "good": false}]
=> «JSON», «XML»

ВИДЫ И ЦЕННОСТИ:

jq поддерживает тот же набор типов данных, что и JSON - числа, строки, логические значения, массивы,
объекты (которые в языке JSON являются хешами только с строковыми ключами) и "null".

Логические значения, null, строки и числа записываются так же, как в javascript. Как
все остальное в jq, эти простые значения принимают ввод и производят вывод - 42 - это
допустимое выражение jq, которое принимает входные данные, игнорирует их и вместо этого возвращает 42.

массив строительство - []
Как и в JSON, [] используется для построения массивов, как в [1,2,3]. Элементы массивов могут
быть любым выражением jq. Собираются все результаты, полученные с помощью всех выражений.
в один большой массив. Вы можете использовать его для построения массива из известного количества значений.
(Как в [.foo, .бар, .баз]) или "собрать" все результаты фильтра в массив (как
in [.items []. name])

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

Если у вас есть фильтр X что дает четыре результата, тогда выражение [X] будет производить
единый результат, массив из четырех элементов.

jq ´ [.user, .projects []] ´
{"пользователь": "стедолан", "проекты": ["jq", "wikiflow"]}
=> ["stedolan", "jq", "wikiflow"]

Объекты - {}
Как JSON, {} предназначен для создания объектов (то есть словарей или хэшей), например: {"а": 42 году
"b": 17/XNUMX/XNUMX}.

Если клавиши «толковые» (все буквенные символы), кавычки можно не ставить.
Значение может быть любым выражением (хотя вам может потребоваться заключить его в круглые скобки, если это
сложный), который применяется ко входу выражения {} (помните, что все фильтры
есть вход и выход).

{фу: .бар}

создаст объект JSON {"фу": 42/XNUMX/XNUMX} если указан объект JSON {"бар": 42, "baz": 43}.
Вы можете использовать это для выбора определенных полей объекта: если ввод - это объект с
поля "user", "title", "id" и "content", а вам просто нужны "user" и "title", вы можете
записывать

{пользователь: .user, title: .title}

Поскольку это очень распространено, существует сокращенный синтаксис: {Пользователь, заглавие}.

Если одно из выражений дает несколько результатов, несколько словарей будут
произведен. Если вход

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

тогда выражение

{пользователь, title: .titles []}

даст два выхода:

{"user": "stedolan", "title": "JQ Primer"}
{"user": "stedolan", "title": "Еще JQ"}

Заключение ключа в круглые скобки означает, что он будет вычислен как выражение. С
тот же ввод, что и выше,

{(.пользователь): .titles}

производит

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

jq ´ {пользователь, название: .titles []} ´
{"user": "stedolan", "title": ["JQ Primer", "More JQ"]}
=> {"user": "stedolan", "title": "JQ Primer"}, {"user": "stedolan", "title": "Еще JQ"}

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

ВСТРОЕННЫЙ ОПЕРАТОРЫ И ФУНКЦИИ

Какой-нибудь оператор jq (например, +) делают разные вещи в зависимости от типа своего
аргументы (массивы, числа и т. д.). Однако jq никогда не выполняет неявных преобразований типов. Если
вы пытаетесь добавить строку к объекту, вы получите сообщение об ошибке, но нет результата.

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

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

· Массивы добавляются путем объединения в больший массив.

· Струны добавляются путем объединения в большую строку.

· Объекты добавляются путем слияния, то есть вставки всех пар ключ-значение из обоих
объекты в единый комбинированный объект. Если оба объекта содержат значение для одного и того же
ключ, объект справа от + побеждает. (Для рекурсивного слияния используйте * оператор.)

нуль может быть добавлен к любому значению и возвращает другое значение без изменений.

jq '.a + 1'
{"а": 7}
=> 8

jq '.a + .b'
{"a": [1,2], "b": [3,4]}
=> [1,2,3,4]

jq «.a + ноль»
{"а": 1}
=> 1

jq '.a + 1'
{}
=> 1

jq ´ {a: 1} + {b: 2} + {c: 3} + {a: 42} ´
нуль
=> {"a": 42, "b": 2, "c": 3}

вычитание - -
Так же, как и обычное арифметическое вычитание чисел, - оператор может использоваться с массивами
чтобы удалить все вхождения элементов второго массива из первого массива.

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

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

Умножение, деление, форма - *, /, и %
Эти инфиксные операторы ведут себя должным образом, если заданы два числа. Деление на ноль прибавок
ошибка. x % y вычисляет x по модулю y.

Умножение строки на число приводит к конкатенации этой строки,
раз. "Икс" * 0 производит нуль.

Разделение строки на другую разделяет первую строку, используя вторую в качестве разделителя.

Умножение двух объектов объединит их рекурсивно: это работает как сложение, но если оба
объекты содержат значение для одного и того же ключа, а значения являются объектами, два объединяются
с той же стратегией.

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

jq ´. / "," ´
"а, б, в, г, д"
=> ["а", "б, в, г", "д"]

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


Встроенная функция получает длину различных типов значений:

· Длина string это количество содержащихся в нем кодовых точек Unicode (которое будет
то же, что и его длина в байтах в кодировке JSON, если это чистый ASCII).

· Длина массив количество элементов.

· Длина объект - количество пар "ключ-значение".

· Длина нуль это ноль.

jq ´. [] | length´ [[1,2], "строка", {"a": 2}, null] => 2, 6, 1, 0

ключи, ключи_unsorted
Встроенная функция ключипри задании объекта возвращает его ключи в виде массива.

Ключи отсортированы «в алфавитном порядке» в порядке кодирования Unicode. Это не приказ
это имеет особый смысл для любого конкретного языка, но вы можете рассчитывать на то, что это
одинаково для любых двух объектов с одним и тем же набором ключей, независимо от настроек локали.

После появления ключи дается массив, он возвращает действительные индексы для этого массива: целые числа
от 0 до длины-1.

" ключи_unsorted функция такая же, как ключи, но если вход - объект, то ключи
не будут отсортированы, вместо этого ключи будут примерно в порядке вставки.

jq «ключи»
{"abc": 1, "abcd": 2, "Foo": 3}
=> ["Foo", "abc", "abcd"]

jq «ключи»
[42,3,35]
=> [0,1,2]

имеет (ключ)
Встроенная функция и возвращает, имеет ли входной объект данный ключ, или вход
В массиве есть элемент по данному индексу.

имеет ($ ключ) имеет тот же эффект, что и проверка того, $ ключ является членом возвращаемого массива
by ключи, Хотя и будет быстрее.

jq ´map (has ("foo")) ´
[{"foo": 42}, {}]
=> [правда, ложь]

jq ´map (и(2)) ´
[[0,1], ["a", "b", "c"]]
=> [ложь, правда]

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

jq ´. [] | in ({"foo": 42}) ´
["фу", "бар"]
=> правда, ложь

jq ´map (in ([0,1])) ´
[2, 0]
=> [ложь, правда]

путь (выражение_пути)
Выводит представление массива данного выражения пути в .. Выходы представляют собой массивы
строки (ключи в объектах 0 и / или числа (индексы массива.

Выражения пути - это выражения jq, например .a, Но и . []. Есть два типа пути
выражения: те, которые могут точно соответствовать, и те, которые не могут. Например, .abc есть
выражение пути точного совпадения, в то время как .a []. b не является.

путь (точное_путь_выражение) создаст представление массива выражения пути
даже если его нет в ., Если . is нуль или массив или объект.

путь (узор) создаст массивные представления путей, соответствующих описания если
пути существуют в ..

Обратите внимание, что выражения пути не отличаются от обычных выражений. Выражение
путь (.. | select (type == "логическое")) выводит все пути к логическим значениям в ., и только
эти пути.

jq ´path (.a [0] .b) ´
нуль
=> ["а", 0, "б"]

jq ´ [путь (..)] ´
{"а": [{"б": 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]) ´
["фу", "бар", "баз"]
=> ["фу"]

to_entries, из_записей, with_entries
Эти функции выполняют преобразование между объектом и массивом пар ключ-значение. Если to_entries
передается объект, затем для каждого k: v запись на входе, выходной массив включает
{"ключ": k, "ценность": v}.

from_entries выполняет обратное преобразование, и with_entries (foo) это сокращение для
to_entries | карта (foo) | from_entries, полезно для выполнения некоторых операций со всеми клавишами и
значения объекта. from_entries принимает ключ, ключ, имя, значение и значение в качестве ключей.

jq «to_entries»
{"a": 1, "b": 2}
=> [{"ключ": "а", "значение": 1}, {"ключ": "б", "значение": 2}]

jq «из_записей»
[{"ключ": "а", "значение": 1}, {"ключ": "б", "значение": 2}]
=> {"a": 1, "b": 2}

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

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

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

jq ´map (выберите (.> = 2)) ´
[1,5,3,0,7]
=> [5,3,7]

jq ´. [] | выберите (.id == "второй") ´
[{"id": "первый", "val": 1}, {"id": "второй", "val": 2}]
=> {"id": "second", "val": 2}

массивы, объекты, итерации, булевы номера, нормали конечные строки, нули ценности,
скаляры
Эти встроенные функции выбирают только входные данные, которые являются массивами, объектами, итерациями (массивами или
объекты), логические, числа, нормальные числа, конечные числа, строки, ноль, ненулевое значение
значения и не повторяющиеся, соответственно.

jq ´. [] | числа´
[[], {}, 1, "foo", ноль, истина, ложь]
=> 1

пустой
пустой не возвращает результатов. Вовсе нет. Даже не нуль.

Иногда это полезно. Вы знаете, если вам это нужно :)

jq ´1, пусто, 2´
нуль
=> 1, 2

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

ошибка(Сообщение)
Выдает ошибку, как и .a применяется к значениям, отличным от null, и объекты будут, но
с данным сообщением в качестве значения ошибки.

$ __ loc__
Создает объект с ключом "файл" и ключом "строка" с именем файла и номером строки.
в котором $ __ loc__ происходит, как значения.

jq ´try error ("\ ($ __ loc__)") catch .´
нуль
=> "{\" файл \ ": \" \",\"линия 1}"

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

Кроме того, map_values ​​(x) запустит этот фильтр для каждого элемента, но вернет
объект при передаче объекта.

карта (х) эквивалентна [. [] | x]. Фактически, это то, как это определяется. Так же,
map_values ​​(x) определяется как . [] |= x.

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

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

дорожки пути (node_filter), листовые_путь
пути выводит пути ко всем элементам на входе (за исключением того, что не выводит
пустой список, представляющий. сам).

дорожки (f) выводит пути к любым значениям, для которых f правда. Это, пути (числа)
выводит пути ко всем числовым значениям.

листовые_путь это псевдоним пути (скаляры); листовые_путь is устарела и будет удален через
следующий крупный выпуск.

jq ´ [пути] ´
[1, [[], {"а": 2}]]
=> [[0],[1],[1,0],[1,1],[1,1,"a"]]

jq ´ [пути (скаляры)] ´
[1, [[], {"а": 2}]]
=> [[0], [1,1, "а"]]


Фильтр принимает в качестве входных данных массив и производит в качестве выходных данных элементы массива
сложены вместе. Это может означать суммирование, объединение или слияние в зависимости от типов
элементы входного массива - правила такие же, как и для + оператор
(описано выше).

Если ввод - пустой массив, Возвращает нуль.

jq «добавить»
[«а», «б», «в»]
=> "abc"

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

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

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

Если ввод - пустой массив, любой Возвращает ложный.

" любой (условие) 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 ´range (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

SQRT
" SQRT функция возвращает квадратный корень числового ввода.

jq «sqrt»
9
=> 3

число
" число функция анализирует свой ввод как число. Он преобразует правильно отформатированный
строки к их числовому эквиваленту, оставьте числа в покое и выдайте ошибку на всех остальных
вход.

jq ´. [] | tonumber´
[1, «1»]
=> 1, 1

нанизывать
" нанизывать функция печатает свой ввод в виде строки. Строки оставляем без изменений, а все
другие значения закодированы в формате JSON.

jq ´. [] | нанизывать
[1, «1», [1]]
=> «1», «1», «[1]»

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

jq ´map (тип) ´
[0, ложь, [], {}, ноль, "привет"]
=> ["число", "логическое", "массив", "объект", "ноль", "строка"]

бесконечна, нан бесконечно, Иснан, бесконечен, это нормально
Некоторые арифметические операции могут давать бесконечные значения, а не числа (NaN). В
бесконечен встроенный возврат правда если его вход бесконечен. В IsNaN встроенный возврат правда
если его вход - NaN. В бесконечный builtin возвращает положительное бесконечное значение. В бабушка
builtin возвращает NaN. В это нормально builtin возвращает истину, если его ввод - нормальное число.

Обратите внимание, что деление на ноль вызывает ошибку.

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

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

jq ´ бесконечное, нан | тип
нуль
=> «число», «число»

Сортировать, sort_by (выражение_пути)
" sort функции сортируют свой ввод, который должен быть массивом. Значения отсортированы в
в следующем порядке:

· нуль

· ложный

· правда

· Числа

· Строки в алфавитном порядке (по значению кода Юникода)

· Массивы в лексическом порядке

· объекты

Порядок объектов немного сложен: сначала они сравниваются, сравнивая их
наборы ключей (как массивы в отсортированном порядке), и если их ключи равны, то значения
сравнил по ключам.

sort может использоваться для сортировки по определенному полю объекта или путем применения любого фильтра jq.

sort_by (foo) сравнивает два элемента, сравнивая результат Foo на каждом элементе.

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

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

group_by (выражение_пути)
group_by (.foo) принимает в качестве входных данных массив, группирует элементы, имеющие одинаковые .foo поле
в отдельные массивы и производит все эти массивы как элементы большего массива,
отсортировано по значению .foo поле.

Любое выражение jq, а не только доступ к полю, может использоваться вместо .foo. Сортировка
порядок такой же, как описано в sort функция выше.

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

мин, Максимум, min_by (path_exp), max_by (путь_exp)
Найдите минимальный или максимальный элемент входного массива.

" min_by (path_exp) и max_by (путь_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}

уникальный, unique_by (выражение_пути)
" созданного функция принимает в качестве входных данных массив и производит массив тех же элементов в
отсортированный порядок, с удаленными дубликатами.

" unique_by (выражение_пути) функция сохранит только один элемент для каждого значения, полученного
применяя аргумент. Подумайте об этом как о создании массива, вынимая по одному элементу из каждого
группа произведена группы.

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 полностью содержится во входных данных. А
строка B содержится в строке A, если B является подстрокой A. Массив B содержится в
массив A, если все элементы в B содержатся в любом элементе в A. Объект B - это
содержится в объекте A, если все значения в B содержатся в значении в A с
тот же ключ. Предполагается, что все остальные типы содержатся друг в друге, если они равны.

jq ´contains («бар») ´
"фубар"
=> правда

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

jq ´contains (["bazzzzz", "bar"]) ´
["foobar", "foobaz", "blarp"]
=> ложь

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

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

индексы
Выводит массив, содержащий индексы в . в котором s имеет место. Вход может быть массивом в
в каком случае, если s является массивом, то выходные индексы будут такими, где все элементы в .
соответствовать тем из s.

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

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

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

индекс (ы), риндекс (ы)
Выводит индекс первого (индекс) или последний (риндекс) появление s на входе.

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

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

внутри
Фильтр внутри (б) вернет истину, если ввод полностью содержится в b. Это
по сути, является перевернутой версией содержит.

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

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 ´ [. [] | начинается с ("foo")] ´
["fo", "foo", "barfoo", "foobar", "barfoob"]
=> [ложь, правда, ложь, правда, ложь]

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

jq ´ [. [] | заканчивается на ("фу")] ´
["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 ("фу")] ´
["fo", "foo", "barfoo", "foobar", "afoo"]
=> ["fo", "", "barfoo", "bar", "afoo"]

rtrimstr (str)
Выводит свой ввод с удаленной данной строкой суффикса, если она ею заканчивается.

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

взорваться
Преобразует входную строку в массив номеров кодовых точек строки.

jq «взорваться»
"фубар"
=> [102,111,111,98,97,114]

взрываться
Инверсия взрыва.

jq «взорваться»
[65, 66, 67]
=> «Азбука»

раскол
Разбивает входную строку по аргументу-разделителю.

jq ´split (",") ´
"а, б, в, г, д,"
=> ["а", "б, в, г", "д", ""]

присоединиться (ул.)
Присоединяется к массиву элементов, заданных как входные, с использованием аргумента в качестве разделителя. Это
обратный раскол: то есть бег сплит ("фу") | присоединиться ("фу") над любой входной строкой
возвращает указанную строку ввода.

jq ´join (",") ´
["а", "б, в, г", "д"]
=> "а, б, в, г, д"

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

в то время как (cond; Обновить)
" в то время как (cond; Обновить) функция позволяет многократно применять обновление к . до конд
ложно

Обратите внимание, что в то время как (cond; Обновить) внутренне определяется как рекурсивная функция jq. Рекурсивный
звонки в в то время как не будет потреблять дополнительную память, если обновление производит не более одного
вывод для каждого входа. См. Дополнительные темы ниже.

jq ´ [в то время как (. <100;. * 2)] ´
1
=> [1,2,4,8,16,32,64]

до (cond; следующий)
" до (cond; следующий) функция позволяет многократно применять выражение следующий,
изначально для . затем на собственный выход, пока конд правда. Например, это можно использовать
для реализации факториальной функции (см. ниже).

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

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

рекурсивный (е), рекурсивный рекурсивный (f; состояние), recurse_down
" рекурсивный (е) функция позволяет выполнять поиск в рекурсивной структуре и извлекать
интересные данные со всех уровней. Предположим, ваш ввод представляет файловую систему:

{"name": "/", "children": [
{"название": "/ бен", "дети": [
{"название": "/ bin / ls", "дети": []},
{"название": "/ Бен / ш", "дети": []}]},
{"название": "/ Главная", "дети": [
{"name": "/ home / stephen", "children": [
{"name": "/ home / stephen / jq", "children": []}]}]}]}

Теперь предположим, что вы хотите извлечь все существующие имена файлов. Вам нужно получить .name,
.children []. имя, .children []. children []. name, и так далее. Вы можете сделать это с помощью:

рекурсивный (.children []) | .название

При вызове без аргумента рекурсию эквивалентна рекурсивный (. []?).

рекурсивный (е) идентично рекурсивный (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": [{"фу": []}]}, {"фу": []}

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

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

..
Сокращение для рекурсию без аргументов. Это должно напоминать XPath //
оператор. Обратите внимание, что ..и не работает; использовать .. | а вместо. В приведенном ниже примере мы используем
.. | .a? чтобы найти все значения ключей объекта "a" в любом объекте, найденном "ниже" ..

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

окр
Выводит объект, представляющий среду jq.

jq 'env.PAGER'
нуль
=> "меньше"

транспонировать
Транспонируйте возможно зазубренную матрицу (массив массивов). Строки дополняются нулями, поэтому
результат всегда прямоугольный.

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

bsearch (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 и фромджсон встроенные функции выгрузки значений в виде текстов JSON или синтаксического анализа текстов JSON в
значения соответственно. Встроенный tojson отличается от tostring тем, что возвращает tostring
строки не изменены, а tojson кодирует строки как строки JSON.

jq ´ [. [] | tostring] ´
[1, «фу», [«фу»]]
=> ["1", "foo", "[\" foo \ "]"]

jq ´ [. [] | tojson] ´
[1, «фу», [«фу»]]
=> ["1", "\" фу \ "", "[\" фу \ "]"]

jq ´ [. [] | tojson | fromjson] ´
[1, «фу», [«фу»]]
=> [1, "foo", ["foo"]]

Формат струны и побег
" @foo синтаксис используется для форматирования и экранирования строк, что полезно для создания URL-адресов,
документы на таком языке, как HTML или XML, и так далее. @foo может использоваться как фильтр на
собственное, возможные побеги:

@текст:

Объявления нанизыватьподробности см. в этой функции.

@json:

Сериализует ввод как JSON.

@html:

Применяет экранирование HTML / XML путем сопоставления символов <> & ´ " к их сущности
эквиваленты <, >, ДОСТУПНОСТЬ &, ', ".

@ури:

Применяет процентное кодирование, сопоставляя все зарезервированные символы URI с % XX последовательность.

@csv:

Входными данными должен быть массив, и он отображается как CSV с двойными кавычками для
строки и кавычки, экранированные повторением.

@тсв:

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

@ш:

Входные данные экранированы и подходят для использования в командной строке оболочки POSIX. Если
input - это массив, на выходе будет серия строк, разделенных пробелами.

@ base64:

Входные данные преобразуются в base64, как указано в RFC 4648.

Этот синтаксис можно удобно комбинировать со строковой интерполяцией. Вы можете следить за
@foo токен со строковым литералом. Содержимое строкового литерала будет сбежать.
Однако все интерполяции, сделанные внутри этого строкового литерала, будут экранированы. Например,

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

создаст следующий вывод для ввода {"поиск": "что is jq? "}:

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

Обратите внимание, что косые черты, вопросительный знак и т. Д. В URL-адресе не экранируются, поскольку они были частью
строкового литерала.

jq ´ @ html´
"Это работает, если x <y"
=> «Это работает, если x <y»

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

Финики
jq предоставляет некоторые базовые функции обработки даты, с некоторыми высокоуровневыми и низкоуровневыми
встроенные. Во всех случаях эти встроенные функции имеют дело исключительно со временем в формате UTC.

" от даты iso8601 встроенный анализирует дату и время в формате ISO 8601 до количества секунд
с эпохи Unix (1970-01-01T00: 00: 00Z). В сегодня iso8601 builtin делает обратное.

" с даты Встроенный анализирует строки даты и времени. В настоящее время с даты поддерживает только ISO 8601
строки даты и времени, но в будущем он попытается проанализировать строки даты и времени в большем количестве
форматов.

" назначить свидание builtin - это псевдоним для сегодня iso8601.

" сейчас builtin выводит текущее время в секундах с эпохи Unix.

Также предоставляются низкоуровневые jq-интерфейсы к функциям времени C-библиотеки: стрптайм,
стрфтайм, мктайми гмвремя. Обратитесь к документации вашей операционной системы для получения
строки формата, используемые стрптайм и стрфтайм. Примечание: они не обязательно стабильны
интерфейсы в jq, особенно в части их функциональности по локализации.

" гмвремя builtin потребляет несколько секунд с эпохи Unix и выводит "сломанный
время простоя "представление времени в виде массива чисел, представляющих (в этом порядке):
год, месяц (с нуля), день месяца, час дня, минута
час, секунда минуты, день недели и день года - все
на основе одного, если не указано иное.

" мктайм встроенная функция потребляет "разбитое время" представления времени, выводимого гмвремя
и стрптайм.

" strptime (fmt) встроенный анализирует входные строки, соответствующие FMT аргумент. Вывод находится в
представление "разобранного времени", потребляемое гмвремя и вывод мктайм.

" strftime (fmt) встроенный форматирует время в заданном формате.

Строки формата для стрптайм и стрфтайм описаны в типичной библиотеке C
документация. Строка формата для даты и времени ISO 8601: "% Y-% m-% dT% H:% M:% SZ".

jq может не поддерживать некоторые или все функции этой даты в некоторых системах.

jq «от даты»
"2015-03-05T23:51:47Z"
=> 1425599507

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

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

УСЛОВИЯ И СРАВНЕНИЯ

==, !=
Выражение ´a == b´ даст "истинно", если результат a и b равны (то есть,
если они представляют собой эквивалентные документы JSON) и «false» в противном случае. В частности, струны
никогда не считаются равными числам. Если вы используете Javascript, jq´s == похож на
Javascript´s === - считается, что значения равны только тогда, когда они имеют один и тот же тип, а также
такое же значение.

! = не равно, а ´a! = b´ возвращает значение, противоположное ´a == b´

jq ´. [] == 1´
[1, 1.0, «1», «банан»]
=> правда, правда, ложь, ложь

если-то-иначе
if A тогда B еще C конец будет действовать так же, как B if A выдает значение, отличное от false или
null, но действовать так же, как C в противном случае.

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

Если условие A дает несколько результатов, оно считается "истинным", если любой из них
результат не является ложным или нулевым. Если он дает нулевой результат, он считается ложным.

Если вы используете Элиф A тогда B синтаксис.

jq ´if. == 0 тогда

"ноль" элиф. == 1 затем "один" другой "много" end´ 2 => "много"

>, > =, <=, <
Операторы сравнения >, >=, <=, < вернуть, больше ли их левый аргумент,
больше или равно, меньше или равно или меньше их правильного аргумента
(соответственно).

Порядок такой же, как и для sort, выше.

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

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

Если операнд одного из этих операторов дает несколько результатов, сам оператор
выдаст результат для каждого ввода.

на самом деле является встроенной функцией, а не оператором, поэтому он называется фильтром для
какие вещи могут быть переданы по конвейеру, а не с помощью специального синтаксиса, как в .foo и .бар | .

Эти три производят только значения «истина» и «ложь», поэтому полезны только для подлинных
Логические операции, а не обычная идиома Perl / Python / Ruby
"value_that_may_be_null или по умолчанию". Если вы хотите использовать эту форму «или», выбирая между
два значения вместо оценки условия, см. оператор «//» ниже.

jq ´42 и «строка» ´
нуль
=> правда

jq ´ (истина, ложь) или ложь´
нуль
=> правда, ложь

jq ´ (истина, истина) и (истина, ложь) ´
нуль
=> правда, ложь, правда, ложь

jq ´ [истина, ложь | нет
нуль
=> [ложь, правда]

Альтернатива оператор - //
Фильтр формы a // b дает те же результаты, что и a, Если a дает результаты другие
чем ложный и нуль, В противном случае, 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 ´try .a catch ". is not an object" ´
правда
=> «. не объект»

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

jq ´try error ("какое-то исключение") catch .´
правда
=> "какое-то исключение"

Разрыв внешний of контроль структур
Удобное использование try / catch - вырваться из-под контроля таких структур, как уменьшить, Еогеасп,
в то время как, И так далее.

Например:

# Повторяйте выражение до тех пор, пока оно не вызовет "break" как
# error, затем прекратите повторение, не вызывая повторно ошибку.
# Но если обнаруженная ошибка не является "обрывом", то повторно поднимите ее.
попробуйте повторить (exp) catch. == "break" затем пусто else error;

jq имеет синтаксис для именованных лексических меток, чтобы «прервать» или «вернуться (назад) в»:

этикетка $ out | ... вырваться наружу ...

" перерыв $ label_name выражение заставит программу действовать так, как если бы ближайший
(налево) этикетка $ label_name произведенный пустой.

Отношения между перерыв и соответствующий этикетка лексический: метка должна быть
«видны» из разрыва.

Вырваться из уменьшить, Например:

этикетка $ out | уменьшить. [] как $ item (null; если. == false, то вывести $ out else ... end)

Следующая программа jq выдает синтаксическую ошибку:

вырваться

потому что без ярлыка $ вне виден

? оператор
" ? оператор, используемый как опыт?, это сокращение для стараться EXP.

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

ОЧЕРЕДНАЯ ВЫРАЖЕНИЯ (ПКРЕ)

jq использует библиотеку регулярных выражений Oniguruma, как и php, ruby, TextMate, Sublime Text,
и т. д., поэтому описание здесь будет сосредоточено на специфике jq.

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

STRING | ФИЛЬТР (REGEX)
STRING | ФИЛЬТР (REGEX; ФЛАГИ)
STRING | ФИЛЬТР ([REGEX])
STRING | ФИЛЬТР ([REGEX, FLAGS])

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

FLAGS - это строка, состоящая из одного или нескольких поддерживаемых флагов:

· g - Глобальный поиск (найти все совпадения, а не только первое)

· i - Поиск без учета регистра

· m - Многострочный режим (´.´ соответствует символу новой строки)

· n - Игнорировать пустые совпадения

· p - Включены оба режима: s и m.

· s - Однострочный режим (´ ^ ´ -> ´ \ A´, ´ $ ´ -> ´ \ Z´)

· l - Найдите самые длинные совпадения

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

Чтобы сопоставить пробелы в шаблоне x, используйте escape-последовательность, например \ s, например

· Тест («а \ сб», «х»).

Обратите внимание, что некоторые флаги также могут быть указаны в REGEX, например

· Jq -n ´ («тест», «ТЕСТ», «ТЕСТ», «ТЕСТ») | test ("(? i) te (? - i) st") ´

оценивается как: истина, истина, ложь, ложь.

[Требует 1.5] тест (val), тест (регулярное выражение; флаги)
Подобно совпадение, но не возвращает объекты соответствия, только правда or ложный для того, действительно ли
регулярное выражение соответствует вводу.

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

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

[Требует 1.5] совпадение (val), совпадение (регулярное выражение; флаги)
совпадение выводит объект для каждого найденного совпадения. В матчах есть следующие поля:

· смещение - смещение в кодовых точках UTF-8 от начала ввода

· - длина совпадения в кодовых точках UTF-8

· string - строка, которой она соответствует

· перехватывает - массив объектов, представляющих группы захвата.

Объекты группы захвата имеют следующие поля:

· смещение - смещение в кодовых точках UTF-8 от начала ввода

· - длина в кодовых точках UTF-8 этой группы захвата

· string - строка, которая была захвачена

· имя - название группы захвата (или нуль если он был безымянным)

При захвате групп, которые не совпадают ни с чем, возвращается смещение -1

jq ´match ("(abc) +"; "g") ´
"abc abc"
=> {"смещение": 0, "длина": 3, "строка": "abc", "захватов": [{"смещение": 0, "длина": 3, "строка": "abc", " name ": null}]}, {" смещение ": 4," длина ": 3," строка ":" abc "," захватывает ": [{" смещение ": 4," длина ": 3," строка " : "abc", "name": null}]}

jq ´match ("фу") ´
"фу бар фу"
=> {"смещение": 0, "длина": 3, "строка": "foo", "захватов": []}

jq ´match (["foo", "ig"]) ´
"foo bar FOO"
=> {"смещение": 0, "длина": 3, "строка": "foo", "захватов": []}, {"смещение": 8, "длина": 3, "строка": "FOO "," захватывает ": []}

jq ´match ("foo (? бар)? foo ";" ig ") ´
"фу бар фу фу фу"
=> {"offset": 0, "length": 11, "string": "foo bar foo", "captures": [{"offset": 4, "length": 3, "string": "bar" , "name": "bar123"}]}, {"offset": 12, "length": 8, "string": "foo foo", "captures": [{"offset": -1, "length" : 0, «строка»: null, «имя»: «bar123»}]}

jq ´ [совпадение ("."; "g")] | длина
"abc"
=> 3

[Требует 1.5] захват (val), захват (регулярное выражение; флаги)
Собирает именованные захваты в объект JSON с именем каждого захвата в качестве ключа,
и совпавшая строка как соответствующее значение.

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

[Требует 1.5] сканирование (регулярное выражение), сканирование (регулярное выражение; флаги)
Испускать поток неперекрывающихся подстрок ввода, которые соответствуют регулярному выражению в
в соответствии с флагами, если таковые были указаны. Если совпадений нет, поток
пустой. Чтобы захватить все совпадения для каждой входной строки, используйте идиому [ выраж ], например [
сканирование (регулярное выражение) ].

разделить (регулярное выражение; флаги)
Для обратной совместимости раскол разбивается на строку, а не на регулярное выражение.

[Требует 1.5] разбивает (регулярное выражение), разбивает (регулярное выражение; флаги)
Они дают те же результаты, что и их раскол аналоги, но как поток вместо
массив.

[Требует 1.5] sub (регулярное выражение; нанизывать) sub (регулярное выражение; строка; флаги)
Вывести строку, полученную заменой первого совпадения регулярного выражения во входной строке на
нанизывать, после интерполяции. нанизывать должен быть строкой jq и может содержать ссылки
по названным захватам. Именованные захваты, по сути, представлены как объект JSON (как
построен захватить), Чтобы нанизывать, поэтому ссылка на захваченную переменную с именем "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"}],
"realnames": {"anon": "Анонимный трус",
"person1": "Человек Макферсон"}}

Мы хотим создавать сообщения с полем автора, содержащим настоящее имя, например:

{"title": "Frist psot", "author": "Anonymous Coward"}
{"title": "Хорошо написанная статья", "author": "Человек Макферсон"}

Мы используем переменную $ names для хранения объекта realnames, чтобы мы могли ссылаться на него позже.
при поиске имен пользователей авторов:

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

Выражение ехр as $x | ... означает: для каждого значения выражения ехр, запустите остальную часть
конвейер со всем исходным вводом и с $x установить на это значение. Таким образом as
функционирует как нечто вроде цикла foreach.

Подобно тому, как {фу} это удобный способ написания {фу: .foo}, так {$ foo} это удобный способ написания
{foo: $ foo}.

Несколько переменных могут быть объявлены с помощью одного as выражение путем предоставления шаблона
который соответствует структуре ввода (это называется «деструктуризация»):

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

Объявления переменных в шаблонах массивов (например, . as [сначала $, $ second]) привязать к
элементы массива от элемента с нулевым индексом вверх по порядку. Когда нет
значение в индексе для элемента шаблона массива, нуль привязан к этой переменной.

Переменные ограничены остальной частью выражения, которое их определяет, поэтому

.realnames как $ names | (.posts [] | {название, автор: $ 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 выполняется для каждого элемента входного массива).
Аргументы функции больше похожи на обратные вызовы, чем на аргументы значения. Это
важно понять. Учитывать:

определение foo (f): f | f;
5 | foo (. * 2)

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

Если вам нужно поведение аргумента значение для определения простых функций, вы можете просто использовать
переменная:

def addvalue (f): f as $ f | карта (. + $ f);

Или воспользуйтесь сокращением:

def addvalue ($ f): ...;

С любым определением addvalue (.foo) добавит текущий ввод .foo поле каждому
элемент массива.

Допускается несколько определений с использованием одного и того же имени функции. Каждое новое определение заменяет
предыдущий для того же количества аргументов функции, но только для ссылок из
функции (или основная программа) после переопределения.

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

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

Уменьшить
" уменьшить синтаксис в jq позволяет объединить все результаты выражения с помощью
собирая их в один ответ. В качестве примера передадим [3,2,1] к этому
выражение:

уменьшить. [] как $ item (0;. + $ item)

Для каждого результата, который . [] производит, . + $ пункт запускается для накопления промежуточной суммы,
начиная с 0. В этом примере . [] дает результаты 3, 2 и 1, поэтому эффект
похоже на запуск чего-то вроде этого:

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

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

предел (п; опыт)
" предел функция извлекает до n выходы из ехр.

jq ´ [предел (3;. [])] ´
[0,1,2,3,4,5,6,7,8,9]
=> [0,1,2]

первый (выражение), последний (выражение), nth (n; выражение)
" первый (выражение) и последний (выражение) функции извлекают первое и последнее значения из выраж,
соответственно.

" nth (n; выражение) функция извлекает n-е значение, выводимое с помощью выраж. Это можно определить как
защиту nth (n; выражение): последний (предел (n + 1; выражение));, Обратите внимание, что nth (n; выражение) не поддерживает
отрицательные значения n.

jq ´ [первый (диапазон (.)), последний (диапазон (.)), n-й (./ 2; диапазон (.))] ´
10
=> [0,9,5]

первый, прошлой, nth (n)
" первый и последний функции извлекают первое и последнее значения из любого массива в ..

" nth (n) функция извлекает n-е значение любого массива в ..

jq ´ [диапазон (.)] | [первый, последний, энный(5)] ´
10
=> [0,9,5]

Еогеасп
" Еогеасп синтаксис похож на уменьшить, но предназначен для создания предел
и редукторы, дающие промежуточные результаты (см. пример).

Форма Еогеасп EXP as $ var (В ЭТОМ; ОБНОВИТЬ; ИЗВЛЕКАТЬ), подобно уменьшить, INIT оценивается
один раз для получения значения состояния, затем каждый вывод EXP связан с $ var, ОБНОВЛЕНИЕ ПО is
оценивается для каждого результата EXP с текущим состоянием и с $ var видимый. Каждое значение
вывод ОБНОВЛЕНИЕ ПО заменяет предыдущее состояние. Ну наконец то, ВЫПИСКА оценивается для каждого нового
состояние для извлечения вывода Еогеасп.

В основном это полезно только для построения уменьшить- а также предел-подобные функции. Но это
гораздо более общий, поскольку он позволяет частичное сокращение (см. пример ниже).

jq ´ [foreach. [] как $ item ([[], []]; если $ item == null, то [[],. [0]] else [(. [0] + [$ item]), [ ]] конец; если $ item == null, то. [1] иначе пустой конец)] ´
[1,2,3,4, null, «a», «b», null]
=> [[1,2,3,4], ["а", "б"]]

Рекурсия
Как описано выше, рекурсию использует рекурсию, и любая функция jq может быть рекурсивной. В
в то время как Встроенный также реализован с точки зрения рекурсии.

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

Например:

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

def while (cond; update):
def _ while:
если cond then., (update | _ while) else empty end;
_пока;

def повтор (exp):
защита _repeat:
опыт, _repeat;
_повторение;

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

Даже оператор запятой является генератором, сначала генерирующим значения, сгенерированные
выражение слева от запятой, то для каждого из них значения генерируются
выражение справа от запятой.

" пустой Встроенный - это генератор, который производит нулевые выходные данные. В пустой встроенная
возвращается к предыдущему выражению генератора.

Все функции jq могут быть генераторами, просто используя встроенные генераторы. Также возможно
для определения новых генераторов, используя только рекурсию и оператор запятой. Если рекурсивный
вызов (ы) находится (находятся) "в хвостовой позиции", тогда генератор будет эффективным. В примере
ниже рекурсивного вызова _диапазон себе находится в положении хвоста. Пример демонстрирует
три продвинутых темы: хвостовая рекурсия, построение генератора и подфункции.

jq ´def range (init; upto; by): def _range: if (by> 0 и. <upto) или (by <0 and.> upto) then., ((. + by) | _range) else. конец; если по == 0, то init else init | _range end | выберите ((по> 0 и. <до) или (по <0 и.> до)); диапазон (0; 10; 3) ´
нуль
=> 0, 3, 6, 9

jq ´def while (cond; update): def _ while: if cond then., (update | _ while) else empty end; _пока; [в то время как (. <100;. * 2)] ´
1
=> [1,2,4,8,16,32,64]

МАТЕМАТИКА

jq в настоящее время поддерживает только числа с плавающей запятой двойной точности (754-битные) IEEE64.

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

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

Ввода / вывода

В настоящее время jq имеет минимальную поддержку ввода-вывода, в основном в форме контроля над тем, когда
считываются входы. Для этого предусмотрены две встроенные функции: вход и затраты, что читал
из одних и тех же источников (например, STDIN, файлы, названные в командной строке) как сам jq. Эти
две встроенные команды и собственные действия чтения jq могут чередоваться друг с другом.

Одна встроенная функция обеспечивает минимальные возможности вывода, отлаживать. (Напомним, что программа jq
выходные значения всегда выводятся как тексты JSON на стандартный вывод.) отлаживать встроенный может иметь
поведение, зависящее от приложения, например, для исполняемых файлов, которые используют libjq C API, но не
сам исполняемый файл jq.

вход
Выводит один новый ввод.

затраты
Выводит все оставшиеся входы один за другим.

Это в первую очередь полезно для сокращения вводов программы.

отлаживать
Вызывает сообщение отладки на основе входного значения. Исполняемый файл jq обертывает
входное значение с ["ОТЛАЖИВАТЬ:", ] и печатает это и новую строку на stderr,
компактно. Это может измениться в будущем.

имя_входного_файла
Возвращает имя файла, входные данные которого в данный момент фильтруются. Обратите внимание, что это будет
не работает, если jq не работает в локали UTF-8.

input_line_number
Возвращает номер строки ввода, который в данный момент фильтруется.

STREAMING

Для --транслировать опция jq может анализировать входящие тексты в потоковом режиме, позволяя jq
программы для начала обработки больших текстов JSON сразу, а не после синтаксического анализа
завершает. Если у вас есть один текст JSON размером 1 ГБ, потоковая передача позволит вам
чтобы обработать это намного быстрее.

Однако с потоковой передачей справиться непросто, поскольку программа jq будет иметь [ ,
] (и несколько других форм) в качестве входных данных.

Предусмотрено несколько встроенных функций, упрощающих обработку потоков.

В приведенных ниже примерах используется потоковая форма [0, [1]], Которая является
[[0],0],[[1,0],1],[[1,0]],[[1]].

Формы потоковой передачи включают [ , ] (чтобы указать любое скалярное значение, пустой массив,
или пустой объект), и [ ] (чтобы указать конец массива или объекта). Будущее
версии jq запускаются с --транслировать и -seq может выводить дополнительные формы, такие как ["ошибка
сообщение"] когда вводимый текст не удается проанализировать.

truncate_stream (выражение_потока)
Принимает число в качестве входных данных и обрезает соответствующее количество элементов пути из
слева от выходных данных данного потокового выражения.

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

из потока (выражение_потока)
Выводит значения, соответствующие выводам выражения потока.

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

направлять
" направлять builtin выводит свои входные данные в потоковой форме.

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

ЗАДАНИЕ

Назначение в jq работает немного иначе, чем в большинстве языков программирования. jq не
различать ссылки и копии чего-либо - два объекта или массива
либо равны, либо не равны, без каких-либо дополнительных понятий «один и тот же объект» или «нет»
тот же объект ».

Если у объекта есть два поля, которые являются массивами, .foo и .бар, и вы что-то добавляете в
.foo, то .бар больше не станет. Даже если вы только что установили .бар = .foo. Если вы использовали
программированию на таких языках, как Python, Java, Ruby, Javascript и т. д., тогда вы можете подумать
из него, как будто jq делает полную глубокую копию каждого объекта, прежде чем он выполнит присваивание
(что касается производительности, на самом деле этого не происходит, но это общая идея).

Все операторы присваивания в jq имеют выражения пути в левой части.

=
Фильтр .foo = 1 примет на входе объект и создаст на выходе объект с
Поле "foo" установлено в 1. В jq нет понятия "модификация" или "изменение" чего-либо -
все значения jq неизменяемы. Например,

.foo = .бар | .foo.баз = 1

не будет побочного эффекта установки .bar.baz равным 1, поскольку похожий
программа на Javascript, Python, Ruby или других языках. В отличие от этих языков (но
как Haskell и некоторые другие функциональные языки), нет понятия двух массивов или
объекты, являющиеся «одним массивом» или «одним и тем же объектом». Они могут быть равными или не равными, но
если мы изменим одно из них, другое ни при каких обстоятельствах не изменится за нашей спиной.

Это означает, что невозможно построить циклические значения в jq (например, массив,
первый элемент - это сам). Это сделано намеренно и гарантирует, что все, что jq
Программа может быть представлена ​​в формате JSON.

Обратите внимание, что левая часть ´ = ´ относится к значению в ., таким образом $ var.foo = 1 не будет работать
как и ожидалось ($ var.foo не является допустимым или полезным выражением пути в .); использовать $ var | .foo = 1
.

Если правая часть ´ = ´ дает несколько значений, то для каждого такого значения jq будет
установите для путей с левой стороны значение, а затем он выведет измененный ..
Например, (.a, .b) =ассортимент(2) выходы {"a": 0, "b": 0}, то {"a": 1, "b": 1}. Обновление"
формы назначения (см. ниже) этого не делают.

Обратите внимание, что .a, .b = 0 не устанавливает .a и .b, Но (.a, .b) = 0 устанавливает оба.

|=
Наряду с оператором присваивания ´ = ´, jq предоставляет оператор «обновления» ´ | = ´, который
берет фильтр с правой стороны и определяет новое значение для свойства .
присваивается, пропуская через это выражение старое значение. Например, .foo | =
. + 1 создаст объект с полем «foo», установленным на вход «foo» плюс 1.

Этот пример должен показать разницу между ´ = ´ и ´ | = ´:

Предоставьте ввод ´ {"a": {"b": 10}, "b": 20} ´ для программ:

.a = .b .a | = .b

Первый установит поле «a» ввода в поле «b» ввода и произведет
вывод {"a": 20}. Последний установит поле "a" ввода в поле "a".
Поле "b", производящее {"a": 10}.

Левая часть может быть любым общим выражением пути; видеть дорожка().

Обратите внимание, что левая часть ´ | = ´ относится к значению в ., таким образом $ var.foo |= . + 1 не будет
работать как положено ($ var.foo не является допустимым или полезным выражением пути в .); использовать $ var | .foo
|= . + 1 .

Если правая часть выводит несколько значений, будет использоваться только последнее.

jq ´ (.. | select (type == "boolean")) | = if. то 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 | =. + ["это здорово"]

В этом примере строка "это отлично" добавляется к массиву "комментариев" каждого сообщения в
ввод (где ввод - это объект с полем «сообщения», которое представляет собой массив сообщений).

Когда jq встречает присвоение типа ´a = b´, он записывает "путь", выбранный для выбора
часть входного документа при выполнении. Затем этот путь используется, чтобы найти, какая часть
ввод, который нужно изменить при выполнении задания. Любой фильтр можно использовать на
левая часть равенства - независимо от того, какой путь он выберет из входных данных, будет там, где
присвоение выполнено.

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

.posts [] | выберите (.author == "stedolan")

Пути, предоставленные этой операцией, указывают на каждый из сообщений, написанных "stedolan", и
мы можем прокомментировать каждый из них так же, как и раньше:

(.posts [] | select (.author == "stedolan") | .comments) | =
. + ["ужасно."]

МОДУЛИ

jq имеет систему библиотек / модулей. Модули - это файлы, имена которых заканчиваются на .jq.

Модули, импортированные программой, ищутся по пути поиска по умолчанию (см. Ниже). В
Импортировать и включают директивы позволяют импортеру изменять этот путь.

Пути в пути поиска могут быть заменены различными способами.

Для путей, начинающихся с «~ /», домашний каталог пользователя заменяется на «~».

Для путей, начинающихся с "$ ORIGIN /", путь к исполняемому файлу jq заменяется на
«$ ORIGIN».

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

Директивы импорта могут дополнительно указывать путь поиска, к которому добавляется значение по умолчанию.

Путь поиска по умолчанию - это путь поиска, указанный для -L параметр командной строки, иначе
["~ / .jq", "$ ORIGIN /../ lib / jq", "$ ORIGIN / ../ Lib"].

Нулевые и пустые строковые элементы пути прекращают обработку пути поиска.

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

Последовательные компоненты с одинаковыми именами не допускаются во избежание двусмысленности (например,
"фу / фу").

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

Если «$ HOME / .jq» - это файл, он загружается в основную программу.

Импортировать ОтносительнаяПутьСтрока as ИМЯ [ ];
Импортирует модуль, найденный по заданному пути, относительно каталога в пути поиска. A ".jq"
суффикс будет добавлен к строке относительного пути. Символы модуля имеют префикс
"НАЗВАНИЕ::".

Необязательные метаданные должны быть постоянным выражением jq. Это должен быть объект с ключами
например, "домашняя страница" и так далее. В настоящее время jq использует только «поисковый» ключ / значение
метаданные. Метаданные также доступны пользователям через модульмета встроенный.

Ключ «поиска» в метаданных, если он присутствует, должен иметь значение строки или массива (array
струн); это путь поиска, который будет добавлен к пути поиска верхнего уровня.

включают ОтносительнаяПутьСтрока [ ];
Импортирует модуль, найденный по заданному пути, относительно каталога в пути поиска, как если бы он
были включены на место. К строке относительного пути будет добавлен суффикс ".jq". В
символы модуля импортируются в пространство имен вызывающего абонента, как если бы содержимое модуля
были включены напрямую.

Необязательные метаданные должны быть постоянным выражением jq. Это должен быть объект с ключами
например, "домашняя страница" и так далее. В настоящее время jq использует только «поисковый» ключ / значение
метаданные. Метаданные также доступны пользователям через модульмета встроенный.

Импортировать ОтносительнаяПутьСтрока as $ NAME [ ];
Импортирует файл JSON, найденный по заданному пути, относительно каталога в пути поиска. А
Суффикс ".json" будет добавлен к строке относительного пути. Данные файла будут
доступно как $ NAME :: NAME.

Необязательные метаданные должны быть постоянным выражением jq. Это должен быть объект с ключами
например, "домашняя страница" и так далее. В настоящее время jq использует только «поисковый» ключ / значение
метаданные. Метаданные также доступны пользователям через модульмета встроенный.

Ключ «поиска» в метаданных, если он присутствует, должен иметь значение строки или массива (array
струн); это путь поиска, который будет добавлен к пути поиска верхнего уровня.

модуль ;
Эта директива не является обязательной. Это не требуется для правильной работы. Это служит
только цель предоставления метаданных, которые могут быть прочитаны с помощью модульмета встроенный.

Метаданные должны быть постоянным выражением jq. Это должен быть объект с такими ключами, как
"домашняя страница". В настоящее время jq не использует эти метаданные, но они доступны для пользователей.
через модульмета встроенный.

модульмета
Принимает имя модуля в качестве входных и выводит метаданные модуля как объект с
модуль импорта (включая метаданные) как значение массива для ключа "deps".

Программы могут использовать это для запроса метаданных модуля, которые они затем могут использовать для
Например, найдите, загрузите и установите недостающие зависимости.

Используйте jq в Интернете с помощью сервисов onworks.net