问题[json](coding)

我有一个包含两个“列”'User id'和'email'示例的 CSV：

User id,email
1234-1234-1234,[email protected]
321-1235-44432,[email protected]
322136231345,[email protected]

JSON 如下所示：

    [{
            "externalId": "100000",
            "watchers": ["[email protected]", "[email protected]", "[email protected]"]
        },
{
            "externalId": "100002",
            "watchers": ["[email protected]", "[email protected]"]
        }
    ]

我想要做的是相应地用 CSV 中的“用户 ID”替换 JSON 中的电子邮件地址。到目前为止，我有低效的 foreach in foreach 代码，但它只替换了观察者数组中的第一个电子邮件。

$usersCSV = Import-Csv 'users.csv'
$watchersJSON = Get-Content -Path "watchers.json" -raw |ConvertFrom-Json

foreach ($watchersJSONdata in $watchersJSON) {
    foreach ($usersCSVdata in $usersCSV){
        if ($watchersJSONdata.watchers -eq $usersCSVdata.email) {
            $watchersJSONdata.watchers = $usersCSVdata.'User id'
        }
    }
} $watchersJSON |ConvertTo-Json | out-file  "watchers-with-ID.json"

结果是：

[{
        "externalId": "100000",
        "watchers": ["1234-1234-1234"]
    }
]

我仍在努力，但如果能提供一点帮助就太好了。

我不会介意使用单行 jq 的完全不同的方法，但我完全不了解 jq。

我正在尝试编写一个备份程序来备份我们 CRM 中的大量数据，因为它的原生版本缺少很多我们想要保护的信息。我需要使用 vb.net（.Net Framework 4.8.1），我的最终目标是，一旦我弄清楚我们要备份的确切值，就将其映射到具有大量表的 SQL 服务器。调用是 HTTP GET，响应是嵌套的 JSON。除此之外，我希望尽可能多地备份，我并不真正关心我必须使用什么方法/nuget 包（只要信誉良好）/任何我可以使用的东西来实现这一点。我以前从未处理过 JSON，坦率地说，我对此感到力不从心。

数据变化极大且庞大——主要属性可能有多达 300 个，其中大部分都保留了版本历史记录，但并非全部。空白值似乎不会返回，因此响应的结构有点不可预测。

基本结构高度匿名：

{
  "vid": 12345,
  "canonical-vid": 12345,
  "merged-vids": [],
  "portal-id": 12345678,
  "is-contact": true,
  "properties": {
    "prop1": {
      "value": "12345678",
      "versions": [
        {
          "value": "12345678",
          "source-type": "CALCULATED",
          "source-id": "source1",
          "source-label": null,
          "updated-by-user-id": null,
          "timestamp": 1717375078168,
          "selected": false,
          "data-sensitivity": null,
          "is-encrypted": null
        },
        {
          "value": "12345678;12345679",
          "source-type": "CALCULATED",
          "source-id": "source1",
          "source-label": null,
          "updated-by-user-id": null,
          "timestamp": 1711381559120,
          "selected": false,
          "data-sensitivity": null,
          "is-encrypted": null
        },
        {
          "value": "12345679",
          "source-type": "CALCULATED",
          "source-id": "source1",
          "source-label": null,
          "updated-by-user-id": null,
          "timestamp": 1711037348472,
          "selected": false,
          "data-sensitivity": null,
          "is-encrypted": null
        },
        {
          "value": "12345679;12345680",
          "source-type": "CALCULATED",
          "source-id": "source1",
          "source-label": null,
          "updated-by-user-id": null,
          "timestamp": 1711027558111,
          "selected": false,
          "data-sensitivity": null,
          "is-encrypted": null
        },
        {
          "value": "12345681",
          "source-type": "CALCULATED",
          "source-id": "source1",
          "source-label": null,
          "updated-by-user-id": null,
          "timestamp": 1710899316341,
          "selected": false,
          "data-sensitivity": null,
          "is-encrypted": null
        }
      ]
    },
    "prop2": {
      "value": "https://myurl.com/contact/",
      "versions": [
        {
          "value": "https://myurl.com/contact/",
          "source-type": "ANALYTICS",
          "source-id": "source2",
          "source-label": null,
          "updated-by-user-id": null,
          "timestamp": 1685656187542,
          "selected": false,
          "data-sensitivity": null,
          "is-encrypted": null
        },
        {
          "value": "https://myurl.com/page 2/",
          "source-type": "ANALYTICS",
          "source-id": "source2",
          "source-label": null,
          "updated-by-user-id": null,
          "timestamp": 1685656121699,
          "selected": false,
          "data-sensitivity": null,
          "is-encrypted": null
        }
      ]
    },
'...continue like this for a variable amount of properties with a variable amount of nested versions each, though all the versions sections have the same properties, then finish off with the below...
},
  "form-submissions": [
    {
      "conversion-id": "alphanumeric_string",
      "timestamp": 1685656111147,
      "form-id": "alphanumeric_string",
      "portal-id": 12345678,
      "page-url": "https://myurl.com/form page/",
      "page-title": "My Page Title",
      "title": "#gform_2 .form",
      "form-type": "CAPTURED",
      "meta-data": []
    }
  ],
  "list-memberships": [],
  "identity-profiles": [
    {
      "vid": 12345,
      "saved-at-timestamp": 1685656112544,
      "deleted-changed-timestamp": 0,
      "identities": [
        {
          "type": "EMAIL",
          "value": "[email protected]",
          "timestamp": 1685656111147,
          "is-primary": true
        },
        {
          "type": "LEAD_GUID",
          "value": "alphanumeric_string",
          "timestamp": 1685656112534
        }
      ]
    }
  ],
  "merge-audits": []
}

我认为版本历史部分足够有规律，我可以通过映射到带有字段的 SQL 表来处理它们：

ID int identity no null, 
ObjType varchar(32) no null, 
ObjID int no null,
Prop varchar(128) no null,
value varchar no null,
sourceType varchar no null,
sourceId varchar null,
sourceLabel varchar null,
updatedByUserID varchar null,
timestamp varchar no null,
selected boolean no null,
dataSensitivity varchar null,
isEncrypted boolean null

我想说的是

Dim Fields as string = ""
Dim Values as string = ""
Dim VerHistory as List(Of VerHistoryCustomClass)
For Each prop as JsonMember in JsonObject
  Fields &= prop.Name & ","
  Values &= prop.Value & ","
  If (some test for presence of version history) Then
    dim hist as new VerHistoryCustomClass(variables...)
    VerHistory.Add(hist)
  End If
End For

SQLComm.CommandText = "INSERT INTO objTable (" & Fields & ")
VALUES (" & Values & ")"
SQLcon.Open()
SQLcomm.ExecuteNonQuery()

For Each ver as VerHistoryCustomClass in VerHistory
  SQLcomm.CommandText = "INSERT INTO verTable VALUES (" & ver.toCommaDelimitedString & ")"
  SQLcomm.ExecuteNonQuery()
End For

SQLcon.Close()

或者其类似的更新版本（如果该 ID 已经存在）。

我只是真的很难从返回的 JSON 中得到可以开始分配给变量的东西。我也不知道如何处理破坏模式并具有自身嵌套结构的最后几个属性。

以下是我尝试获取 JSON 并进行处理的一些步骤：

IMPORTS RestSharp
Public Class Test_Area
    Private ReadOnly HttpClientTest As New HttpClient
    Friend ReadOnly EndptContactsAllData As String = "https://apiurl.com/endpt"
    Private Async Sub btnTestGetSpecificContact_Click(sender As Object, e As EventArgs) Handles btnTestGetSpecificContact.Click
        'Dim testclient As HttpClient = GetCrmClient() 'adds headers if not there
        'Dim email As String = "[email protected]"
        'Dim fullUri = EndptContactsAllData & "/contact/email/" & email & "/profile"
        'Dim response As HttpResponseMessage = Await testclient.GetAsync(fullUri)
        'If response.IsSuccessStatusCode Then
        '    Dim pause = True
        '    Dim raw = Await response.Content.ReadAsStringAsync()
        '    'Using jDoc As JsonDocument = JsonDocument.Parse(raw)
        '    '    Dim JRtElement As JsonElement = jDoc.RootElement
        '    '    pause = True
        '    'End Using
        'Else
        'End If
        Dim email As String = "[email protected]"
        Dim fullUri = EndptContactsAllData & "/contact/email/" & email & "/profile"
        Dim testclient As New RestClient(fullUri)
        Dim testReq As New RestRequest(Method.GET)
        testReq.AddHeaders(GetCrmClientHeaders) 'GetCrmClientHeaders returns dictionary(Of string, string) for header values
        Dim testResponse As IRestResponse = Await testclient.ExecuteAsync(testReq)
        If testResponse.IsSuccessful Then
            'handle returned JSON
        Else
            'handle error codes
        End If
    End Sub

    Public Function GetCrmClient() As HttpClient
        If HttpIsInitialized = False Then
            HttpClientTest.DefaultRequestHeaders.Add("accept", "application/json")
            HttpClientTest.DefaultRequestHeaders.Add("authorization", "Bearer " & AccessToken)
        End If
        Return HttpClientTest
    End Function

    Public Function GetCrmClientHeaders() As Dictionary(Of String, String)
        Dim hdrDict As New Dictionary(Of String, String)
        hdrDict.Add("accept", "application/json")
        hdrDict.Add("authorization", "Bearer " & AccessToken)
        Return hdrDict

    End Function
END Class

我知道这很多，我可以使用您提供的任何关于从哪里开始的建议。

编辑：添加了.Net 版本（.Net Framework 4.8.1）

我遇到了 kotlin 序列化问题，需要一些帮助：

import kotlinx.serialization.json.Json

fun main() {
    val someValue: Double = 1.0
    val someKey: String? = null    
        
    HashMap(readMapFromStorage()).also {
        it[someKey?:""] = someValue
    }.let {
        Json.encodeToString(it) // Cannot infer type for this parameter. Please specify it explicitly.
    }.let {
        runBlocking<Unit> { async { writeString("SomeCategory", it) } }
    }
}

private fun readMapFromStorage(): Map<String, Double> {
    return mapOf(
        "" to 1.0,
        "A" to 1.5, 
        "B" to 2.0,
    )
}

private fun writeString(key: String, value: String) {
    // do something clever
}

我在 IDE 中调用以下第 10 行时收到错误Json.encodeToString(it)：

无法推断此参数的类型。请明确指定。

这是为什么？ it这里HashMap<String, Double>（据我所知）应该是可序列化的。我找到的所有教程都准确演示了我尝试过的方法（据我所知）。那么为什么他的工作不成功呢？

我有来自第三方的多种 JSON 格式，需要以统一的方式进行处理。考虑到数据结构未规范化，我无法应用统一的数据处理逻辑。为了实现这一点，我在处理之前寻求将数据格式化为单一格式。

来源1：

{
  "fieldName": "status",
  "oldValue": "Open",
  "newValue": "Closed"
}

来源2：

{
  "fieldName": "status",
  "oldValue": {
    "name": "Open"
  },
  "newValue": {
    "name": "Closed"
  }
}

来源3：

{
   "fieldName": "reason",
   "oldValue": null,
   "newValue": {
      "name": "Requirements changed"
   }
}

来源4：

{
   "fieldName": "advertise",
   "oldValue": true,
   "newValue": false
}

在结果转换中我希望得到以下内容（结合所有来源）：

{
   "status"|"reason"|"advertise": {
      "oldValue": {
         "value": "Open"|null|true
      },
      "newValue": {
         "value": "Closed"|"Requirements changed"|false
      }
   }
}

我正在努力尝试各种 shift 和 default 的组合，但无法实现转换。我尝试构建 JOLT 规范来进行这种转换（见下面的示例），但我无法将不同的字段结构（简单值与对象）放入统一的格式。

[
  {
    "operation": "shift",
    "spec": {
      "fieldName": {
        "*": {
          "@(2,oldValue)": "&1.oldValue",
          "@(2,newValue)": "&1.newValue"
        }
      }
    }
  }
]

重现问题的代码示例（Java）

package org.example;

import com.bazaarvoice.jolt.Chainr;
import com.bazaarvoice.jolt.JsonUtils;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {
        var spec = read("src/main/resources/spec.json");
        var chainr = Chainr.fromSpec(JsonUtils.jsonToList(spec));

        var example1 = read("src/main/resources/example1.json");
        var example2 = read("src/main/resources/example2.json");
        var example3 = read("src/main/resources/example3.json");
        var example4 = read("src/main/resources/example4.json");

        for (String source: List.of(example1, example2, example3, example4)) {
            System.out.println("===\nSource \n" + source);
            var transformedSource = chainr.transform(JsonUtils.jsonToMap(source));

            System.out.println("\nAfter transformation \n" +
                    JsonUtils.toPrettyJsonString(transformedSource));
        }
    }

    private static String read(String path) throws IOException {
        return new String(Files.readAllBytes(Paths.get(path)));
    }
}

您还需要以下依赖项来实现数据转换

        <dependency>
            <groupId>com.bazaarvoice.jolt</groupId>
            <artifactId>jolt-core</artifactId>
            <version>0.1.8</version>
        </dependency>
        <dependency>
            <groupId>com.bazaarvoice.jolt</groupId>
            <artifactId>json-utils</artifactId>
            <version>0.1.8</version>
        </dependency>

有什么想法可以实现它吗？

提前致谢！

我正在尝试使用一行 json_query（和/或其他过滤器）在 ansible 中编辑字典，但出了点问题，我无法弄清楚。我有这个结构（带有示例数据）

seinfeld:
  - name: Jerry
    jobs:
      - comedian
    friends: 
      - name: Elaine
      - name: Kramer
  - name: George
    jobs:
      - yankees
    friends:
      - name: Jerry
      - name: Susan

我需要创建一个这样的新结构

new_list:
    - main: Jerry
      name: Elaine
    - main: Jerry
      name: Kramer
    - main: George
      name: Jerry
    - main: George
      name: Susan

将密钥name添加到friendskey 的每个元素中，并将其展平到新列表中。我已经在混合 jmespathmap和方面取得了一些进展merge，但至少有一个密钥始终为空或无效，一些随机测试是 [].merge({friends: friends},{main: name}) [*].map(&merge({main: name}, @), friends)

在 XSLT 3.0 中，我想以标准方式处理json-to-xml()由包含对象和简单值数组的 JSON 输入的调用隐式生成的 XML。 使用 XSLT 3.0 函数将 JSON 转换为 XML 和 XSLT 3.0 中的 JSON 到 XML 转换中给出的解决方案似乎很简单。但是，数组的模板没有被调用。尽管以第二种解决方案为例，其数组模板规则的匹配条件，即

<xsl:template match="array">

和

<xsl:template match="array[@key]/*">

比第一个模板规则更具体，即<xsl:template match="*[@key]">。我似乎记得 XSLT 优先规则的一般经验法则是：“更具体的规则胜过更一般的规则。”

举一个受上述解决方案启发的我自己的例子，在下面的样式表中，模板<xsl:template match="array[@key='phones']">和模板都<xsl:template match="array[@key]">没有被调用：

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="3.0"
                xmlns:fn="http://www.w3.org/2005/xpath-functions"
                exclude-result-prefixes="fn"> 

   <xsl:param name="json">
   { 
    "person":{
        "name": "John",
        "age": 30,
        "address": {
          "city": "New York",
          "zipcode": "10001"
        },
        "phones": ["123-4567", "987-6543"]
      }
   }

      <!-- A reminder of what would be produced by a call to <xsl:copy-of select="$XMLfromJSON" />:
<map xmlns="http://www.w3.org/2005/xpath-functions">
    <map key="person">
        <string key="name">John</string>
        <number key="age">30</number>
        <map key="address">
            <string key="city">New York</string>
            <string key="zipcode">10001</string>
        </map>
        <array key="phones">
            <string>123-4567</string>
            <string>987-6543</string>
        </array>
    </map>
</map>
-->
</xsl:param>
    <xsl:variable name="XMLfromJSON" select="json-to-xml($json)" />
   <xsl:output method="xml" indent="yes" omit-xml-declaration="yes"/>

   <xsl:template match="/">
        <xsl:apply-templates select="$XMLfromJSON/*"/>
   </xsl:template>

    <!-- Universal template for processing elements with an attribute "key"-->
    <xsl:template match="*[@key]">
        <xsl:element name="{@key}">
            <xsl:apply-templates/>
        </xsl:element>
    </xsl:template>

    <!-- Specific template for processing arrays named "phones" -->
    <xsl:template match="array[@key='phones']">
        <xsl:element name="{@key}">
            <xsl:for-each select="*">
                <value>
                    <xsl:value-of select="."/>
                </value>
            </xsl:for-each>
        </xsl:element>
    </xsl:template>

    <!-- Universal fallback-template for processing other arrays -->
    <xsl:template match="array[@key]">
        <xsl:element name="{@key}">
            <xsl:for-each select="*">
                <item>
                    <xsl:apply-templates/>
                </item>
            </xsl:for-each>
        </xsl:element>
    </xsl:template>
    
</xsl:stylesheet>

这仅生成以下 XML：

<person>
    <name>John</name>
    <age>30</age>
    <address>
        <city>New York</city>
        <zipcode>10001</zipcode>
    </address>
    <phones>123-4567987-6543</phones>
</person>

然而我想要的是以下 XML：

<person>
    <name>John</name>
    <age>30</age>
    <address>
        <city>New York</city>
        <zipcode>10001</zipcode>
    </address>
    <phones>
        <value>123-4567</value>
        <value>987-6543</value>
    </phones>
</person>

所以我的第一个问题是：为什么没有调用数组模板？有人能给我解释一下吗？也许参考 XSLT 3.0 优先规则的特定子规则？

我的第二个问题是：如何让这些模板自动调用？

如果这不可能，我的第三个问题是：这里最优雅的（特别是模块化的）解决方案是什么？

我想出了一个产生所需输出的解决方案，即：

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="3.0"
                xmlns:fn="http://www.w3.org/2005/xpath-functions"
                exclude-result-prefixes="fn"> 

   <xsl:param name="json">
   { 
    "person":{
        "name": "John",
        "age": 30,
        "address": {
          "city": "New York",
          "zipcode": "10001"
        },
        "phones": ["123-4567", "987-6543"]
      }
   }

      
</xsl:param>
    <xsl:variable name="XMLfromJSON" select="json-to-xml($json)" />
   <xsl:output method="xml" indent="yes" omit-xml-declaration="yes"/>

   <xsl:template match="/">
        <xsl:apply-templates select="$XMLfromJSON/*"/>
   </xsl:template>

    <xsl:template match="*[@key]" >
        <xsl:element name="{@key}">
            <xsl:choose>
                <xsl:when test="name() = 'array'">
                    <xsl:call-template name="process-array"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:apply-templates/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:element>
    </xsl:template>
    
    <!-- Named template for processing arrays -->
    <xsl:template name="process-array">
        <xsl:for-each select="*">
            <value>
                <xsl:apply-templates/>
            </value>
        </xsl:for-each>
    </xsl:template>
    
</xsl:stylesheet>

但是，我确实希望避免使用任何条件代码（如 xsl:choose 或 xsl:if 和命名模板），而是依赖 XSLT 的处理器规则。

作为可选的第四个问题，并且出于兴趣：我上面引用的第一个链接，即使用 XSLT 3.0 函数将 JSON 转换为 XML

<xsl:copy>像这样使用-element ：

<xsl:copy>
        <xsl:apply-templates select="json-to-xml(.)/*"/>
</xsl:copy>

但是，我删除了它，它还是一样。<xsl:copy>-element 也没有出现在上面第二个链接的非常相似的解决方案中。这个 -element 有什么用途吗<xsl:copy>？也许在特定情况下？还是它只是多余的？

我有一个像下面这样的枚举

#[serde(rename_all="snake_case")]
pub enum Flag {
    One,
    Two,
    Three { value: Option<Decimal>}
}

我想匹配以下 JSON 表示形式

{"flag":"one"} // Working fine
{"flag":"two"} // Working fine
{"flag":{"three":{"value":###}} // Working fine -> Three { value: Some(###) }
{"flag":"three"} // not working, desired result -> Three { value: None }

我怎样才能得到这样的行为？

我已经尝试过了：

• #[serde(default)]在变体上，但这只会匹配{"flag":{"three":{}}}
• #[serde(untagged)]在变体上，但这适用于完整枚举
• ThreeNone具有#[serde(rename="Three")]属性的另一种变体

请帮忙

我有一个 JSON 输入，我使用 JOLT 符号将其转换为另一个 JSON。我有需要保存为键值对的测量值，车站名称和车站编号合并为一个字段，日期字段需要单独保存。除了获取时间并将其转换为 GMT 之外，我已经生成了相应的输出。请查看我的输入 JSON 和预期输出 JSON 并修改我当前的 JOLT。

输入 JSON：

[
  {
    "station_id": 1919,
    "local_time_last_update": "2024-11-05 10:45:21",
    "ts": 1730796321,
    "temperature": 19.7,
    "humidity": 49,
    "pressure": 1026.87,
    "wind_average": 1.6,
    "wind_direction": 270,
    "total_rain": 0,
    "solar_radiation": 0,
    "FDI": 38,
    "fault_status": 0,
    "station_Name": "Silicon Valley "
  }
]

预期产出：

{
  "data": [
    {
      "code": "temperature",
      "value": 19.7
    },
    {
      "code": "humidity",
      "value": 49
    },
    {
      "code": "pressure",
      "value": 1026.87
    },
    {
      "code": "wind_average",
      "value": 1.6
    },
    {
      "code": "wind_direction",
      "value": 270
    },
    {
      "code": "total_rain",
      "value": 0
    },
    {
      "code": "solar_radiation",
      "value": 0
    },
    {
      "code": "FDI",
      "value": 38
    },
    {
      "code": "fault_status",
      "value": 0
    }
  ],
  "stationname": "1919_Silicon Valley",
  "Date": "2024-11-05 08:45:21"
}        

• 所有度量都保存为键值对
• 车站名称 = 车站名称 + 车站 ID
• Date” = local_time_last_update 转换为 GMT（ts 字段也可以转换为 GMT）

当前 JOLT 规格：

[
  {
    "operation": "modify-overwrite-beta",
    "spec": {
      "*": {
        "timestamp": "${ts:multiply(1000):format('yyyy-MM-dd HH:mm:ss', 'Etc/GMT-1')}"
      }
    }
  },
  {
    "operation": "remove",
    "spec": {
      "*": {
        "local_time_last_update": "",
        "ts": "",
        "station_id": ""
      }
    }
  },
  {
    "operation": "shift",
    "spec": {
      "*": {
        "timestamp": "Date",
        "*": {
          "$": "data[#2].code",
          "@": "data[#2].value"
        },
        "station_Name": "stationname"
      }
    }
  }
]

输入 ：

{
  "values": [
    {
      "reference_id": "TEST_51_ST",
      "idoc_number": "0000000113916030",
      "sto_number": "",
      "sending_location": "0000000625",
      "receiving_location": "4955",
      "idoc_status": "51",
      "create_time": "07:19:34",
      "create_date": "2023-07-20",
      "values1": [
        {
          "material_number": "A17265420",
          "status": "E",
          "message_class": "06",
          "message_num": "215",
          "message_text": "Please enter net price"
        },
        {
          "material_number": "",
          "status": "E",
          "message_class": "BAPI",
          "message_num": "001",
          "message_text": "No instance of object type PurchaseOrder has been created. External reference:"
        }
      ]
    },
    {
      "reference_id": "TEST_51_ST123",
      "idoc_number": "0000000113916030312",
      "sto_number": "",
      "sending_location": "00000006253",
      "receiving_location": "49553",
      "idoc_status": "513",
      "create_time": "07:19:34",
      "create_date": "2023-07-20",
      "values1": [
        {
          "material_number": "A172654203",
          "status": "E",
          "message_class": "06",
          "message_num": "2153",
          "message_text": "Please enter net price"
        },
        {
          "material_number": "",
          "status": "E",
          "message_class": "BAPI",
          "message_num": "0031",
          "message_text": "No instance of object type PurchaseOrder has been created. External reference:"
        }
      ]
    }
  ]
}

预期输出：

[
  {
    "reference_id": "TEST_51_ST",
    "idoc_number": "0000000113916030",
    "sto_number": "",
    "sending_location": "0000000625",
    "receiving_location": "4955",
    "idoc_status": "51",
    "create_time": "07:19:34",
    "create_date": "2023-07-20",
    "material_number": "A17265420",
    "status": "E",
    "message_class": "06",
    "message_num": "215",
    "message_text": "Please enter net price"
  },
  {
    "reference_id": "TEST_51_ST",
    "idoc_number": "0000000113916030",
    "sto_number": "",
    "sending_location": "0000000625",
    "receiving_location": "4955",
    "idoc_status": "51",
    "create_time": "07:19:34",
    "create_date": "2023-07-20",
    "material_number": "",
    "status": "E",
    "message_class": "BAPI",
    "message_num": "001",
    "message_text": "No instance of object type PurchaseOrder has been created. External reference:"
  },
  {
    "reference_id": "TEST_51_ST123",
    "idoc_number": "0000000113916030312",
    "sto_number": "",
    "sending_location": "00000006253",
    "receiving_location": "49553",
    "idoc_status": "513",
    "create_time": "07:19:34",
    "create_date": "2023-07-20",
    "material_number": "A172654203",
    "status": "E",
    "message_class": "06",
    "message_num": "2153",
    "message_text": "Please enter net price"
  },
  {
    "reference_id": "TEST_51_ST123",
    "idoc_number": "0000000113916030312",
    "sto_number": "",
    "sending_location": "00000006253",
    "receiving_location": "49553",
    "idoc_status": "513",
    "create_time": "07:19:34",
    "create_date": "2023-07-20",
    "material_number": "",
    "status": "E",
    "message_class": "BAPI",
    "message_num": "0031",
    "message_text": "No instance of object type PurchaseOrder has been created. External reference:"
  }
]

需要一个 jolt 规范来解决这个问题，尝试了这个 jolt，但它只对一个数组元素起作用

[
  {
    "operation": "shift",
    "spec": {
      "values": {
        "*": {
          "values1": {
            "*": {
              // Extract fields from the main object along with each `values1` item
              "@(2,reference_id)": "[&1].reference_id",
              "@(2,idoc_number)": "[&1].idoc_number",
              "@(2,sto_number)": "[&1].sto_number",
              "@(2,sending_location)": "[&1].sending_location",
              "@(2,receiving_location)": "[&1].receiving_location",
              "@(2,idoc_status)": "[&1].idoc_status",
              "@(2,create_time)": "[&1].create_time",
              "@(2,create_date)": "[&1].create_date",
              // Map each field within `values1`
              "material_number": "[&1].material_number",
              "status": "[&1].status",
              "message_class": "[&1].message_class",
              "message_num": "[&1].message_num",
              "message_text": "[&1].message_text"
            }
          }
        }
      }
    }
  }
]

但无法正常工作。它适用于这种有效负载直接父引用(@(3, ...))：values1 之外的每个父字段（如 reference_id、idoc_number 等）在第 3 级（相对于 values1）访问，确保每个 values1 项都生成具有唯一父值集的对象。唯一的扁平化条目([&2])：values1 数组元素分别被扁平化为不同的对象，因此输出 JSON 对于每个 values1 元素都有独立的条目，而无需将字段分组到数组中。预期输出这应该为每个 values1 条目生成一个包含 reference_id、idoc_number、material_number 等字段的不同对象列表，而无需将值组合成数组。如果这提供了所需的格式，请告诉我

假设我有这个 json：

[
  {
    "first": 12355,
    "second": "abc"
  },
  {
    "first": 89010,
    "second": "def"
  },
  {
    "first": 23423,
    "second": "hij"
  },
  {
    "first": 23456,
    "second": "klm"
  },
  {
    "first": 11111,
    "second": "nop"
  }
]

我希望（一种通用形式）将它们合并为 1 个对象，其中每个键的值合并到相应值的数组中：

{
    "first" : [12355,89010,23423,23456,11111],
    "second" : ["abc","def","hij","klm","nop"]
}

我正在尝试这个，但它根本没有产生任何输出。

reduce .[] as $final (
    {};
    ((. | keys) as $k |
        map(
            ( (.[$k] // []) += ($final[$k] // []))
        )
    )
)