如何从多层嵌套JSON的最深层级提取code与message并拼接？

问题描述 #

我有结构多变的JSON错误数据，以下是三个示例：

示例1 #

{
  "error" : {
    "code" : "validation_failed",
    "message" : "Validation failed",
    "fields" : {
      "banners" : {
        "code" : "bad_items",
        "message" : "Bad items in list",
        "items" : [ {
          "code" : "active_banners_limit",
          "message" : "Limit of active banners exceeded"
        } ]
      }
    }
  }
}

示例2 #

{
  "error" : {
    "code" : "validation_failed",
    "message" : "Validation failed",
    "fields" : {
      "date_end" : {
        "code" : "min_value",
        "message" : "Value is less than minimum allowed"
      }
    }
  }
}

示例3 #

{
    "error": {
        "code": "validation_failed",
        "message": "Validation failed",
        "fields": {
            "targetings": {
                "fields": {
                    "geo": {
                        "fields": {
                            "regions": {
                                "unallowed_values": [
                                    100000000
                                ],
                                "code": "unallowed_value",
                                "message": "Unallowed value"
                            }
                        }
                    }
                }
            }
        }
    }
}

需求：从error.fields路径下找到最深层级的节点，提取其中的code和message并用|拼接成指定格式的输出。由于JSON层级不确定，但目标信息始终在最深层级，预期输出分别为：

[
  {
    "errorMessage": "active_banners_limit|Limit of active banners exceeded"
  }
]

[
  {
    "errorMessage": "min_value|Value is less than minimum allowed"
  }
]

[
  {
    "errorMessage": "unallowed_value|Unallowed value"
  }
]

已知固定层级时提取无难度，但现在层级未知，请问该需求是否可实现？

解决方案 #

完全可以实现，核心思路是通过递归遍历或迭代遍历的方式，逐层深入JSON结构，直到找到不存在子层级（即没有fields或items属性）且包含code和message的节点。

以下是JavaScript的实现示例：

function extractDeepestError(errorData) {
    let result = [];
    
    // 递归遍历函数
    function traverse(node) {
        // 判断当前节点是否是最深层级：有code和message，且没有fields/items子节点
        const hasCodeMsg = node.code && node.message;
        const hasChildren = node.fields || node.items;
        
        if (hasCodeMsg && !hasChildren) {
            result.push({
                errorMessage: `${node.code}|${node.message}`
            });
            return;
        }
        
        // 处理fields层级
        if (node.fields) {
            Object.values(node.fields).forEach(child => traverse(child));
        }
        
        // 处理items数组
        if (node.items) {
            node.items.forEach(child => traverse(child));
        }
    }
    
    // 从error.fields开始遍历
    if (errorData.error?.fields) {
        Object.values(errorData.error.fields).forEach(field => traverse(field));
    }
    
    return result;
}

// 测试示例1
const example1 = { /* 示例1的JSON数据 */ };
console.log(extractDeepestError(example1));

// 测试示例2
const example2 = { /* 示例2的JSON数据 */ };
console.log(extractDeepestError(example2));

// 测试示例3
const example3 = { /* 示例3的JSON数据 */ };
console.log(extractDeepestError(example3));

实现说明 #

1. 遍历逻辑：优先检查当前节点是否符合最深层级的条件（有code和message，且没有fields或items子节点），符合则直接提取信息。
2. 层级处理：如果当前节点有fields（对象）或items（数组），则递归遍历这些子节点，直到找到最深层级。
3. 兼容性：覆盖了示例中出现的两种子层级类型（fields嵌套对象、items数组），如果后续有其他子层级类型，只需在遍历逻辑中添加对应判断即可。

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