使用 jq，将任意 JSON 扁平化到分隔符分隔的扁平字典

Question

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

已经在这方面进行了尝试。 例如， 使用 jq 展平嵌套的 JSON 。

但是，如果 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

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

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

$ 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)) 。 外括号通常可能不是必需的，但它仍然是两个单独的过滤器表达式与一个（和更多文本）。

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

Answer 2

以下已使用 jq 1.4、jq 1.5 和当前的“主”版本进行了测试。 关于包含 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) map(tostring) | join($delim) ，对象：

 {"a.b": [1]}

会成为：

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

Answer 3

为了给已经给出的解决方案添加一个新选项， 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脚本的作者。