jq - 云端在线

程序：

您的姓名

jq - 命令行 JSON 处理器

概要

jq [选项...] 过滤 [档...]

jq 可以通过选择、迭代、减少和其他方式以各种方式转换 JSON
整理 JSON 文档。 例如，运行命令 jq '地图（。价格） | 添加 将
将一组 JSON 对象作为输入并返回其“价格”字段的总和。

jq 也可以接受文本输入，但默认情况下， jq 读取 JSON 实体流
（包括数字和其他文字）来自 标准输入. 空格只需要分隔
实体，例如 1 和 2，以及 true 和 false。 一个或多个 档 可以指定，其中
案件 jq 将从这些读取输入。

选项 描述在 调用 JQ 部分; 他们主要关注输入和输出
格式化。 这 过滤 是用jq语言写的，指定了如何转换
输入文件或文档。

滤波器

jq 程序是一个“过滤器”：它接受一个输入，并产生一个输出。 有很多的
内置过滤器，用于提取对象的特定字段，或将数字转换为
一个字符串，或各种其他标准任务。

过滤器可以通过多种方式组合 - 您可以将一个过滤器的输出通过管道传输到
另一个过滤器，或将过滤器的输出收集到一个数组中。

一些过滤器会产生多种结果，例如有一种过滤器会产生所有
其输入数组的元素。 将该过滤器管道化到第二个运行第二个过滤器
数组的每个元素。 通常，可以通过循环和迭代完成的事情
在其他语言中只是通过在 jq 中将过滤器粘合在一起来完成。

重要的是要记住，每个过滤器都有一个输入和一个输出。 甚至文字
像 "hello" 或 42 是过滤器——它们接受一个输入但总是产生与
输出。 结合两个过滤器的操作，如加法，通常提供相同的输入
两者并结合结果。 因此，您可以将平均滤波器实现为 加 / 长度
- 将输入数组同时提供给 加 过滤器和 长度 过滤然后执行
司。

但这已经超越了我们自己。 :) 让我们从更简单的事情开始：

调用 JQ

jq 过滤器在 JSON 数据流上运行。 jq 的输入被解析为一个序列
以空格分隔的 JSON 值，它们通过提供的过滤器在一个
时间。 过滤器的输出被写入标准输出，同样作为一个序列
空格分隔的 JSON 数据。

注意：注意 shell 的引用规则很重要。 作为一般规则，最好是
总是引用（用单引号字符）jq 程序，因为太多的字符用
jq 的特殊含义也是 shell 元字符。 例如， jq “富” 将失败
大多数 Unix shell，因为这将与 jq FOO，这通常会失败
因为 FOO is 不能 定义. 使用 Windows 命令外壳 (cmd.exe) 时，最好
在命令行上给出时，在 jq 程序周围使用双引号（而不是 -f
程序文件 选项），但是 jq 程序中的双引号需要反斜杠转义。

您可以使用一些命令行来影响 jq 读取和写入其输入和输出的方式
opţiuni:

· - 版:

输出 jq 版本并以零退出。

· --seq:

使用 应用程序/json-seq 用于在 jq 的输入中分隔 JSON 文本的 MIME 类型方案
和输出。 这意味着在之前打印了 ASCII RS（记录分隔符）字符
输出中的每个值和 ASCII LF（换行）在每次输出后打印。 输入
无法解析的 JSON 文本将被忽略（但会发出警告），丢弃所有
后续输入直到下一个 RS。 这更多地也解析了 jq 的输出，而没有
--seq 选项。

· - 溪流:

以流方式解析输入，输出路径和叶值数组
（标量和空数组或空对象）。 例如， “一种” 成为 [[]，“一种”]及
[[],"a",["b"]] 成为 [[0],[]], [[1],"a"]及 [[1,0],"b"].

这对于处理非常大的输入很有用。 结合使用这个
过滤和 减少 和 的foreach 语法以逐步减少大输入。

· --啜饮/-s:

读取整个输入，而不是为输入中的每个 JSON 对象运行过滤器
流入一个大数组并只运行一次过滤器。

· --原始输入/-R:

不要将输入解析为 JSON。 相反，每一行文本都作为
细绳。 如果结合 --啜饮，然后整个输入作为一个
单长字符串。

· --null-输入/-n:

不要阅读任何输入！ 相反，过滤器运行一次，使用 空 作为输入。
这在使用 jq 作为一个简单的计算器或构建 JSON 数据时很有用
刮。

· --紧凑型输出 / -c:

默认情况下，jq 漂亮地打印 JSON 输出。 使用此选项将导致更多
通过将每个 JSON 对象放在一行上来压缩输出。

· - 标签:

为每个缩进级别使用一个制表符而不是两个空格。

· --缩进 n:

使用给定数量的空格（不超过 8 个）进行缩进。

· --颜色输出 / -C 和 --单色输出 / -M:

默认情况下，如果写入终端，jq 会输出彩色 JSON。 你可以强迫它
即使写入管道或文件，也会产生颜色 -C，并禁用颜色 -M.

· --ascii 输出 / -a:

jq 通常将非 ASCII Unicode 代码点输出为 UTF-8，即使输入指定
它们作为转义序列（如“\u03bc”）。 使用此选项，您可以强制 jq
生成纯 ASCII 输出，每个非 ASCII 字符都替换为等效的
转义序列。

· --无缓冲

在打印每个 JSON 对象后刷新输出（如果您正在缓慢地进行管道传输，则很有用）
数据源到 jq 和管道 jq 的输出别处）。

· --排序键 / -S:

按排序顺序输出带有键的每个对象的字段。

· --原始输出 / -r:

使用此选项，如果过滤器的结果是字符串，则将直接写入
到标准输出，而不是格式化为带引号的 JSON 字符串。 这个可以
可用于使 jq 过滤器与非基于 JSON 的系统通信。

· --join-输出 / -j:

喜欢 -r 但 jq 不会在每次输出后打印换行符。

· -f 文件名 / - 从文件 文件名:

从文件而不是从命令行读取过滤器，如 awk 的 -f 选项。 你
也可以使用“#”来发表评论。

· -L目录 / -L 目录:

前置 目录 到模块的搜索列表。 如果使用此选项，则没有
使用内置搜索列表。 请参阅下面有关模块的部分。

· -e / --退出状态:

如果最后一个输出值不是，则将 jq 的退出状态设置为 0 false 也不 空,
1 如果最后一个输出值是 false or 空, 或者 4 如果没有有效结果
产生。 如果出现任何使用问题或系统错误，通常 jq 会以 2 退出，3
如果有 jq 程序编译错误，或者如果 jq 程序运行，则为 0。

· --arg 姓名 折扣值:

此选项将一个值作为预定义变量传递给 jq 程序。 如果你运行 jq
--arg FOO 酒吧， 然后 $ foo 在程序中可用并具有值 “酒吧”.
需要注意的是 折扣值 将被视为一个字符串，所以 --arg FOO 123 会绑定 $ foo 至 “123”.

· --argjson 姓名 JSON 文本:

此选项将 JSON 编码的值作为预定义变量传递给 jq 程序。 如果
你用 jq 运行 --argjson FOO 123， 然后 $ foo 在程序中可用并具有
折扣值 123.

· --slurp文件 变量名 文件名:

此选项读取指定文件中的所有 JSON 文本并绑定一个数组
将 JSON 值解析为给定的全局变量。 如果你运行 jq --arg文件 FOO 酒吧,
然后 $ foo 在程序中可用，并有一个数组，其元素对应于
名为的文件中的文本 酒吧.

· --arg文件 变量名 文件名:

不使用。 用 --slurp文件 代替。

（这个选项就像 --slurp文件，但是当文件只有一个文本时，那就是
使用，否则使用文本数组，如 --slurp文件.)

· --运行测试 [文档名称]:

在给定的文件或标准输入中运行测试。 这必须是给出的最后一个选项
并且不支持所有前面的选项。 输入由注释行组成，为空
行和程序行后跟一个输入行，输出行数与
预期（每个输出一个），以及一个终止的空行。 编译失败测试
从仅包含“%%FAIL”的行开始，然后是包含要执行的程序的行
编译，然后包含一条错误消息的行与实际进行比较。

请注意，此选项可能会向后不兼容地更改。

基本 滤波器

.
绝对最简单（也是最不有趣）的过滤器是 .. 这是一个过滤器
输入并产生不变的输出。

由于默认情况下 jq 会漂亮地打印所有输出，因此这个简单的程序可能是一种有用的方式
格式化 JSON 输出，例如， 卷曲.

jq '.'
“你好，世界！”
=> “你好，世界！”

.foo, .foo.bar
最简单的 有用 过滤器是 .foo. 当给定一个 JSON 对象（又名字典或哈希）作为
输入，它在键“foo”处产生值，如果不存在则为空。

如果键包含特殊字符，则需要用双引号将其括起来，例如
这个： ."foo$".

表单过滤器 .foo.bar 相当于 .foo|.bar.

jq '.foo'
{"foo": 42, "bar": "不太有趣的数据"}
=> 42

jq '.foo'
{“notfoo”：真，“alsonotfoo”：假}
=> 空

jq ´.["foo"]´
{“富”：42}
=> 42

.foo？
就像 .foo，但在以下情况下甚至不输出错误 . 不是数组或对象。

jq '.foo?'
{"foo": 42, "bar": "不太有趣的数据"}
=> 42

jq '.foo?'
{“notfoo”：真，“alsonotfoo”：假}
=> 空

jq ´.["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::酒吧 和 .foo.bar 不会。

? “operator”也可以与切片操作符一起使用，如 .[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] 将产生的数字为三
单独的结果，而不是作为单个数组。

您也可以在对象上使用 this，它将返回对象的所有值。

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[]'
{“用户”：“stedolan”，“项目”：[“jq”，“wikiflow”]}
=> "stedolan", "jq", "wikiflow"

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

|
| 运算符通过将左侧过滤器的输出馈入来组合两个过滤器
右边那个的输入。 它与 Unix shell 的管道几乎相同，如果
你已经习惯了。

如果左边的一个产生多个结果，右边的将运行
这些结果中的每一个。 所以，表达式 .[] | .foo 检索每个的“foo”字段
输入数组的元素。

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

类型 AND 价值观

jq 支持与 JSON 相同的一组数据类型 - 数字、字符串、布尔值、数组、
对象（在 JSON 中是只有字符串键的哈希）和“null”。

布尔值、空值、字符串和数字的编写方式与 JavaScript 相同。 就像
jq 中的所有其他内容，这些简单的值接受一个输入并产生一个输出 - 42 是一个
接受输入的有效 jq 表达式，忽略它，并返回 42。

排列 施工 - []
就像在 JSON 中一样， [] 用于构造数组，如 [1,2,3]. 数组的元素可以
是任何 jq 表达式。 收集所有表达式产生的所有结果
成一个大阵列。 您可以使用它从已知数量的值中构造一个数组
（如在 [.foo, 。酒吧， .baz]) 或将过滤器的所有结果“收集”到一个数组中（如
in [.项目[].名称])

一旦你理解了“,”操作符，你就可以用不同的方式查看 jq 的数组语法
光：表达 [1,2,3] 没有使用逗号分隔数组的内置语法，
而是应用 [] 运算符（收集结果）到表达式 1,2,3（其中
产生三种不同的结果）。

如果你有过滤器 X 产生四个结果，那么表达式 [X] 会产生一个
单个结果，一个包含四个元素的数组。

jq '[.user, .projects[]]'
{“用户”：“stedolan”，“项目”：[“jq”，“wikiflow”]}
=> ["stedolan", "jq", "wikiflow"]

对象 - {}
像 JSON 一样， {} 用于构建对象（又名字典或哈希），如： {“一种”：
“乙”： 17}.

如果键是“合理的”（所有字母字符），则可以省略引号。
该值可以是任何表达式（尽管如果它是
复杂的），它被应用于 {} 表达式的输入（记住，所有过滤器
有一个输入和一个输出）。

{富：.bar}

将产生 JSON 对象 {“富”： 42} 如果给定 JSON 对象 {“酒吧”：42， “巴兹”：43}.
您可以使用它来选择对象的特定字段：如果输入是具有
“user”、“title”、“id”和“content”字段，而您只需要“user”和“title”，您可以
写

{用户：.user，标题：.title}

因为这很常见，所以有一个快捷语法： {用户， 标题}.

如果其中一个表达式产生多个结果，则多个字典将被
产生。 如果输入的

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

那么表达式

{用户，标题：.titles[]}

将产生两个输出：

{"user":"stedolan", "title": "JQ Primer"}
{"user":"stedolan", "title": "更多 JQ"}

将括号放在键周围意味着它将被评估为表达式。 随着
与上面相同的输入，

{（.用户）：.标题}

产生

{"stedolan": ["JQ Primer", "更多 JQ"]}

jq ´{用户，标题：.titles[]}´
{"user":"stedolan","titles":["JQ Primer", "More JQ"]}
=> {"user":"stedolan", "title": "JQ Primer"}, {"user":"stedolan", "title": "更多 JQ"}

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

内置 操作员 AND 职能

一些 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。

将一个字符串乘以一个数字会产生多个字符串的串联
倍。 “X” * 0 产生 空.

将一个字符串除以另一个使用第二个作为分隔符拆分第一个。

将两个对象相乘将递归合并它们：这类似于加法，但如果两者都
对象包含同一个键​​的值，值是对象，两者合并
用同样的策略。

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

jq´. / ", "´
“a，b，c，d，e”
=> ["a","b,c,d","e"]

jq ´{"k": {"a": 1, "b": 2}} * {"k": {"a": 0,"c": 3}}´
空
=> {"k": {"a": 0, "b": 2, "c": 3}}

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

长度
内置函数 长度 获取各种不同类型值的长度：

· 长度 绳子 是它包含的 Unicode 代码点的数量（这将是
如果它是纯 ASCII，则与其 JSON 编码的长度（以字节为单位）相同）。

· 长度 排列 是元素的数量。

· 长度 对象 是键值对的数量。

· 长度 空 是零。

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

钥匙， 键_未排序
内置函数 键，当给定一个对象时，在数组中返回它的键。

键按 unicode 代码点顺序“按字母顺序”排序。 这不是订单
这在任何特定语言中都特别有意义，但您可以指望它是
无论区域设置如何，对于具有相同键集的任何两个对象都相同。

什么时候 键 给定一个数组，它返回该数组的有效索引：整数
从 0 到 length-1。

键_未排序 功能就像 键, 但如果输入是一个对象，那么键
不会被排序，而是键将大致按插入顺序排列。

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'地图（具有(2))'
[[0,1], ["a","b","c"]]
=> [假，真]

in
内置函数 in 返回输入键在给定对象中，或输入索引
对应于给定数组中的一个元素。 从本质上讲，它是
具有.

jq ´.[] | in({"foo": 42})´
["foo", "bar"]
=> 真，假

jq 'map(in([0,1]))'
[2 0]
=> [假，真]

路径（路径表达式）
输出给定路径表达式的数组表示 .. 输出是数组
字符串（objects0 中的键和/或数字（数组索引。

路径表达式是 jq 表达式，如 .a，但也 .[]. 有两种类型的路径
表达式：可以完全匹配的表达式和不能完全匹配的表达式。 例如， .abc 是一个
精确匹配路径表达式，而 .a[].b 不是。

路径（exact_path_expression） 将产生路径表达式的数组表示
即使它不存在于 .如果 . is 空 或数组或对象。

路径（模式） 将产生匹配路径的数组表示 模式 如果
路径存在于 ..

请注意，路径表达式与普通表达式没有区别。 表达方式
路径（..|选择（类型==“布尔值”）） 输出布尔值的所有路径 .，并且只有
那些路径。

jq '路径(.a[0].b)'
空
=> ["a",0,"b"]

jq '[路径（..）]'
{"a":[{"b":1}]}
=> [[],["a"],["a",0],["a",0,"b"]]

删除（路径表达式）
内置函数 该 从对象中删除键及其对应的值。

jq 'del(.foo)'
{“foo”：42，“bar”：9001，“baz”：42}
=> {"bar": 9001, "baz": 42}

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

to_entry, 来自_条目， 有条目
这些函数在对象和键值对数组之间进行转换。 如果 to_entry
传递一个对象，然后对于每个 k: v 输入中的条目，输出数组包括
{“钥匙”： k, “价值”： v}.

来自_entries 进行相反的转换，并且 with_entries(foo) 是的简写
to_entry | 地图（富） | 来自_entries, 用于对所有键进行一些操作和
对象的值。 来自_entries 接受键、键、名称、值和值作为键。

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

jq 'from_entries'
[{"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 为该输入返回 true，
否则不产生任何输出。

它对过滤列表很有用： [1,2,3] | 地图（选择（。 >= 2）） 会给你 [2,3].

jq '地图（选择（。> = 2））'
[1,5,3,0,7]
=> [5,3,7]

jq ´.[] | 选择（.id ==“第二个”）'
[{"id": "first", "val": 1}, {"id": "second", "val": 2}]
=> {"id": "second", "val": 2}

数组， 对象， 可迭代对象， 布尔值， 号， 法线， 有限， 弦， 空值， 值
标量
这些内置函数只选择数组、对象、可迭代对象（数组或
对象）、布尔值、数字、普通数字、有限数字、字符串、空值、非空值
值和不可迭代的，分别。

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

空的
空的 不返回任何结果。 一个都没有。 甚至不 空.

有时很有用。 你会知道你是否需要它:)

jq '1, 空, 2'
空
=> 1, 2

jq '[1,2,empty,3]'
空
=> [1,2,3]

错误（信息）
产生错误，就像 .a 应用于 null 和对象以外的值会，但是
将给定的消息作为错误值。

$__loc__
生成一个带有“文件”键和“行”键的对象，带有文件名和行号
哪里 $__loc__ 发生，作为值。

jq ´try error("\($__loc__)") catch .´
空
=> "{\"文件\":\" \",\"行\":1}"

地图（x）， 地图值（x）
对于任何过滤器 x, 地图(x) 将为输入数组的每个元素运行该过滤器，并且
产生输出一个新的数组。 地图(.+1) 将增加数组的每个元素
号码。

同样， 地图值（x） 将为每个元素运行该过滤器，但它会返回一个
当一个对象被传递时对象。

地图(x) 相当于 [.[] | x]. 事实上，它是这样定义的。 相似地，
地图值（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}

路径， 路径（节点过滤器）， 叶子路径
路径 输出到其输入中所有元素的路径（除非它不输出
空列表，代表 . 本身）。

路径(f) 输出到任何值的路径 f 是真的。 那是， 路径（数字）
输出所有数值的路径。

叶子路径 是一个别名 路径（标量）; 叶子路径 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 '添加'
[]
=> 空

任何， 任何（条件）， 任何（发电机； 状况）
过滤器 任何 将布尔值数组作为输入，并产生 true 作为输出如果
数组的任何元素是 true.

如果输入是空数组， 任何 回报 false.

任何（条件） form 将给定的条件应用于输入数组的元素。

任何（发电机； 状况） form 将给定的条件应用于所有的输出
给定的发电机。

jq '任何'
[真假]
=> 真

jq '任何'
[假，假]
=> 假

jq '任何'
[]
=> 假

全部， 所有（条件）， 所有（发电机； 状况）
过滤器 所有 将布尔值数组作为输入，并产生 true 作为输出如果
数组的所有元素都是 true.

全部（条件） form 将给定的条件应用于输入数组的元素。

所有（发电机； 状况） form 将给定的条件应用于所有的输出
给定的发电机。

如果输入是空数组， 所有 回报 true.

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)] 以数组形式获取范围。

one 参数形式生成从 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

弦
弦 函数将其输入打印为字符串。 字符串保持不变，所有
其他值是 JSON 编码的。

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

类型
类型 函数将其参数的类型作为字符串返回，它是空值之一，
布尔值、数字、字符串、数组或对象。

jq '地图（类型）'
[0, false, [], {}, null, "你好"]
=> [“数字”，“布尔值”，“数组”，“对象”，“空”，“字符串”]

无穷， 难， 无限， 伊斯南， 是有限的， 是正常的
一些算术运算可以产生无穷大和“非数字”(NaN) 值。 这
无限的 内置返回 true 如果它的输入是无限的。 这 伊斯南 内置返回 true
如果它的输入是 NaN。 这 无穷 内置返回一个正的无限值。 这 南
内置返回一个 NaN。 这 是正常的 如果其输入是正常数字，则 builtin 返回 true。

请注意，除以零会引发错误。

目前，大多数对无穷大、NaN 和次正规数进行运算的算术运算都没有
引发错误。

jq ´.[] | （无限*。）< 0´
[-1, 1]
=> 真，假

jq '无限，南 | 类型
空
=> "数", "数"

分类， sort_by（路径表达式）
分类 函数对其输入进行排序，它必须是一个数组。 值排序在
以下顺序：

· 空

· false

· true

· 数字

· 字符串，按字母顺序（按 unicode 代码点值）

· 数组，按词法顺序

· 对象

对象的排序有点复杂：首先通过比较它们来比较它们
键集（作为按排序顺序的数组），如果它们的键相等，则值是
一键比较。

分类 可用于按对象的特定字段或通过应用任何 jq 过滤器进行排序。

排序依据（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（路径表达式）
分组依据（.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_by(路径表达式), max_by(路径表达式)
查找输入数组的最小或最大元素。

min_by(路径表达式) 和 max_by(路径表达式) 函数允许你指定一个特定的
要检查的领域或财产，例如 min_by(.foo) 找到最小的对象 FOO
领域。

jq 'min'
[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(length)'
[“矮胖”、“培根”、“小猫”、“蝉”、“芦笋”]
=> [“培根”、“粗粒”、“芦笋”]

反转
此函数反转数组。

jq '反向'
[1,2,3,4]
=> [4,3,2,1]

包含（元素）
过滤器 包含(b) 如果 b 完全包含在输入中，将产生 true。 一种
如果 B 是 A 的子串，则字符串 B 包含在字符串 A 中。数组 B 包含在
如果 B 中的所有元素都包含在 A 中的任何元素中，则为数组 A。对象 B 是
如果 B 中的所有值都包含在 A 中的值中，则包含在对象 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 发生。 输入可能是一个数组，在
如果 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]

索引， r索引
输出第一个 (指数) 或最后 (指数) 的发生 s 在输入中。

jq '索引（”，“）'
“a、b、cd、efg、hijk”
=> 3

jq 'rindex(", ")'
“a、b、cd、efg、hijk”
=> 12

内
过滤器 里面(b) 如果输入完全包含在 b 中，将产生 true。 它
本质上是 包含.

jq '里面（“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}]}
=> 假

开始（字符串）
输出 true 如果 。 以给定的字符串参数开头。

jq ´[.[]|startswith("foo")]´
[“fo”，“foo”，“barfoo”，“foobar”，“barfoob”]
=> [假，真，假，真，假]

结尾（str）
输出 true 如果 。 以给定的字符串参数结尾。

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]

爆
爆炸的反义词。

jq“内爆”
[65，66，67]
=> "ABC"

分裂
在分隔符参数上拆分输入字符串。

jq 'split(", ")'
“a，b，c，d，e，”
=> ["a","b,c,d","e",""]

加入（字符串）
连接作为输入给出的元素数组，使用参数作为分隔符。 它是
倒数 分裂: 也就是说，运行 分裂（“富”） | 加入（“富”） 在任何输入字符串上
返回所述输入字符串。

jq '加入（“，”）'
["a","b,c,d","e"]
=> "a, b,c,d, e"

ascii_downcase， ascii_大写
发出输入字符串的副本，其字母字符（az 和 AZ）转换为
指定的情况。

同时（条件； 更新）
同时（条件； 更新） 功能允许您重复应用更新 . 直到 COND
是错误的。

需要注意的是 同时（条件； 更新） 在内部定义为递归 jq 函数。 递归
内调用 而 不会消耗额外的内存，如果 更新 最多产生一个
每个输入的输出。 请参阅下面的高级主题。

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

直到（条件； 下一个）
直到（条件； 下一个） 函数允许您重复应用表达式 下页,
最初到 . 然后到它自己的输出，直到 COND 是真的。 例如，这可以使用
实现阶乘函数（见下文）。

需要注意的是 直到（条件； 下一个） 在内部定义为递归 jq 函数。 递归
内调用 直到（） 不会消耗额外的内存，如果 下页 最多产生一个
每个输入的输出。 请参阅下面的高级主题。

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

递归（f）， 递归， 递归（f; 健康）状况）， 递归向下
递归（f） 函数允许您搜索递归结构，并提取
来自各个层面的有趣数据。 假设您的输入代表一个文件系统：

{“姓名”：“/”，“孩子”：[
{“姓名”： ”/箱“， “孩子们”： [
{“姓名”： ”/ bin / ls“， “孩子们”： []}，
{“姓名”： ”/ bin / sh的“， “孩子们”： []}]}，
{“姓名”： ”/主页“， “孩子们”： [
{"name": "/home/stephen", "children": [
{"name": "/home/stephen/jq", "children": []}]}]}]}

现在假设您要提取所有存在的文件名。 你需要检索 。名称,
.children[].名字, .children[].children[].name， 等等。 你可以这样做：

递归(.children[]) | 。姓名

在没有参数的情况下调用时， 递归 相当于 递归(.[]?).

递归（f） 是完全相同的 递归（f; . != 空值） 并且可以毫无顾虑地使用
递归深度。

递归（f; 状况） 是一个以发射开始的生成器。 然后依次发射
.|f, .|f|f, .|f|f|f, ... 只要计算值满足条件。 为了
例如，要生成所有整数，至少原则上可以这样写 递归(.+1;
正确）.

由于遗留原因， 递归向下 作为调用的别名存在 递归 没有论据。
这个别名被认为 弃用 并将在下一个主要版本中删除。

递归调用 递归 任何时候都不会消耗额外的内存 f 生产于
每个输入最多只有一个输出。

jq '递归（.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 '递归（. * .; . < 20）'
2
=> 2, 4, 16

..
简写 递归 没有论据。 这旨在类似于 XPath //
操作员。 注意 ..一种 不起作用； 用 ..|一个 反而。 在下面的例子中，我们使用
..|.一个？ 在“下面”找到的任何对象中查找对象键“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 是一个插入点，这样数组就会
在 ix 处插入 x 后仍会排序。 如果数组没有排序，bsearch(x)
将返回一个可能不感兴趣的整数。

jq´搜索(0)'
[0,1]
=> 0

jq´搜索(0)'
[1,2,3]
=> -1

jq´搜索(4) 作为 $ix | 如果 $ix < 0 那么 .[-(1+$ix)] = 4 else 。 结尾
[1,2,3]
=> [1,2,3,4]

串 插值 - \（富）
在字符串中，您可以在反斜杠后的括号中放置表达式。 不管是什么
表达式返回将被插入到字符串中。

jq ´"输入的是\(.)，比\(.+1)小XNUMX"´
42
=> "输入是 42，比 43 少 XNUMX"

转化率 往/返 JSON
托森 和 来自json 内置程序将值转储为 JSON 文本或将 JSON 文本解析为
值，分别。 tojson 内置函数与 tostring 的不同之处在于 tostring 返回
字符串未修改，而 tojson 将字符串编码为 JSON 字符串。

jq '[.[]|tostring]'
[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 可以用作过滤器
它自己的，可能的转义是：

@文本:

呼叫 弦，请参阅该函数以了解详细信息。

@json:

将输入序列化为 JSON。

@html:

通过映射字符应用 HTML/XML 转义 <>&´" 到他们的实体
当量 <, >, 和, “, “.

@uri:

应用百分比编码，通过将所有保留的 URI 字符映射到一个 ％XX 序列。

@csv:

输入必须是一个数组，它被呈现为带有双引号的 CSV
字符串和通过重复转义的引号。

@tsv:

输入必须是一个数组，并呈现为 TSV（制表符分隔值）。 每个
输入数组将打印为一行。 字段由单个制表符分隔
（ASCII 0x09）。 输入字符换行符 (ascii 0x0a), 回车 (ascii
0x0d), 制表符 (ascii 0x09) 和反斜杠 (ascii 0x5c) 将作为转义输出
序列 \n, \r, \t, \\ 。

@sh:

输入已转义，适用于 POSIX shell 的命令行。 如果
输入是一个数组，输出将是一系列以空格分隔的字符串。

@base64:

按照 RFC 64 的规定，输入将转换为 base4648。

这种语法可以以一种有用的方式与字符串插值结合使用。 你可以按照一个
@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 "echo \(.)"´
“奥哈拉啤酒”
=> "echo 'O'\\''Hara'\\''s Ale'"

重要日期
jq 提供了一些基本的日期处理功能，有一些高级和低级
内置函数。 在所有情况下，这些内置函数都专门处理 UTC 时间。

从dateiso8601 内置将 ISO 8601 格式的日期时间解析为秒数
自 Unix 时代 (1970-01-01T00:00:00Z) 以来。 这 今日iso8601 内建反之。

从日期 内置解析日期时间字符串。 目前 从日期 仅支持 ISO 8601
日期时间字符串，但将来它会尝试更多地解析日期时间字符串
格式。

迄今为止 内置是一个别名 今日iso8601.

现在 内置输出当前时间，以 Unix 纪元以来的秒数为单位。

还提供了 C 库时间函数的低级 jq 接口： 时间,
时间, 时间及 准时. 请参阅您的主机操作系统的文档以了解
使用的格式字符串 时间 和 时间. 注意：这些不一定稳定
jq 中的接口，特别是关于它们的本地化功能。

准时 自 Unix 纪元以来，builtin 消耗了数秒并输出一个“损坏的
停机时间”将时间表示为一组数字表示（按此顺序）：
年、月（从零开始）、月中的哪一天、一天中的小时、分钟
小时、分钟的秒数、星期几和一年中的哪一天——所有
除非另有说明，否则以一为基础。

时间 内置消耗时间输出的“故障时间”表示 准时
和 时间.

字符串时间(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

条件 AND 比较

==， !=
如果 a 和 b 的结果相等（即，
如果它们代表等效的 JSON 文档），否则为“假”。 尤其是字符串
永远不会被认为等于数字。 如果你来自 Javascript，jq´s == 就像
Javascript 的 === - 仅当它们具有相同的类型时才考虑值相等
相同的值。

!= 是“不等于”，并且 '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 。名称 然后 A 其他 B 结束,
你需要更像 if （。姓名 | 长度） > 0 然后 A 其他 B 结束 代替。

如果条件 A 产生多个结果，并且其中任何一个结果都被认为是“真”
结果不为假或空。 如果它产生零结果，则认为是错误的。

可以将更多案例添加到 if 中 ELIF A 然后 B 语法。

jq '如果 . == 0 那么

“零” elif 。 == 1 然后“一个”否则“许多”结束´ 2 =>“许多”

>, >=, <=， <
比较运算符 >, >=, <=, < 返回他们的左参数是否大于，
大于或等于、小于或等于或小于它们的正确参数
（分别）。

顺序与所描述的相同 分类， 以上。

jq´. < 5´
2
=> 真

和/或/不是
jq 支持普通的布尔运算符和/或/非。 他们有相同的真理标准
as if 表达式 - false 和 null 被认为是“假值”，其他任何东西都是
“真正的价值”。

如果这些运算符之一的操作数产生多个结果，则运算符本身
将为每个输入产生一个结果。

不能 实际上是一个内置函数而不是一个运算符，所以它被称为过滤器
哪些东西可以通过管道传输而不是使用特殊的语法，如 .foo 和 。酒吧 | 不能.

这三个只产生值“真”和“假”，所以只对正版有用
布尔运算，而不是常见的 Perl/Python/Ruby 习语
“value_that_may_be_null 或默认值”。 如果您想使用这种形式的“或”，请在
两个值而不是评估条件，请参阅下面的“//”运算符。

jq ´42 和“一个字符串”´
空
=> 真

jq ´(true, false) 或 false´
空
=> 真，假

jq '(true, true) and (true, false)'
空
=> 真、假、真、假

jq ´[真, 假 | 不是
空
=> [假，真]

可再生 操作者 - //
表单过滤器 a // b 产生相同的结果 a如果 a 产生其他结果
比 false 和 空。 除此以外， a // b 产生相同的结果 b.

这对于提供默认值很有用： .foo // 1 将评估为 1 如果没有 .foo
输入中的元素。 这类似于如何 or 有时在 Python 中使用（jq's or 操作者
保留用于严格的布尔运算）。

jq '.foo // 42'
{“富”：19}
=> 19

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

试着抓
可以通过使用捕获错误 尝试 进出口 捕捉 进出口. 执行第一个表达式，如果
它失败，然后第二个执行错误消息。 处理程序的输出，如果
any, 是输出，就好像它是要尝试的表达式的输出一样。

尝试 进出口 形式用途 空的 作为异常处理程序。

jq 'try .a catch ". is not an object"'
true
=> ". 不是一个对象"

jq ´[.[]|试试 .a]´
[{}, 真, {"a":1}]
=> [空，1]

jq 'try error("some exception") catch .'
true
=>“一些例外”

破坏 输出 of 控制 结构
try/catch 的一个方便用途是打破控制结构，例如 减少, 的foreach,
而，等等。

例如：

# 重复一个表达式，直到它引发“break”作为
# 错误，然后停止重复而不重新引发错误。
# 但如果捕获的错误不是“中断”，则重新提出它。
尝试 repeat(exp) catch .=="break" 然后清空 else 错误；

jq 有一个命名词法标签的语法，以“中断”或“转到（返回）到”：

标签 $out | ...突破$...

打破 $标签名称 表达式将使程序表现得好像最近的
（靠左） 标签 $标签名称 生产 空的.

之间的关系 打破 并对应 标签 是词法的：标签必须是
从休息“可见”。

打破一个 减少， 例如：

标签 $out | reduce .[] as $item (null; if .==false then break $out else ... end)

以下 jq 程序产生语法错误：

突破$

因为没有标签 $出 是可见的。

? 操作者
? 运算符，用作 经验？, 是简写 尝试 进出口.

jq'[.[]|(.a)?]'
[{}, 真, {"a":1}]
=> [空，1]

定期 表情 (聚合酶链反应)

jq 使用 Oniguruma 正则表达式库，php、ruby、TextMate、Sublime Text 也是如此，
等等，所以这里的描述将集中在 jq 细节上。

定义了 jq 正则表达式过滤器，以便可以使用以下模式之一使用它们：

字符串 | 过滤器（正则表达式）
字符串 | 过滤器（正则表达式；标志）
字符串 | 过滤器（[正则表达式]）
字符串 | 过滤器（[正则表达式，标志]）

其中： * STRING、REGEX 和 FLAGS 是 jq 字符串，受 jq 字符串插值影响； *
字符串插值后的 REGEX 应该是有效的 PCRE 正则表达式； * 过滤器是其中之一 test,
匹配或 捕获，如下所述。

FLAGS 是一个字符串，由多个受支持的标志之一组成：

· g - 全局搜索（查找所有匹配项，而不仅仅是第一个）

· i - 不区分大小写的搜索

· m - 多行模式（´.´ 将匹配换行符）

· n - 忽略空匹配

· p - s 和 m 模式均已启用

· s - 单行模式 (´^´ -> ´\A´, ´$´ -> ´\Z´)

· l - 找到最长的可能匹配

· x - 扩展正则表达式格式（忽略空格和注释）

要匹配 x 模式中的空格，请使用转义符，例如 \s，例如

· 测试（“a\sb”，“x”）。

请注意，某些标志也可以在 REGEX 中指定，例如

· jq -n ´("测试", "测试", "测试", "测试") | 测试（“（？i）te（？-i）st”）'

计算结果为：真、真、假、假。

[需要 1.5] 测试（val）， 测试（正则表达式； 标志）
喜欢 匹配，但不返回匹配对象，只返回 true or false 无论是
正则表达式匹配输入。

jq '测试（“富”）'
“富”
=> 真

jq ´.[] | test("abc # 空格被忽略"; "ix")´
[“xabcd”，“ABC”]
=> 真的，真的

[需要 1.5] 匹配（值）， 匹配（正则表达式； 标志）
匹配 为它找到的每个匹配输出一个对象。 匹配项具有以下字段：

· 抵消 - 从输入开始的 UTF-8 代码点偏移

· 长度 - 匹配的 UTF-8 代码点长度

· 绳子 - 它匹配的字符串

· 捕获 - 表示捕获组的对象数组。

捕获组对象具有以下字段：

· 抵消 - 从输入开始的 UTF-8 代码点偏移

· 长度 - 此捕获组的 UTF-8 代码点长度

· 绳子 - 被捕获的字符串

· 姓名 - 捕获组的名称（或 空 如果它没有命名）

捕获不匹配任何内容的组返回 -1 的偏移量

jq ´match("(abc)+"; "g")´
“美国广播公司”
=> {"offset": 0, "length": 3, "string": "abc", "captures": [{"offset": 0, "length": 3, "string": "abc", " name": null}]}, {"offset": 4, "length": 3, "string": "abc", "captures": [{"offset": 4, "length": 3, "string" : "abc", "name": null}]}

jq '匹配（“富”）'
“富吧富”
=> {"offset": 0, "length": 3, "string": "foo", "captures": []}

jq 'match(["foo", "ig"])'
“foo 酒吧 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 ´[ match("."; "g")] | 长度
“ABC”
=> 3

[需要 1.5] 捕获（val）， 捕获（正则表达式； 标志）
将命名的捕获收集到一个 JSON 对象中，以每个捕获的名称作为键，
并将匹配的字符串作为相应的值。

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

[需要 1.5] 扫描（正则表达式）， 扫描（正则表达式； 标志）
发出与正则表达式匹配的输入的非重叠子串流
根据标志，如果有的话。 如果没有匹配，则流为
空的。 要捕获每个输入字符串的所有匹配项，请使用习语 [ 表达式 ]，例如 [
扫描（正则表达式） ].

拆分（正则表达式； 标志）
为了向后兼容， 分裂 在字符串上拆分，而不是正则表达式。

[需要 1.5] 拆分（正则表达式）， 拆分（正则表达式； 标志）
这些提供与它们相同的结果 分裂 对应物，但作为流而不是
数组。

[需要 1.5] 子（正则表达式； 串） 子（正则表达式； 串; 标志）
将输入字符串中正则表达式的第一个匹配项替换为
弦, 插值后。 弦 应该是一个 jq 字符串，并且可能包含引用
到命名捕获。 命名的捕获实际上是作为 JSON 对象呈现的（如
由...构建 捕获），以 弦，因此对名为“x”的捕获变量的引用将
采用形式：“(.x)”。

[需要 1.5] gsub（正则表达式； 细绳）， gsub（正则表达式； 串; 标志）
格子 就像 分 但正则表达式的所有非重叠出现都被替换为
字符串，插值后。

高级 特点

变量在大多数编程语言中是绝对必要的，但它们被降级
到 jq 中的“高级功能”。

在大多数语言中，变量是传递数据的唯一方式。 如果你计算一个
值，并且您想多次使用它，您需要将它存储在一个变量中。 到
将值传递给程序的另一部分，您需要程序的那部分
定义一个变量（作为函数参数、对象成员或其他）来放置
数据。

也可以在 jq 中定义函数，尽管这是一个最大的特性
用途是定义 jq 的标准库（很多 jq 函数如 地图 和 发现 实际上是
写成jq）。

jq 有归约运算符，它们非常强大但有点棘手。 再次，这些是
主要在内部使用，用于定义 jq 标准库的一些有用部分。

一开始可能并不明显，但 jq 是关于生成器的（是的，就像在
其他语言）。 提供了一些实用程序来帮助处理生成器。

一些最小的 I/O 支持（除了从标准输入读取 JSON，并将 JSON 写入到
标准输出）可用。

最后，还有一个模块/库系统。

变量
在 jq 中，所有过滤器都有一个输入和一个输出，因此不需要手动管道
将值从程序的一个部分传递到下一个部分。 很多表达，例如 a + b,
将它们的输入传递给两个不同的子表达式（这里 a 和 b 都通过了相同的
输入），所以通常不需要变量来使用一个值两次。

例如，计算一组数字的平均值需要一些
大多数语言中的变量 - 至少一个来保存数组，也许每个元素一个
或用于循环计数器。 在 jq 中，它只是 加 / 长度 - 加 表达式给出
数组并产生其总和，以及 长度 表达式被赋予数组并产生它的
长度。

因此，通常有一种比定义变量更简洁的方法来解决 jq 中的大多数问题。
尽管如此，有时它们确实使事情变得更容易，因此 jq 允许您使用
表达 as $变量. 所有变量名都以 $. 这是一个稍微丑一点的版本
数组平均示例：

长度为 $array_length | 添加 / $array_length

我们需要一个更复杂的问题来找到实际使用变量的情况
让我们的生活更轻松。

假设我们有一系列博客文章，带有“作者”和“标题”字段，以及另一个
用于将作者用户名映射到真实姓名的对象。 我们的输入看起来像：

{"posts": [{"title": "Frist psot", "author": "anon"},
{"title": "一篇写得很好的文章", "author": "person1"}],
"realnames": {"anon": "匿名懦夫",
"person1": "麦克弗森人"}}

我们想要生成包含真实姓名的作者字段的帖子，如下所示：

{"title": "Frist psot", "author": "匿名懦夫"}
{"title": "一篇写得很好的文章", "author": "Person McPherson"}

我们使用一个变量 $names 来存储 realnames 对象，以便我们以后可以引用它
查找作者用户名时：

.realnames 作为 $names | .posts[] | {标题，作者：$names[.author]}

表达方式 EXP as $x | ... 意思是：对于表达式的每个值 EXP, 运行剩下的
具有整个原始输入的管道，以及 $x 设置为该值。 因此 as
功能类似于 foreach 循环。

正如 {富} 是一种方便的写作方式 {富： .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”语法为过滤器命名：

定义增量：。 + 1;

从那时起， 增量 可以像内置函数一样用作过滤器（实际上，这
是一些内置函数的定义方式）。 一个函数可以接受参数：

定义映射(f): [.[] | F];

参数作为过滤器传递，而不是作为值传递。 可以引用相同的论点
多次使用不同的输入（这里 f 为输入数组的每个元素运行）。
函数的参数更像是回调而不是值参数。 这是
理解很重要。 考虑：

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

结果将是 20，因为 f is .*2，并且在第一次调用 f . 将是 5，
第二次是 10 (5 * 2)，所以结果是 20。 函数参数
是过滤器，过滤器在调用时需要输入。

如果你想要定义简单函数的值参数行为，你可以只使用
变量：

def addvalue(f): f as $f | 地图（。+ $f）；

或者使用简写：

def addvalue($f): ...;

无论是哪种定义， 附加值（.foo） 将添加当前输入 .foo 字段到每个
数组的元素。

允许使用相同函数名的多个定义。 每次重新定义替换
前一个用于相同数量的函数参数，但仅用于来自
重新定义之后的函数（或主程序）。

jq ´def addvalue(f): . + [f]; 地图（加值（。[0]））'
[[1,2]，[10,20]]
=> [[1,2,1], [10,20,10]]

jq ´def addvalue(f): f as $x | 地图（。+ $x）； 附加值(.[0])´
[[1,2]，[10,20]]
=> [[1,2,1,2], [10,20,1,2]]

减少
减少 jq 中的语法允许您通过以下方式组合表达式的所有结果
将它们累积成一个答案。 例如，我们将通过 [3,2,1] 对此
表达：

将 .[] 减少为 $item (0; . + $item)

对于每个结果 .[] 产生， . + $项目 运行以累积运行总数，
从 0 开始。在这个例子中， .[] 产生结果 3、2 和 1，所以效果是
类似于运行这样的东西：

0 | (3 作为 $item | . + $item) |
(2 作为 $item | . + $item) |
（1 为 $item | . + $item）

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

限制（n; 经验)
限制 函数提取到 n 输出来自 EXP.

jq '[limit(3;.[])]'
[0,1,2,3,4,5,6,7,8,9]
=> [0,1,2]

第一个（表达式）， 最后（表达式）， 第n(n; 表达式)
首先（表达式） 和 最后（表达式） 函数从中提取第一个和最后一个值 表达式,
。

第n(n; 表达式) 函数提取第n个值输出 表达式. 这可以定义为
DEF 第n(n; 表达式）： 最后（限制（n + 1; 表达式));。 注意 第n(n; 表达式) 不支持
的负值 n.

jq ´[第一个（范围（.）），最后一个（范围（.）），第n个（./2；范围（.））]´
10
=> [0,9,5]

第一， 持续， 第n(n)
第一 和 最后 函数从任何数组中提取第一个和最后一个值 ..

第n(n) 函数提取任何数组的第 n 个值 ..

jq´[range(.)]|[第一个，最后一个， 第n(5)]'
10
=> [0,9,5]

的foreach
的foreach 语法类似于 减少，但旨在允许构建 限制
和产生中间结果的减速器（参见示例）。

表格是 的foreach 进出口 as $变量 （在里面; 更新; 提炼）。 如 减少, INIT 被评估
一次产生一个状态值，然后每个输出 进出口 一定会 $变量, 更新 is
对每个输出进行评估 进出口 与当前状态和 $变量 可见的。 每个值
由输出 更新 替换之前的状态。 最后， 提取 评估每个新的
状态以提取输出 的foreach.

这主要仅用于构建 减少 - 和 限制- 类似的功能。 但它是
更通用，因为它允许部分减少（见下面的例子）。

jq ´[foreach .[] as $item ([[],[]]; if $item == null then [[],.[0]] else [(.[0] + [$item]),[ ]] 结束；如果 $item == null 那么 .[1] 否则为空结束)]´
[1,2,3,4,null,"a","b",null]
=> [[1,2,3,4],["a","b"]]

递归
如上所述， 递归 使用递归，任何 jq 函数都可以递归。 这
而 内置也是在递归方面实现的。

每当递归调用左侧的表达式输出时优化尾调用
它的最后一个值。 实际上，这意味着递归左边的表达式
call 不应为每个输入产生多个输出。

例如：

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

def while(cond; 更新):
定义_while：
if cond then ., (update | _while) else 空结束；
_尽管;

定义重复（exp）：
定义_重复：
exp，_重复；
_重复;

发电机 和 迭代器
一些 jq 运算符和函数实际上是生成器，因为它们可以产生零，
每个输入有一个或多个值，正如人们在其他编程中所期望的那样
具有生成器的语言。 例如， .[] 在其输入中生成所有值
（必须是数组或对象）， 范围（0; 10） 生成 0 到 XNUMX 之间的整数
10，以此类推。

甚至逗号运算符也是一个生成器，首先生成由
逗号左侧的表达式，然后对于每个表达式，由
逗号右边的表达式。

空的 内置是产生零输出的生成器。 这 空的 内建的
回溯到前面的生成器表达式。

只需使用内置生成器，所有 jq 函数都可以成为生成器。 也有可能
仅使用递归和逗号运算符来定义新的生成器。 如果递归
call(s) is(are) "in tail position" 那么生成器将是高效的。 在示例中
在递归调用下面 _范围 to 本身处于尾部位置。 该示例显示
三个高级主题：尾递归、生成器构造和子函数。

jq ´def range(init; upto; by): def _range: if (by > 0 and . < upto) or (by < 0 and . > upto) then ., ((.+by)|_range) else . 结尾; if by == 0 then init else init|_range end | select((by > 0 and . < upto) or (by < 0 and . > upto)); 范围(0; 10; 3)´
空
=> 0, 3, 6, 9

jq ´def while(cond; update): def _while: if cond then ., (update | _while) else empty end; _尽管; [while(.<100; .*2)]´
1
=> [1,2,4,8,16,32,64]

数学

jq 目前只有 IEEE754 双精度（64 位）浮点数支持。

除了简单的算术运算符，如 +, jq 也有最标准的数学函数
来自 C 数学库。 接受单个输入参数的 C 数学函数（例如， 罪（）)
可用作零参数 jq 函数。 需要两个输入的 C 数学函数
参数（例如， 战俘（）) 可用作忽略的双参数 jq 函数 ..

标准数学函数的可用性取决于相应的数学函数的可用性
操作系统和 C 数学库中的数学函数。 不可用的数学函数
将被定义，但会引发错误。

I / O

这时候jq对I/O的支持很少，主要是控制什么时候
输入被读取。 为此提供了两个内置函数， 输入 和 输入，那读
来自相同的来源（例如， 标准输入, 在命令行上命名的文件）作为 jq 本身。 这些
两个内置函数和 jq 自己的读取操作可以相互交错。

一个内置提供最少的输出功能， 调试. （回想一下 jq 程序的
输出值始终作为 JSON 文本输出 标准输出。） 这 调试 内置可以有
特定于应用程序的行为，例如对于使用 libjq C API 但不使用 libjq C API 的可执行文件
jq 可执行文件本身。

输入
输出一个新输入。

输入
一一输出所有剩余的输入。

这主要用于减少程序的输入。

调试
导致基于要生成的输入值的调试消息。 jq 可执行文件包装
输入值与 ["调试：", ] 并在 stderr 上打印它和换行符，
紧凑地。 这在未来可能会改变。

输入文件名
返回当前正在过滤其输入的文件的名称。 请注意，这将
除非 jq 在 UTF-8 语言环境中运行，否则效果不佳。

输入行号
返回当前正在过滤的输入的行号。

流媒体

随着 - 溪流 选项 jq 可以以流式方式解析输入文本，允许 jq
立即开始处理大型 JSON 文本的程序，而不是在解析之后
完成。 如果您有一个大小为 1GB 的 JSON 文本，流式传输它将允许您
以更快地处理它。

但是，流式处理并不容易，因为 jq 程序将具有 [ ,
] （和其他一些形式）作为输入。

提供了几个内置函数以使处理流更容易。

下面的示例使用流式传输形式 [0,[1]]，这是
[[0],0],[[1,0],1],[[1,0]],[[1]].

流媒体形式包括 [ , ] （表示任何标量值，空数组，
或空对象），和 [ ] （指示数组或对象的结尾）。 未来
jq 的版本运行 - 溪流 和 -seq 可能会输出其他形式，例如 [“错误
信息”] 当输入文本无法解析时。

截断流（流表达式）
使用一个数字作为输入并截断相应数量的路径元素
给定流表达式的输出的左侧。

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]

流
流 内置输出其输入的流形式。

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")) |= if . then 1 else 0 end´
[真,假,[5,真,[真,[假]],假]]
=> [1,0,[5,1,[1,[0]],0]]

+=, -=, *=, /=, %=, // =
jq 有几个操作符的形式 a 操作= b，它们都等价于 a |= . op b。 所以，
+= 1 可用于增加值。

jq '.foo += 1'
{“富”：42}
=> {"foo": 43}

复杂 任务
jq 赋值的左侧允许的内容比大多数情况多
语言。 我们已经在左侧看到了简单的字段访问，它没有
令人惊讶的是，数组访问也能正常工作：

.posts[0].title = "JQ 手册"

令人惊讶的是，左边的表达式可能会产生多个
结果，指的是输入文档中的不同点：

.posts[].comments |= 。 + [“这很棒”]

该示例将字符串“this is great”附加到每个帖子的“评论”数组中
输入（其中输入是一个带有字段“posts”的对象，它是一个帖子数组）。

当 jq 遇到像‘a = b’这样的赋值时，它会记录选择一个所采用的“路径”
执行a时输入文档的一部分。 然后使用此路径查找哪个部分
执行分配时要更改的输入。 任何过滤器都可以用于
等号的左侧 - 它从输入中选择的任何路径都将是
分配被执行。

这是一个非常强大的操作。 假设我们想在博客文章中添加评论，使用
上面相同的“博客”输入。 这一次，我们只想对作者写的帖子发表评论
“斯多兰”。 我们可以使用前面描述的“选择”功能找到这些帖子：

.posts[] | 选择（。作者==“stedolan”）

此操作提供的路径指向“stedolan”所写的每个帖子，以及
我们可以像以前一样对它们中的每一个进行评论：

(.posts[] | select(.author == "stedolan") | .comments) |=
. + [“太糟糕了。”]

课程结构

jq 有一个库/模块系统。 模块是名称以 .jq.

在默认搜索路径中搜索由程序导入的模块（见下文）。 这
进口 和 包括 指令允许导入程序更改此路径。

搜索路径中的路径会进行各种替换。

对于以“~/”开头的路径，用户的主目录将替换为“~”。

对于以“$ORIGIN/”开头的路径，jq 可执行文件的路径被替换为
“$起源”。

对于以“./”开头的路径或以“.”开头的路径，包含文件的路径为
替代 ”。”。 对于命令行上给出的顶级程序，当前
目录使用。

导入指令可以选择指定附加默认值的搜索路径。

默认搜索路径是给定的搜索路径 -L 命令行选项，否则
["〜/.jq", "$ORIGIN/../lib/jq", “$起源/../ lib目录"].

空和空字符串路径元素终止搜索路径处理。

将在“foo/bar.jq”中搜索具有相对路径“foo/bar”的依赖项
给定搜索路径中的“foo/bar/bar.jq”。 这是为了允许放置模块
在一个目录中，例如版本控制文件、自述文件等，
但也允许单文件模块。

不允许具有相同名称的连续组件以避免歧义（例如，
“富/富”）。

例如， -L$HOME/.jq 一个模块 FOO 可以发现 $HOME/.jq/foo.jq 和
$HOME/.jq/foo/foo.jq.

如果 "$HOME/.jq" 是一个文件，它会被导入到主程序中。

进口 相对路径字符串 as 您的姓名 [ ];
导入在相对于搜索路径中的目录的给定路径中找到的模块。 一个“.jq”
后缀将被添加到相对路径字符串中。 模块的符号以
“姓名：：”。

可选的元数据必须是常量 jq 表达式。 它应该是一个带键的对象
如“主页”等。 此时 jq 只使用“搜索”键/值
元数据。 元数据也可以通过 元模块 内置。

元数据中的“搜索”键（如果存在）应具有字符串或数组值（数组
字符串）； 这是要作为顶级搜索路径前缀的搜索路径。

包括 相对路径字符串 [ ];
导入在相对于搜索路径中的目录的给定路径中找到的模块，就好像它
被包括在原地。 “.jq”后缀将被添加到相对路径字符串中。 这
模块的符号被导入调用者的命名空间，就好像模块的内容已经
被直接收录。

可选的元数据必须是常量 jq 表达式。 它应该是一个带键的对象
如“主页”等。 此时 jq 只使用“搜索”键/值
元数据。 元数据也可以通过 元模块 内置。

进口 相对路径字符串 as $名称 [ ];
导入在相对于搜索路径中的目录的给定路径中找到的 JSON 文件。 一种
“.json”后缀将被添加到相对路径字符串中。 该文件的数据将是
可作为 $名称::名称.

可选的元数据必须是常量 jq 表达式。 它应该是一个带键的对象
如“主页”等。 此时 jq 只使用“搜索”键/值
元数据。 元数据也可以通过 元模块 内置。

元数据中的“搜索”键（如果存在）应具有字符串或数组值（数组
字符串）； 这是要作为顶级搜索路径前缀的搜索路径。

模块 ;
该指令完全是可选的。 正常操作不需要它。 它服务于
只是为了提供可以用 元模块 内置。

元数据必须是常量 jq 表达式。 它应该是一个带有像这样的键的对象
“主页”。 此时 jq 不使用此元数据，但它可供用户使用
通过 元模块 内置。

元模块
将模块名称作为输入并将模块的元数据作为对象输出，其中
模块的导入（包括元数据）作为“deps”键的数组值。

程序可以使用它来查询模块的元数据，然后他们可以使用这些元数据，例如
例如，搜索、下载和安装缺少的依赖项。

使用 onworks.net 服务在线使用 jq