问题[jq](coding)

假设我返回了这样的 json：

export json_string='{
    "summary": "1 failure",
    "checks": [
        {
            "id": "check1",
            "status": "OK"
        },
        {
            "id": "check2",
            "status": "FAILED"
        },
        {
            "id": "check3",
            "status": "CONFIG_WARNING"
        }
    ]
}'

如何获取已返回的摘要和未返回的支票？我可以通过以下方式获取未返回的支票：

echo "$json_string" | jq '.checks | .[] | select(.status != "OK")'

但我真的很想获得摘要和失败的检查，或者如果没有失败，则只获得摘要。

更新 被接受的答案为我指明了正确的方向。这是我最终用来按我想要的方式格式化输出的命令：

echo "$json_string" | jq '{"summary": .summary, "checks":[.checks[] | select(.status != "OK")]}'

我正在尝试从 skopeo 检查输出中提取包列表，但这似乎不起作用：

❯ skopeo inspect docker://ghcr.io/ublue-os/bluefin-dx:gts | jq '.Labels."dev.hhd.rechunk.info".packages'

上述代码没有“.packages”部分，内容如下：

❯ skopeo inspect docker://ghcr.io/ublue-os/bluefin-dx:gts | jq '.Labels."dev.hhd.rechunk.info"'
"{\"version\": 2, \"uniq\": \"gts-40.20250305\", \"packages\": {\"libgcc\": \"14.2.1-3.fc40\", .....

我怎样才能让 jq 进入这个对象并仅提取“包”部分？

如何将递归对象转换{ id, name: { data }, children: self[] }为类似的数组{ id: id, name: name.data | join('/') }？

例如，我想转换以下数据

[
    {"id": "1", "name": { "data": "foo" }, "children": [] },
    {"id": "2", "name": { "data": "bar" }, "children": [
        {"id": "4", "name": { "data": "melon" }, "children": [
            {"id": "5", "name": { "data": "soda" }, "children": [] }
        ] }
    ] },
    {"id": "3", "name": { "data": "baz" }, "children": [
        {"id": "6", "name": { "data": "my data" }, "children": [] }
    ] }
]

进入：

{"id": "1", "name": "foo"},
{"id": "2", "name": "bar"},
{"id": "4", "name": "bar/melon"},
{"id": "5", "name": "bar/melon/soda"},
{"id": "3", "name": "baz"},
{"id": "6", "name": "baz/my data"},

我不介意元素的顺序，因为每个id给定的对象在每个输入中都有唯一的值。

我的尝试是

.. | (.children? // empty) | .[] | { id: .id, name: .name.data }

但这会产生单层的名称（即，，，foo... ）。barmelon

我有一些如下数据：

{
"data": [
    {
      "startTime": "2024-12-31T00:00:00Z",
      "data": [
        {
          "one": "a",
          "two": 1125.000
        },
        {
          "one": "b",
          "two": 2119.000
        },
        {
          "one": "c",
          "two": 0.000
        }
      ]
    },

外部数据数组中有多个对象。我失败的是输出如下内容：

startTime, one, two

在上述数据的情况下，将给出三行输出。我可以将 one 和 two 组合在一起，但不能将 startTime: 与jq -r '.data[] | "\(.startTime)", (.data[] | "\(.one), \(.two)" )'

2024-12-31T00:00:00Z
a, 1125.000
b, 2119.000
c, 0.000

jq -r '.data[] | "\(.startTime)", (.data[] | "\(.one), \(.two)" )'获取以下内容，迭代最后每一项（“二”）：

2024-12-31T00:00:00Z, a, 1125.000
2024-12-31T00:00:00Z, b, 1125.000
2024-12-31T00:00:00Z, c, 1125.000
2024-12-31T00:00:00Z, a, 2119.000
2024-12-31T00:00:00Z, b, 2119.000
2024-12-31T00:00:00Z, c, 2119.000
2024-12-31T00:00:00Z, a, 0.000
2024-12-31T00:00:00Z, b, 0.000
2024-12-31T00:00:00Z, c, 0.000

我似乎找不到正确的语法。

在下面的 jq 脚本中，我想要打印 和 的连接first_name或者last_name仅仅last_name。

$ echo '{"first_name": "John", "last_name": "Johnson"}' | jq -c '{
  "name": (if (.last_name | startswith(.first_name)) 
           then .last_name 
           else .first_name + " " + .last_name 
           end)
}'

错误是

jq: error (at <stdin>:1): Cannot index string with string "first_name"

jq 命令在调用startswith- 时失败，好像startswith只接受字符串文字。如果我更改startswith(.first_name)为startswith("John")，则表达式将编译并按预期工作。

在现实世界的例子中，有许多输入记录和许多不同的first_names。有什么方法可以插入.first_name吗startswith？

给出简化的输入：

[
  [ "gpu" ],
  [ "disk" ]
]

我想选择第一个元素为的数组"gpu"。

我可以用一个简单的条件来做到这一点：

map(select(.[0] == "gpu"))

[
  [ "gpu" ]
]

但是我不明白当我尝试使用IN内置函数时出了什么问题：

map(select(.[0] | IN(["gpu"])))

[]

我用的是jq1.6

我有以下 JSON（基于 NDPI 输出）

{
    "src_ip": "x.x.x.x",
    "dest_ip": "x1.x1.x1.x1",
    "src_port": 48318,
    "dst_port": 443,
    "ip": 4,
    "proto": "TCP",
    "ndpi": {
        "flow_risk": {
            "35": {
                "risk": "Susp Entropy",
                "severity": "Medium",
                "risk_score": {
                    "total": 210,
                    "client": 165,
                    "server": 45
                }
            }
        },
        "confidence": {
            "1": "Match by port"
        },
        "proto": "TLS",
        "proto_id": "91",
        "proto_by_ip": "Unknown",
        "proto_by_ip_id": 0,
        "encrypted": 1,
        "breed": "Safe",
        "category_id": 5,
        "category": "Web"
    },
    "detection_completed": 1,
    "check_extra_packets": 0,
    "flow_id": 0,
    "first_seen": 1733074272.824,
    "last_seen": 1733074282.757,
    "duration": 9.933,
    "vlan_id": 0,
    "bidirectional": 1,
    "xfer": {
        "data_ratio": -0.958,
        "data_ratio_str": "Download",
        "src2dst_packets": 1268,
        "src2dst_bytes": 86239,
        "src2dst_goodput_bytes": 2551,
        "dst2src_packets": 2693,
        "dst2src_bytes": 4042956,
        "dst2src_goodput_bytes": 3865218
    },
    "iat": {
        "flow_min": 1,
        "flow_avg": 6.1,
        "flow_max": 4005,
        "flow_stddev": 108.3,
        "c_to_s_min": 0,
        "c_to_s_avg": 7.4,
        "c_to_s_max": 4005,
        "c_to_s_stddev": 137.8,
        "s_to_c_min": 0,
        "s_to_c_avg": 1.4,
        "s_to_c_max": 35,
        "s_to_c_stddev": 2.2
    },
    "pktlen": {
        "c_to_s_min": 66,
        "c_to_s_avg": 68.0,
        "c_to_s_max": 514,
        "c_to_s_stddev": 28.8,
        "s_to_c_min": 66,
        "s_to_c_avg": 1501.3,
        "s_to_c_max": 1506,
        "s_to_c_stddev": 76.6
    },
    "tcp_flags": {
        "cwr_count": 0,
        "ece_count": 0,
        "urg_count": 0,
        "ack_count": 3961,
        "psh_count": 1323,
        "rst_count": 0,
        "syn_count": 0,
        "fin_count": 0,
        "src2dst_cwr_count": 0,
        "src2dst_ece_count": 0,
        "src2dst_urg_count": 0,
        "src2dst_ack_count": 1268,
        "src2dst_psh_count": 7,
        "src2dst_rst_count": 0,
        "src2dst_syn_count": 0,
        "src2dst_fin_count": 0,
        "dst2src_cwr_count": 0,
        "dst2src_ece_count": 0,
        "dst2src_urg_count": 0,
        "dst2src_ack_count": 2693,
        "dst2src_psh_count": 1316,
        "dst2src_rst_count": 0,
        "dst2src_syn_count": 0,
        "dst2src_fin_count": 0
    },
    "c_to_s_init_win": 0,
    "s_to_c_init_win": 0
}

我可以获得几乎所有的信息（src_ip，端口等），但有一件事与“flow_risk”有关

{"flow_risk": {"35": {"risk":"Susp Entropy","severity":"Medium"

与数字（本例中为 35）相关。此数字可能不同（从 01 到 50），我不知道如何过滤以搜索不同的数字。

目前，我正在使用的过滤器

cat data.json | jq -r '"\(.src_ip),\(.src_port),\(.dest_ip),\(.dst_port),\(.proto),\(.ndpi.proto),\(.ndpi.category),\(.ndpi.hostname),\(.duration),\(.vlan_id),\(.xfer.src2dst_bytes),\(.xfer.dst2src_bytes),\(.ndpi.flow_risk."35".risk),\(.ndpi.flow_risk."35".severity)"')

当数字正好是 35 时，此方法有效，但是是否有机会使用类似 jQ 的通配符？

我的意思是我怎样才能接受多个数字？（例如：从 01 到 50 搜索？）

类似于

\(.ndpi.flow_risk."*".risk),\(.ndpi.flow_risk."*".severity)"')

谢谢 ！

对于如下所示的 Json 字段，如果 eventId 是一个连续值，我想添加消息字段的值。

但是即使eventId是连续的，如果message字段以#Time开头的话，message字段是被分割的。

这个是Json的原始字段。

{
    "events": [
        {
            "message": "# Time: 1",
            "eventId": "38636469249093328935961608873790523617989208925384015872"
        },
        {
            "message": ", 2, 3",
            "eventId": "38636469249093328935961608873790523617989208925384015873"
        },
        {
            "message": "# Time: 11",
            "eventId": "38636469249093328935961608873790523617989208925384015875"
        },
        {
            "message": "# Time: 12",
            "eventId": "38636469249093328935961608873790523617989208925384015876"
        },
        {
            "message": "# Time: A",
            "eventId": "1"
        },
        {
            "message": ", B, C",
            "eventId": "2"
        },
        {
            "message": "# Time: C",
            "eventId": "3"
        },
        {
            "message": "# Time: D",
            "eventId": "5"
        }
    ]
}

[
  {
    "message": "# Time: 1, 2, 3"
  },
  {
    "message": "# Time: 11"
  },
  {
    "message": "# Time: 12"
  },
  {
    "message": "# Time: A , B, C"
  },
  {
    "message": "# Time: C"
  },
  {
    "message": "# Time: D"
  }
]

我之前问过这个问题，得到了一个好人的回答。（谢谢 pmf。）
之后，我尽力对其进行了进一步的改进，但没有成功，所以我又问了一次。

首先，当我第一次运行这个 JQ 时，我得到了以下结果。

jq -r '.events 
| reduce .[1:][] as $i (.[:1];
    if ((.[-1].eventId | tonumber + 1 | tostring) != $i.eventId) or ($i.message | startswith("# Time:")) then
        . += [$i]
    else
        .[-1].message += " " + $i.message
    end
) 
| del(.[].eventId)
'

[
  {
    "message": "# Time: 1"
  },
  {
    "message": ", 2, 3"
  },
  {
    "message": "# Time: 11"
  },
  {
    "message": "# Time: 12"
  },
  {
    "message": "# Time: A , B, C"
  },
  {
    "message": "# Time: C"
  },
  {
    "message": "# Time: D"
  }
]

jq '
# Function to add one to a large number represented as a string
def add_one(num):
  (num | split("") | reverse | map(tonumber)) as $digits
  | reduce range(0; length) as $i ([];
      . + if $i == 0 or .[-1] == 10 then
            [($digits[$i] + 1) % 10]
         else
            [$digits[$i]]
         end
    )
  | reverse | map(tostring) | join("");

# Process events and check continuity
.events 
| map(.eventId |= tostring) # Ensure all eventIds are strings
| reduce .[1:][] as $i (.[:1];
    if (add_one(.[-1].eventId) != $i.eventId) or ($i.message | startswith("# Time:")) then
        . += [$i]
    else
        .[-1].message += " " + $i.message
    end
)
| del(.[].eventId)
'

[
  {
    "message": "# Time: 1"
  },
  {
    "message": ", 2, 3"
  },
  {
    "message": "# Time: 11"
  },
  {
    "message": "# Time: 12"
  },
  {
    "message": "# Time: A"
  },
  {
    "message": ", B, C"
  },
  {
    "message": "# Time: C"
  },
  {
    "message": "# Time: D"
  }
]

当我进一步搜索时，我发现了一个名为 gojq 的命令，但我想先测试一下它，看看是否可以用 jq 来实现。

我正在使用 jq 版本 1.7.1。

我正在尝试使用 QueryJSON 插件通过 WinMerge 比较两个长 json 文件。这些文件中的属性是随机顺序的。.\jq 的参数确实有效，但嵌套对象不受影响：

QueryJSON ". | to_entries | sort_by(.key) | from_entries"

有一些“flatten”命令没有提供我所搜索的结果（可能使用不正确）。

Jsons 可以是例如：

{
   "Id": 1,
   "Addresses":[
      {"Street": "Street 1",
      "PostalCode": 12345},
      {"Street": "Street 2",
      "PostalCode": 12345}
   ],
   "Person":{
      "FirstName": "Mike",
      "LastName":"Boe"
   }
}


{
   "Id": 2,
   "Person":{
      "FirstName": "John",
      "LastName":"Boe"
   }
   "Addresses":[
      {"Street": "Street 3",
      "PostalCode": 12345},
      {"Street": "Street 2",
      "PostalCode": 12345}
   ]
}

我可以通过指向嵌套对象来逐个比较它们

QueryJSON ".Person | to_entries | sort_by(.key) | from_entries"

但是，有没有办法对这些对象内部的属性进行排序（即使这会使它们变平）？谢谢。

我在 govc govmomi github 页面上发现以下内容，它允许我通过 MAC 地址搜索虚拟机：

govc object.collect -json -type m / config.hardware.device \
  | jq -r '
      .
      | select(.ChangeSet[].Val.VirtualDevice[].MacAddress == "00:50:56:bc:5e:3c")
      | [.Obj.Type, .Obj.Value]
      | join(":")
    ' \
  | xargs govc ls -L

请参阅附件中足够的 govc 输出片段：

{
  "Obj": {
    "Type": "VirtualMachine",
    "Value": "vm-666"
  },
  "ChangeSet": [
    {
      "Val": {
        "VirtualDevice": [
          {
          },
          {
            "MacAddress": "00:50:56:bc:5e:3c"
          }
        ]
      }
    }
  ]
}

我面临的问题是，有些 MAC 包含大写字母，有些包含小写字母，而且我事先不知道哪台机器使用哪种方案。我不知道如何使大小写==不敏感。

我在 stackoverflow 上找到了建议使用ascii_downcase过滤器的答案，但我不知道如何使用它==。

https://stackoverflow.com/a/62454688中建议的语法给了我一系列explode input must be a string错误（govc 输出每行 1 个）。

如果这对本练习很重要：这发生在Mac OS 15.1，jq是通过 brew 安装的，版本是1.7.1。