嵌入路径的困难递归会导致最终状态。

Question

我有一个决策路径树，它的节点遵循特定的模式，即决策->、原因、->、决策、->、结果、->终端。每个决定都有一个decisionId。每条路径都以终端状态结束。目标是收集所有决策，并将其聚合到DecisionResult对象中的DecisionResult映射中。每个决策对象都以根开始。以下是这些类型的结构：

        export interface Root {
          rootId: string
          decision: Decision
        }
    
        export interface Option {
          optionName: string
          decision: Decision
        }
    
        export interface Decision {
          decisionId: string
          outcome?: Outcome
          options?: Option[]
       }
    
        export interface Outcome {
         terminal: Reason
        }
    
        export interface Reason {
         decision: Decision
        }

        export type DecisionResult = {
          rootId: string
          rootDecision:  Map<string, Decision>,
          decisions: Map<string, Decision>,
        }

下面是表示数据的JSON结构。我不知道如何开始导航这个结构。我从得到钥匙开始，但不知道如何遍历树并将它们添加到地图中

   {
    "rootId": "decision-tree",
    "decision": {
    "decisionId": "rootOption",
    "options": [
     {
      "optionName": "LynsTheory",
      "decision": {
      "decisionId": "lynsOption",
      "outcome": {
        "terminal": "exit"
        }
      }
     },
     {
      "optionName": "Tensor",
       "decision": {
       "decisionId": "tensorOption",
       "outcome": {
        "reason": {
          "decision": {
            "decisionId": "terminalOption",
            "outcome": {
              "reason": {
                "terminal": "exit"
              }
            }
           }
          }
        }
      }
    },
    {
       "optionName": "Talend",
       "decision": {
       "decisionId": "optionals",
       "options": [
        {
          "optionName": "Bayes",
          "decision": {
            "decisionId": "talend",
            "options": [
              {
                "optionName": "cumulative",
                "decision": {
                  "decisionId": "cumulativeI",
                  "options": [
                    {
                      "optionName": "plus",
                      "decision": {
                        "decisionId": "plusT",
                        "outcome": {
                          "reason": {
                            "decision": {
                              "decisionId": "relational",
                              "outcome": {
                                "reason": "exit"
                              }
                            }
                          }
                        }
                      }
                    }
                  ]
                }
              }
            ]
          }
        }
      ]
    }
  }
]

}}

生成的结构应该如下所示:键在外部，每个子决策都在其父中使用子键：

  {
   "rootId": "decision-tree",  
   "rootOption":{
   "root": {
    "decision": {
        "decisionId": "root",
        "outcome": {
          "terminal": "exit"
          }
        }
     }
  },
   "lynsOptions":{
    "decision": 
      {
     "decisionId": "lynsOptions",
     "optionName": "LynsTheory",
     "decisions": {
         "optionName": "LynsTheory",
         "Bayes": {
            "decision":{   
                "outcome":{
                    "terminal": "exit",
                    "reason": "Complete"        
                }                    
              }
         },
         "tensorOption":{
            "optionName": "TensorFlow",
            "decision":{   
                "outcome":{
                    "terminal": "exit",
                    "reason": "Complete"                       
                }                    
              } 
         },
         "variableOption":{
            "decision":{   
                "outcome":{
                    "terminal": "exit",
                    "reason": "Complete"                       
                }                    
              } 
         }
        }              
    }
  }     
}

Answer 1

我的头很痛，只是想弄明白你在找什么！

我看到你的问题有几个问题需要解决，然后才能给出一个合理的答案。

首先，DecisionResult的预期输出类型甚至与您提供的作为预期输出的json不匹配。见TS游乐场。结果的类型错误是..。

Type '{ rootId: string; rootOption: { root: { decision: { decisionId: string; outcome: { terminal: string; }; }; }; }; lynsOptions: { decision: { decisionId: string; optionName: string; decisions: { optionName: string; Bayes: { ...; }; tensorOption: { ...; }; variableOption: { ...; }; }; }; }; }' is not assignable to type 'DecisionResult'.
  Object literal may only specify known properties, and '"rootOption"' does not exist in type 'DecisionResult'.

这几乎就像您希望将decisionId作为键添加到最终输出的根上，但是根决策有一个与其他类型不同的类型，使得类型更加混乱。就像..。

type DecisionResultTest =  & {
  rootId: string;
} & Record<string, Decision>;

还请注意类型记录Record和Map类型在DecisionResult类型和预期输出之间的不一致性。我猜这只是为了将预期的输出显示为JSON。

其次，您的预期类型键和值与您提供的输入不一致，即：

• 'lynsOption'和'lynsOptions'的不同键
• reason作为'Complete'的隐含值
• 似乎是从'tensor'到'tensorOption'等的某种类型的键内插
• 'variableOption'密钥不知从哪里冒出来

第三，您的预期输出有一个不明显的选项层次结构。不知何故，lynsOption的兄弟姐妹现在在输出中是lynsOptions的子级。

第四，任意调整作为'exit'的根结果。似乎您只是提供了每个嵌套决策的结果，但是如果最终的子结果不同会发生什么。

如果您真的想要一个答案，请忘记类型，只需提供一个精确的输入和预期输出。连同所有假设的列表，如插入的键值、隐含的值等，足以让某人理解你的期望。当前的输入/输出示例没有意义！