递归Flow结构转FlowGroup映射失败问题排查

我有一个递归JSON结构，包含可互相引用的Flow与SubFlow，想要把它们存储为带键的Map集合（FlowGroup）。确认TypeScript版本支持Map，且已有成功使用Map的案例，核心问题出在处理算法上，当前执行后返回的FlowGroup为空。

类型定义 #

type Flow = {
   flowId: number,
   subFlows?: Array<SubFlow>
} 

type SubFlow = {
  subFlowId: number,
  flow?: Flow,
}

type FlowGroup = {
    flows: Map<number,Flow>,
    subFlows: Map<number,Flow>
}

最终目标与示例JSON #

需要将所有Flow以flowId为键存入FlowGroup的flows Map，SubFlow以subFlowId为键存入subFlows Map。示例结构如下：

{
  "flowId": 90112,
  "subFlows": [
    {
      "subFlowId": 52820,
      "flow": {
        "flowId": 80032,
        "subFlows": [
          { 
            "subFlowId": 76422
          }, 
          {
            "subFlowId": 12654
          }
        ]
      }
    },
    {
      "subFlowId": 12422
    }
  ]
}

当前实现代码（执行后返回空FlowGroup） #

const mainFlow:Flow = { 
  flowId: 90112,
  subFlows: _subFlows
}

function processFlow(flow: Flow) {
  if (flow && flow.subFlows === undefined) {
     flowGroup.flows.set(flow.flowId, flow);
  } else if (flow && Array.isArray(flow.subFlows)) {
     for (const subFlow of flow.subFlows) {
         flowGroup.subFlows.set(subFlow.subFlowId, subFlow);
         if (subFlow.flow) {
             processFlow(subFlow.flow);
         }
     }
 }
}

processFlow(mainFlow);
console.log(`FlowGroup is ${JSON.stringify(flowGroup)}`);

测试数据代码 #

const subFlow1:SubFlow ={
 subFlowId: 52820
}

const subFlow2:SubFlow ={
 subFlowId: 12422
}

const flow3:SubFlow = {
 subFlowId: 76422
}

const flow4: SubFlow = {
 subFlowId: 12654
}

const flow5: Flow = {
 flowId: 80032,
  subFlows: [flow3, flow4]
}

subFlow1.flow = flow5;  

const flowGroup: FlowGroup = {
     flows: new Map<number, Flow>(),
     subFlows: new Map<number, Flow>()
   }

const _subFlows = [subFlow1, subFlow2];

const mainFlow:Flow ={
 flowId: 90112,
 subFlows: _subFlows
}

手动测试Map有效性 #

const m = new Map<string, Flow>();
m.set(flow5.flowId, flow5);

for(const [k, v] of m.entries()){
  console.log(` Map key = ${k} and value = 
         ${JSON.stringify(v)}`);
}

TypeScript编译配置（支持Map） #

"target": "esNext",
"module": "es2022",
"moduleResolution": "node",

已有成功使用Map的案例 #

productHandler<Product, ProductKey
    extends keyof Product>(product: Product, productKey: ProductKey) {
    const map = new Map<ProductKey, Array<string>>();
    const productData = product[productKey] as unknown as Array<string>;
    map.set(productKey, productData)
    return map;
}

问题分析与修复方案 #

问题1：Flow存入逻辑错误 #

当前processFlow函数仅在flow.subFlows === undefined时才将Flow存入flows Map，但主流程mainFlow和嵌套的flow5都包含subFlows数组，导致这些Flow根本不会被存入。

问题2：FlowGroup类型定义错误 #

FlowGroup中的subFlows被定义为Map<number, Flow>，但实际要存储的是SubFlow类型，类型不匹配会导致潜在问题。

修复后的代码 #

修正类型定义

type FlowGroup = {
    flows: Map<number, Flow>,
    subFlows: Map<number, SubFlow> // 修正为SubFlow类型
}

修正处理函数逻辑

function processFlow(flow: Flow) {
    // 优先存入当前Flow，无论是否有subFlows
    if (flow) {
        flowGroup.flows.set(flow.flowId, flow);
        
        // 遍历处理所有子流程
        if (Array.isArray(flow.subFlows)) {
            for (const subFlow of flow.subFlows) {
                flowGroup.subFlows.set(subFlow.subFlowId, subFlow);
                // 递归处理子流程关联的Flow
                if (subFlow.flow) {
                    processFlow(subFlow.flow);
                }
            }
        }
    }
}

补充：Map序列化问题 #

JSON.stringify无法直接序列化Map对象，打印时需要转换为数组：

// 打印flows Map
console.log("FlowGroup flows:", JSON.stringify(Array.from(flowGroup.flows.entries())));
// 打印subFlows Map
console.log("FlowGroup subFlows:", JSON.stringify(Array.from(flowGroup.subFlows.entries())));

修复后执行，flows Map会包含90112和80032两个Flow，subFlows Map会包含52820、12422、76422、12654四个SubFlow。

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