jq

    jq 是 stedolan 开发的一个轻量级的和灵活的命令行JSON处理器，源码请参考

    jq 用于处理JSON输入，将给定过滤器应用于其JSON文本输入并在标准输出上将过滤器的结果生成为JSON。

    最简单的过滤器是，它将jq的输入未经修改地复制到其输出中（格式设置除外）。

    请注意，jq 当前仅支持64位双精度浮点数（IEEE754）。

    1. jq [options] <jq filter> [file...]
    2. jq [options] --args <jq filter> [strings...]
    3. jq [options] --jsonargs <jq filter> [JSON_TEXTS...]
    1. -c               紧凑而不是漂亮的输出;
    2. -n               使用`null`作为单个输入值;
    3. -e               根据输出设置退出状态代码;
    4. -s               将所有输入读取（吸取）到数组中；应用过滤器;
    5. -r               输出原始字符串，而不是JSON文本;
    6. -R               读取原始字符串，而不是JSON文本;
    7. -C               为JSON着色;
    8. -M               单色（不要为JSON着色）;
    9. -S               在输出上排序对象的键;
    10. --tab            使用制表符进行缩进;
    11. --arg a v        将变量$a设置为value<v>;
    12. --argjson a v    将变量$a设置为JSON value<v>;
    13. --slurpfile a f  将变量$a设置为从<f>读取的JSON文本数组;
    14. --rawfile a f    将变量$a设置为包含<f>内容的字符串;
    15. --args           其余参数是字符串参数，而不是文件;
    16. --jsonargs       其余的参数是JSON参数，而不是文件;
    17. --               终止参数处理;
    1. {
    2.   "foo": {
    3.     "bar": {
    4.       "baz": 123
    5.     }
    7. }

    .foo, .foo.bar, .foo?: 获取一个键的值

    1. $ echo '{"foo": 42, "bar": "less interesting data"}' | jq '.foo'
    2. 42

    .[], .[]?, .[2], .[10:15]: 数组运算

    [], {}: 构造一个数组/对象

    1. $ echo '{"user":"stedolan","titles":["JQ Primer", "More JQ"]}' | jq '{user, title: .titles[]}'
    3. {
    4.   "user": "stedolan",
    5.   "title": "JQ Primer"
    6. }
    7. {
    8.   "user": "stedolan",
    9.   "title": "More JQ"
    10. }

    length: 计算一个值的长度

    1. $ echo '[[1,2], "string", {"a":2}, null]' | jq '.[] | length'                                  
    2. 2
    3. 6
    4. 1
    5. 0
    1. $ echo '{"abc": 1, "abcd": 2, "Foo": 3}' | jq 'keys'                                        
    2.   "Foo",
    3.   "abc",
    5. ]

    ,: 使用多个过滤器

    1. $ echo '{ "foo": 42, "bar": "something else", "baz": true}' | jq '.foo, .bar' 
    2. 42
    3. "something else"

    |: 通过管道将一个过滤器的输出当做下一个过滤器的输入

    select(foo): 如果foo返回true，则输入保持不变

    1. $ echo '[1,5,3,0,7]' | jq 'map(select(. >= 2))'                                                    
    2. [
    3.   5,
    4.   3,
    5.   7
    6. ]

    map(foo): 每个输入调用过滤器

    1. $ echo '[1,2,3]' | jq 'map(.+1)'
    2. [
    3.   2,
    4.   3,
    5.   4
    6. ]
    1.  $ echo '2' | jq 'if . == 0 then "zero" elif . == 1 then "one" else "many" end'
    3. "many"

    \(foo): 在字符串中插入值并进行运算

    1. $ echo '42' | jq '"The input was \(.), which is one less than \(.+1)"'