将带嵌套维度值的JavaScript对象转换为一维数组的递归实现

需求说明 #

将嵌套结构的partition数据转换为一维数组，数组每个元素需包含：

• dimensions：存储当前节点到根节点的维度关联链
• values：存储当前节点对应的numbers数据

原始数据模型 #

const partition = {
    "values": [
      {
        "dimensionValue": 'A',
        "numbers": [0, 33],
        "partition": {
          "values": [
            {
              "dimensionValue": '1',
              "numbers": [0, 3375],
              "partition": {
                "values": [
                  {
                    "dimensionValue": 'a',
                    "numbers": [0, 0],
                    "partition": null
                  },
                  {
                    "dimensionValue": 'b',
                    "numbers": [0, 8],
                    "partition": null
                  }
                ]
              }
            },
            {
              "dimensionValue": '2',
              "numbers": [6028, 0],
              "partition": {
                "values": [
                  {
                    "dimensionValue": 'a',
                    "numbers": [0, 6028],
                    "partition": null
                  }
                ]
              }
            }
          ]
        }
      },
      {
        "dimensionValue": 'B',
        "numbers": [0, 31721.57],
        "partition": {
          "values": [
            {
              "dimensionValue": '1',
              "numbers": [0, 0],
              "partition": {
                "values": [
                  {
                    "dimensionValue": 'a',
                    "numbers": [0, 31721.57],
                    "partition": null
                  }
                ]
              }
            }
          ]
        }
      }
    ]
  }

预期输出 #

[
  {
    "dimensions": ["A"],
    "values": [0, 33]
  },
  {
    "dimensions": ["A", "1"],
    "values": [0, 3375]
  },
  {
    "dimensions": ["A", "1", "a"],
    "values": [0, 0]
  },
  {
    "dimensions": ["A", "1", "b"],
    "values": [0, 8]
  },
  {
    "dimensions": ["A", "2"],
    "values": [6028, 0]
  },
  {
    "dimensions": ["A", "2", "a"],
    "values": [0, 6028]
  },
  {
    "dimensions": ["B"],
    "values": [0, 31721.57]
  },
  {
    "dimensions": ["B", "1"],
    "values": [0, 0]
  },
  {
    "dimensions": ["B", "1", "a"],
    "values": [0, 31721.57]
  }
]

现有半可行代码 #

const partition = {
    "values": [
      {
        "dimensionValue": 'A',
        "numbers": [0, 33],
        "partition": {
          "values": [
            {
              "dimensionValue": '1',
              "numbers": [0, 3375],
              "partition": {
                "values": [
                  {
                    "dimensionValue": 'a',
                    "numbers": [0, 0],
                    "partition": null
                  },
                  {
                    "dimensionValue": 'b',
                    "numbers": [0, 8],
                    "partition": null
                  }
                ]
              }
            },
            {
              "dimensionValue": '2',
              "numbers": [6028, 0],
              "partition": {
                "values": [
                  {
                    "dimensionValue": 'a',
                    "numbers": [0, 6028],
                    "partition": null
                  }
                ]
              }
            }
          ]
        }
      },
      {
        "dimensionValue": 'B',
        "numbers": [0, 31721.57],
        "partition": {
          "values": [
            {
              "dimensionValue": '1',
              "numbers": [0, 0],
              "partition": {
                "values": [
                  {
                    "dimensionValue": 'a',
                    "numbers": [0, 31721.57],
                    "partition": null
                  }
                ]
              }
            }
          ]
        }
      }
    ]
  }

const extractDimensionValues = (
  partitionValues
) => {
 return (
    partitionValues.flatMap(({ dimensionValue, numbers, partition }) => {
      const mainValues = {
          "dimensions": [dimensionValue],
          "values": [...numbers],
        }
      const nestedValues = partition.values.flatMap((value) => {
        return ({
          "dimensions": [dimensionValue, value.dimensionValue],
          "values": [...value.numbers]
        }) 
      })
      
      return !partition.values ? [mainValues] : [mainValues, ...nestedValues]
    })
 )
}

const data = [...extractDimensionValues(partition.values)]
console.log('data :', data)

递归实现方案 #

核心逻辑是通过递归函数跟踪当前维度链：

1. 定义递归函数，接收当前节点列表和已有的维度链（默认空数组）
2. 遍历每个节点，生成当前节点的结果对象（维度链拼接当前节点的dimensionValue，values取当前节点的numbers）
3. 若当前节点存在子partition且包含values，递归处理子节点并传递更新后的维度链
4. 用flatMap将所有层级的结果扁平化合并为一维数组

完整递归代码 #

const partition = {
    "values": [
      {
        "dimensionValue": 'A',
        "numbers": [0, 33],
        "partition": {
          "values": [
            {
              "dimensionValue": '1',
              "numbers": [0, 3375],
              "partition": {
                "values": [
                  {
                    "dimensionValue": 'a',
                    "numbers": [0, 0],
                    "partition": null
                  },
                  {
                    "dimensionValue": 'b',
                    "numbers": [0, 8],
                    "partition": null
                  }
                ]
              }
            },
            {
              "dimensionValue": '2',
              "numbers": [6028, 0],
              "partition": {
                "values": [
                  {
                    "dimensionValue": 'a',
                    "numbers": [0, 6028],
                    "partition": null
                  }
                ]
              }
            }
          ]
        }
      },
      {
        "dimensionValue": 'B',
        "numbers": [0, 31721.57],
        "partition": {
          "values": [
            {
              "dimensionValue": '1',
              "numbers": [0, 0],
              "partition": {
                "values": [
                  {
                    "dimensionValue": 'a',
                    "numbers": [0, 31721.57],
                    "partition": null
                  }
                ]
              }
            }
          ]
        }
      }
    ]
  };

const flattenPartition = (values, parentDimensions = []) => {
  return values.flatMap(node => {
    // 生成当前节点的结果
    const currentItem = {
      dimensions: [...parentDimensions, node.dimensionValue],
      values: [...node.numbers]
    };
    // 处理子节点：若存在有效子分区则递归
    const children = node.partition?.values 
      ? flattenPartition(node.partition.values, [...parentDimensions, node.dimensionValue]) 
      : [];
    // 返回当前节点+子节点的结果集合
    return [currentItem, ...children];
  });
};

const result = flattenPartition(partition.values);
console.log(result);

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