JOLT语法中[&]的含义？结合示例详解其作用

问题背景 #

我查阅了相关文档、源码和参考文章，但现有解释十分匮乏。我理解&的含义，但无法理解[&]的作用，希望结合下述示例解释[&]的功能，尤其是以下两行的具体执行逻辑：

"@1": "outer[&4].inner[&2].t",
"@(3,eventTypeCode)": "outer[&4].inner[&2].etc"

输入 JSON #

{
  "uID": 1000358546,
  "events": [
    {
      "eventTypeCode": "FEEDBACK",
      "transports": [
        "PUSH",
        "SMS"
      ]
    },
    {
      "eventTypeCode": "MARKETING",
      "transports": [
        "PUSH",
        "EMAIL"
      ]
    },
    {
      "eventTypeCode": "ORDER_STATUS",
      "transports": [
        "SOC_VK"
      ]
    }
  ]
}

Jolt Spec（Shift 操作） #

[
  {
    "operation": "shift",
    "spec": {
      "events": {
        "*": {
          "transports": {
            "*": {
              "*": {
                "@1": "outer[&4].inner[&2].t",
                "@(3,eventTypeCode)": "outer[&4].inner[&2].etc"
              }
            }
          }
        }
      },
      "*": "&"
    }
  }
]

转换结果 #

{
  "uID": 1000358546,
  "outer": [
    {
      "inner": [
        {
          "t": "PUSH",
          "etc": "FEEDBACK"
        },
        {
          "t": "SMS",
          "etc": "FEEDBACK"
        }
      ]
    },
    {
      "inner": [
        {
          "t": "PUSH",
          "etc": "MARKETING"
        },
        {
          "t": "EMAIL",
          "etc": "MARKETING"
        }
      ]
    },
    {
      "inner": [
        {
          "t": "SOC_VK",
          "etc": "ORDER_STATUS"
        }
      ]
    }
  ]
}

核心解释 #

1. [&N] 的本质作用 #

& 本身用来引用当前节点的键名，而 [&N] 是将引用的键名作为数组索引使用，目的是在输出中构建对应位置的数组结构，保证输入数组的元素能精准映射到输出数组的对应位置。

这里的 N 是向上回溯的层级数，用来指定引用哪一层父节点的键名（对于数组来说，父节点的键名就是数组的索引，比如 events 数组的第 0、1、2 个元素，对应的键名就是 0、1、2）。

2. 关键行的执行逻辑 #

先梳理 Spec 的层级结构（从内到外计数，当前处理的是 transports 数组里的单个元素，即最内层的 *）：

• 第 1 层（最内层）：* → 对应 transports 数组里的单个元素（如 PUSH、SMS）
• 第 2 层：* → 对应 transports 数组的索引（0、1）
• 第 3 层：transports → 固定键名
• 第 4 层：* → 对应 events 数组的索引（0、1、2）
• 第 5 层：events → 固定键名

第一行："@1": "outer[&4].inner[&2].t"

• @1：向上回溯 1 层，取当前元素的值（如 PUSH）
• outer[&4]：&4 表示向上回溯 4 层，引用该层的键名（即 events 数组的索引 0/1/2），对应输出数组 outer 的第 0/1/2 个元素
• inner[&2]：&2 表示向上回溯 2 层，引用该层的键名（即 transports 数组的索引 0/1），对应输出数组 inner 的第 0/1 个元素
• 最终效果：将 transports 里的每个元素值，放到 outer 对应 events 索引位置的 inner 对应 transports 索引位置的 t 字段中

第二行："@(3,eventTypeCode)": "outer[&4].inner[&2].etc"

• @(3,eventTypeCode)：向上回溯 3 层，找到当前节点的祖父节点（即每个 events 元素），取其中的 eventTypeCode 字段值（如 FEEDBACK）
• outer[&4] 和 inner[&2] 的含义与第一行完全一致，保证 eventTypeCode 的值和对应的 transports 元素放到同一个 inner 对象里
• 最终效果：将每个 events 元素的 eventTypeCode 值，对应放到 outer 对应索引位置的 inner 对应 transports 索引位置的 etc 字段中

3. 整体映射逻辑 #

整个 Spec 的作用：

• 保留原有的 uID 字段（通过 "*": "&" 实现）
• 将 events 数组中的每个元素，转换成 outer 数组中的对应元素
• 每个 events 元素的 transports 数组，转换成对应 outer 元素里的 inner 数组
• 每个 transports 元素对应 inner 里的一个对象，包含 t（传输方式值）和 etc（所属事件类型）两个字段

内容的提问来源于 stack exchange，提问作者 Vlad Vlad