获取jq中的对象数组索引

Question

我有一个看起来像这样的 json 对象（由i3-msg -t get_workspaces 。

[
  {
    "name": "1",
    "urgent": false
  },
  {
    "name": "2",
    "urgent": false
  },
  {
    "name": "something",
    "urgent": false
  }
]

我正在尝试使用jq来确定列表中的哪个索引号是基于select查询的。 jq有一个叫做index()东西，但它似乎只支持字符串？

使用类似i3-msg -t get_workspaces | jq '.[] | select(.name=="something")' i3-msg -t get_workspaces | jq '.[] | select(.name=="something")' i3-msg -t get_workspaces | jq '.[] | select(.name=="something")'给了我我想要的对象。 但我想要它的索引。 在这种情况下2 （从 0 开始计数）

这可以单独使用jq吗？

Answer 1

所以我为 OP 提供了一个解决方案的策略，OP 很快就接受了。 随后@peak 和@Jeff Mercado 提供了更好、更完整的解决方案。 所以我把它变成了一个社区维基。 如果可以，请改进此答案。

一个简单的解决方案（由@peak 指出）是使用内置函数index ：

map(.name == "something") | index(true)

jq文档令人困惑地建议index对字符串进行操作，但它也对数组进行操作。 因此index(true)返回映射生成的布尔数组中第一个true的索引。 如果没有满足条件的项目，则结果为空。

jq 表达式以“惰性”方式进行评估，但map将遍历整个输入数组。 我们可以通过重写上面的代码并引入一些调试语句来验证这一点：

[ .[] | debug | .name == "something" ] | index(true)

正如@peak 所建议的，做得更好的关键是使用 jq 1.5 中引入的break语句：

label $out | 
foreach .[] as $item (
  -1; 
  .+1; 
  if $item.name == "something" then 
    ., 
    break $out 
  else 
    empty
  end
) // null

注意//是没有注释的； 它是替代运算符。 如果未找到名称，则foreach将返回empty ，该名称将被替代运算符转换为 null。

另一种方法是递归处理数组：

def get_index(name): 
  name as $name | 
  if (. == []) then
    null
  elif (.[0].name == $name) then 
    0 
  else 
    (.[1:] | get_index($name)) as $result |
    if ($result == null) then null else $result+1 end      
end;
get_index("something")

然而，正如@Jeff Mercado 指出的那样，在最坏的情况下，这种递归实现将使用与数组长度成正比的堆栈空间。 在 1.5 版中， jq引入了尾调用优化 (TCO) ，这将允许我们使用本地辅助函数对其进行优化（请注意，这是对@Jeff Mercado 提供的解决方案的小调整，以便与上述示例保持一致）：

def get_index(name): 
  name as $name | 
  def _get_index:
    if (.i >= .len) then
      null
    elif (.array[.i].name == $name) then
      .i
    else
      .i += 1 | _get_index
    end;
  { array: ., i: 0, len: length } | _get_index;
get_index("something")

根据@peak，在jq获取数组的长度是一个常数时间操作，显然索引数组也很便宜。 我将尝试为此找到引文。

现在让我们尝试实际测量。 以下是测量简单解的示例：

#!/bin/bash

jq -n ' 

  def get_index(name): 
    name as $name |
    map(.name == $name) | index(true)
  ;

  def gen_input(n):  
    n as $n |
    if ($n == 0) then 
      []
    else
      gen_input($n-1) + [ { "name": $n, "urgent":false } ]
    end
  ;  

  2000 as $n |
  gen_input($n) as $i |
  [(0 | while (.<$n; [ ($i | get_index(.)), .+1 ][1]))][$n-1]
'

当我在我的机器上运行它时，我得到以下信息：

$ time ./simple
1999

real    0m10.024s
user    0m10.023s
sys     0m0.008s

如果我用 get_index 的“快速”版本替换它：

def get_index(name): 
  name as $name |
  label $out | 
  foreach .[] as $item (
    -1; 
    .+1; 
  if $item.name == $name then 
    ., 
    break $out 
  else 
    empty
  end
) // null;

然后我得到：

$ time ./fast
1999

real    0m13.165s
user    0m13.173s
sys     0m0.000s

如果我用“快速”递归版本替换它：

def get_index(name): 
  name as $name | 
  def _get_index:
    if (.i >= .len) then
      null
    elif (.array[.i].name == $name) then
      .i
    else
      .i += 1 | _get_index
    end;
  { array: ., i: 0, len: length } | _get_index;

我得到：

$ time ./fast-recursive 
1999

real    0m52.628s
user    0m52.657s
sys     0m0.005s

哎哟! 但我们可以做得更好。 @peak 提到了一个未记录的开关--debug-dump-disasm ，它可以让您查看jq如何编译您的代码。 有了这个，你可以看到修改对象并将其传递给_indexof然后提取数组、长度和索引是很昂贵的。 重构以仅通过索引是一个巨大的改进，进一步改进以避免针对长度测试索引使其与迭代版本具有竞争力：

def indexof($name):
  (.+[{name: $name}]) as $a | # add a "sentinel"
  length as $l | # note length sees original array
  def _indexof:
    if ($a[.].name == $name) then
      if (. != $l) then . else null end
    else
      .+1 | _indexof
    end
  ;


  0 | _indexof
;

我得到：

$ time ./fast-recursive2
null

real    0m13.238s
user    0m13.243s
sys     0m0.005s

因此，如果每个元素的可能性都相同，并且您想要平均情况下的性能，那么您应该坚持使用简单的实现。 （C 编码的函数往往很快！）

Answer 2

@Jim-D 最初提出的使用 foreach 的解决方案仅适用于 JSON 对象数组，并且最初提出的两种解决方案都非常低效。 他们在没有满足条件的项目的情况下的行为也可能令人惊讶。

使用index/1解决方案

如果您只是想要一个快速简便的解决方案，您可以使用内置函数index ，如下所示：

map(.name == "something") | index(true)

如果没有满足条件的项目，则结果将为null 。

顺便说一句，如果您想要条件为真的所有索引，那么只需将index更改为indices ，即可轻松将上述解决方案转换为超快速解决方案：

map(.name == "something") | indices(true)

高效的解决方案

这是一个通用且高效的函数，它返回输入数组中第一次出现的项目的索引（即偏移量），其中 (item|f) 为真（非空也非假），否则为null 。 （在 jq、javascript 和许多其他程序中，数组的索引总是从 0 开始的。）

# 0-based index of item in input array such that f is truthy, else null
def which(f):
  label $out
  | foreach .[] as $x (-1; .+1; if ($x|f) then ., break $out else empty end)
  // null ;

用法示例：

which(.name == "something")

Answer 3

将数组转换为条目将使您可以访问项目数组中的索引和值。 您可以使用它来找到您正在寻找的值并获取其索引。

def indexof(predicate):
    reduce to_entries[] as $i (null;
        if (. == null) and ($i.value | predicate) then
            $i.key
        else
            .
        end
    );
indexof(.name == "something")

然而，这不会短路，而是会遍历整个数组以找到索引。 一旦找到第一个索引，您就会想要返回。 采用更实用的方法可能更合适。

def indexof(predicate):
    def _indexof:
        if .i >= .len then
            null
        elif (.arr[.i] | predicate) then
            .i
        else
            .i += 1 | _indexof
        end;
    { arr: ., i: 0, len: length } | _indexof;
indexof(.name == "something")

请注意，参数以这种方式传递给内部函数以利用一些优化。 即要利用 TCO，该函数不得接受任何附加参数。

通过识别数组及其长度不变，可以获得更快的版本：

def indexof(predicate):
  . as $in
  | length as $len
  |  def _indexof:
       if . >= $len then null
       elif ($in[.] | predicate) then .
       else . + 1 | _indexof
       end;
  0 | _indexof;

Answer 4

这是另一个版本，它似乎比来自 @peak 和 @jeff-mercado 的优化版本稍快：

label $out | . as $elements | range(length) |
select($elements[.].name == "something") | . , break $out

IMO 虽然它仍然依赖于break （仅获得第一场比赛），但它更易于阅读。

我在 ~1,000,000 元素数组上进行了 100 次迭代（最后一个元素是要匹配的元素）。 我只计算了用户和内核时间，而不是挂钟时间。 这个解决方案平均需要 3.4 秒，@peak 的解决方案需要 3.5 秒，@jeff-mercado 的解决方案需要 3.6 秒。 这与我在一次运行中看到的相符，尽管公平地说，我确实有一次运行，该解决方案平均为 3.6 秒，因此每个解决方案之间不太可能有任何统计上的显着差异。