使用 jq，将任意 JSON 展平为分隔符分隔的平面字典

Question

我希望将使用 jq 的 JSON 转换为分隔符分隔的扁平结构。

已经有过这方面的尝试。例如，Flatten nested JSON using jq。

但是，如果 JSON 包含数组，则该页面上的解决方案会失败。例如，如果 JSON 是：

{"a":{"b":[1]},"x":[{"y":2},{"z":3}]}

上述解决方案将无法将上述转换为：

{"a.b.0":1,"x.0.y":2,"x.1.z":3}

此外，我正在寻找一种也允许使用任意分隔符的解决方案。例如，假设空格字符是分隔符。在这种情况下，结果将是：

{"a b 0":1,"x 0 y":2,"x 1 z":3}

我希望通过 CentOS 7 中的 Bash (4.2+) 函数访问此功能，如下所示：

flatten_json()
{
    local JSONData="$1"
    # jq command to flatten $JSONData, putting the result to stdout
    jq ... <<<"$JSONData"
}

该解决方案应适用于所有 JSON 数据类型，包括 null 和 boolean。例如，考虑以下输入：

{"a":{"b":["p q r"]},"w":[{"x":null},{"y":false},{"z":3}]}

它应该产生：

{"a b 0":"p q r","w 0 x":null,"w 1 y":false,"w 2 z":3}

Answer 1

要为已经给出的解决方案添加一个新选项，jqg 是我编写的一个脚本，用于展平任何 JSON 文件，然后使用正则表达式搜索它。出于您的目的，您的正则表达式将只是 '.' 这将匹配所有内容。

$ echo '{"a":{"b":[1]},"x":[{"y":2},{"z":3}]}' | jqg .
{
  "a.b.0": 1,
  "x.0.y": 2,
  "x.1.z": 3
}

并且可以产生紧凑的输出：

$ echo '{"a":{"b":[1]},"x":[{"y":2},{"z":3}]}' | jqg -q -c .
{"a.b.0":1,"x.0.y":2,"x.1.z":3}

它还处理@peak 使用的更复杂的示例：

$ echo '{"a":{"b":["p q r"]},"w":[{"x":null},{"y":false},{"z":3}]}' | jqg .
{
  "a.b.0": "p q r",
  "w.0.x": null,
  "w.1.y": false,
  "w.2.z": 3
}

以及空数组和对象（以及一些其他极端情况值）：

$ jqg . test/odd-values.json
{
  "one.start-string": "foo",
  "one.null-value": null,
  "one.integer-number": 101,
  "two.two-a.non-integer-number": 101.75,
  "two.two-a.number-zero": 0,
  "two.true-boolean": true,
  "two.two-b.false-boolean": false,
  "three.empty-string": "",
  "three.empty-object": {},
  "three.empty-array": [],
  "end-string": "bar"
}

（可以使用-E 选项关闭报告空数组和对象）。

jqg 已使用 jq 1.6 进行测试

注意：我是jqg 脚本的作者。

Answer 2

以下内容已使用 jq 1.4、jq 1.5 和当前“master”版本进行了测试。关于包含 null 和 false 的路径的要求是“allpaths”和“all_leaf_paths”的原因。

# all paths, including paths to null
def allpaths:
  def conditional_recurse(f):  def r: ., (select(.!=null) | f | r); r;
  path(conditional_recurse(.[]?)) | select(length > 0);

def all_leaf_paths:
  def isscalar: type | (. != "object" and . != "array");
  allpaths as $p
  | select(getpath($p)|isscalar)
  | $p ;


. as $in 
| reduce all_leaf_paths as $path ({};
     . + { ($path | map(tostring) | join($delim)): $in | getpath($path) })

在 flatten.jq 中使用这个 jq 程序：

$ cat input.json
{"a":{"b":["p q r"]},"w":[{"x":null},{"y":false},{"z":3}]}

$ jq --arg delim . -f flatten.jq input.json

{
  "a.b.0": "p q r",
  "w.0.x": null,
  "w.1.y": false,
  "w.2.z": 3
}

碰撞

这是一个辅助函数，它说明了另一种路径展平算法。它将包含分隔符的键转换为带引号的字符串，数组元素显示在方括号中（参见下面的示例）：

def flattenPath(delim):
  reduce .[] as $s ("";
    if $s|type == "number" 
    then ((if . == "" then "." else . end) + "[\($s)]")
    else . + ($s | tostring | if index(delim) then "\"\(.)\"" else . end)
    end );

示例：使用flattenPath 而不是map(tostring) | join($delim)，对象：

 {"a.b": [1]}

会变成：

{
  "\"a.b\"[0]": 1
}

Answer 3

如果您流式传输数据，您将获得所有叶值的路径和值的配对。如果不是一对，则标记该路径处对象/数组定义结束的路径。如您所见，使用leaf_paths 只会为您提供通往真实叶子值的路径，因此您将错过null 甚至false 值。作为流，你不会遇到这个问题。

有很多方法可以将它组合到一个对象中，我倾向于在这些情况下使用reduce 和赋值。

$ cat input.json
{"a":{"b":["p q r"]},"w":[{"x":null},{"y":false},{"z":3}]}

$ jq --arg delim '.' 'reduce (tostream|select(length==2)) as $i ({};
    .[[$i[0][]|tostring]|join($delim)] = $i[1]
)' input.json
{
  "a.b.0": "p q r",
  "w.0.x": null,
  "w.1.y": false,
  "w.2.z": 3
}

---

这里将相同的解决方案拆分了一下，以便为解释发生的事情留出空间。

$ jq --arg delim '.' 'reduce (tostream|select(length==2)) as $i ({};
    [$i[0][]|tostring] as $path_as_strings
        | ($path_as_strings|join($delim)) as $key
        | $i[1] as $value
        | .[$key] = $value
)' input.json

使用tostream 将输入转换为流，我们将收到多个对/路径的值作为过滤器的输入。有了这个，我们可以将这些多个值传递给reduce，它旨在接受多个值并对其进行处理。但在此之前，我们希望仅通过对 (select(length==2)) 过滤这些对/路径。

然后在 reduce 调用中，我们从一个干净的对象开始，并使用从路径派生的键和相应的值分配新值。请记住，reduce 调用中生成的每个值都用于迭代中的下一个值。将值绑定到变量不会改变当前上下文和赋值有效地“修改”当前值（初始对象）并将其传递。

$path_as_strings 只是字符串和数字数组的路径。 [$i[0][]|tostring] 是一种简写，当我要映射的数组不是当前数组时，我使用它来替代使用 map。这更紧凑，因为映射是作为单个表达式完成的。而不必这样做以获得相同的结果：($i[0]|map(tostring))。外括号通常可能不是必需的，但它仍然是两个独立的过滤器表达式，而不是一个（以及更多文本）。

然后我们使用提供的分隔符将该字符串数组转换为所需的键。然后为当前对象分配适当的值。