Javascript 使用递归从嵌套对象检索值

我有一个JS对象

数据

，从这个对象数组中，我需要取“amount”值，它在“limitBreakup”数组中。我已经使用了

.map（）

，但是我很想知道使用递归实现相同的功能

var data = [
   {
      "limitRequirementId":"123",
      "facilityType":"cc",
      "amount":800000,
      "existingRoi":12,
      "existingPf":12100,
      "repoRate":5,
      "spread":10,
      "tenure":24,
      "margin":10000,
      "loanVariable":{
         "type":"roi/commission",
         "value":15
      },
      "limitBreakup":[
         {
            "limitRequirementId":"13",
            "facilityType":"cc",
            "repoRate":5,
            "amount":8000,
            "spread":10,
            "tenure":24,
            "margin":100,
            "loanVariable":{
               "type":"roi/commission",
               "value":15
            }
         },
         {
            "limitRequirementId":"22",
            "facilityType":"LC",
            "repoRate":4,
            "amount":900,
            "spread":6,
            "tenure":21,
            "margin":15,
            "loanVariable":{
               "type":"roi/commission",
               "value":10
            }
         }
      ]
   },
   {
      "limitRequirementUniqueId":"13",
      "limitRequirementId":"13",
      "facilityType":"lc",
      "amount":900000,
      "existingRoi":10,
      "existingPf":1000,
      "repoRate":3,
      "spread":1,
      "tenure":21,
      "margin":1000,
      "loanVariable":{
         "type":"roi/commission",
         "value":15
      },
      "limitBreakup":[
         {
            "limitRequirementId":"35",
            "facilityType":"CC",
            "repoRate":6,
            "amount":600,
            "spread":8,
            "tenure":28,
            "margin":13,
            "loanVariable":{
               "type":"roi/commission",
               "value":14
            }
         }
      ]
   }
]

我使用普通迭代的解决方案有效：

data.forEach((d, i)=>{
    let limitBreakup = d.limitBreakup;
   if(Array.isArray(limitBreakup)){
limitBreakup.forEach((l)=>{  console.log(l, '->', l.amount)  })
    }else{
        console.log(limitBreakup, 'else->', limitBreakup.amount) 
  }
   //console.log(d.limitBreakup);

})

但是使用递归，我已经做了一半：

---

（由于json对象非常大，我粘贴了mocky.io以供参考）

类似的东西应该可以工作

演示证明：

您需要一个循环来通过对象，然后在满足条件时将它们添加到数组中

var数据=[{
“limitRequirementId”：“123”，
“设施类型”：“cc”，
“金额”：800000，
“现有投资回报率”：12，
“现有PF”：12100，
“回购”：5，
“蔓延”：10，
“任期”：24，
“保证金”：10000，
“贷款可变”：{
“类型”：“投资回报率/佣金”，
“价值”：15
},
“分手”：[{
“limitRequirementId”：“13”，
“设施类型”：“cc”，
“回购”：5，
“金额”：8000，
“蔓延”：10，
“任期”：24，
“保证金”：100，
“贷款可变”：{
“类型”：“投资回报率/佣金”，
“价值”：15
}
},
{
“limitRequirementId”：“22”，
“设施类型”：“LC”，
“回购”：4，
“金额”：900，
“蔓延”：6，
“任期”：21，
“保证金”：15，
“贷款可变”：{
“类型”：“投资回报率/佣金”，
“价值”：10
}
}
]
},
{
“limitRequirementUniqueId”：“13”，
“limitRequirementId”：“13”，
“设施类型”：“lc”，
“金额”：900000，
“现有投资回报率”：10，
“现有PF”：1000，
“回购”：3，
“蔓延”：1，
“任期”：21，
“保证金”：1000，
“贷款可变”：{
“类型”：“投资回报率/佣金”，
“价值”：15
},
“分手”：[{
“limitRequirementId”：“35”，
“设施类型”：“CC”，
“回购”：6，
“金额”：600，
“蔓延”：8，
“任期”：28，
“保证金”：13，
“贷款可变”：{
“类型”：“投资回报率/佣金”，
“价值”：14
}
}]
}
]
var数组=[]；
函数递归计数器（arr）{
for（设i=0；ilog（数组）

类似的东西应该可以工作

演示证明：

您需要一个循环来通过对象，然后在满足条件时将它们添加到数组中

var数据=[{
“limitRequirementId”：“123”，
“设施类型”：“cc”，
“金额”：800000，
“现有投资回报率”：12，
“现有PF”：12100，
“回购”：5，
“蔓延”：10，
“任期”：24，
“保证金”：10000，
“贷款可变”：{
“类型”：“投资回报率/佣金”，
“价值”：15
},
“分手”：[{
“limitRequirementId”：“13”，
“设施类型”：“cc”，
“回购”：5，
“金额”：8000，
“蔓延”：10，
“任期”：24，
“保证金”：100，
“贷款可变”：{
“类型”：“投资回报率/佣金”，
“价值”：15
}
},
{
“limitRequirementId”：“22”，
“设施类型”：“LC”，
“回购”：4，
“金额”：900，
“蔓延”：6，
“任期”：21，
“保证金”：15，
“贷款可变”：{
“类型”：“投资回报率/佣金”，
“价值”：10
}
}
]
},
{
“limitRequirementUniqueId”：“13”，
“limitRequirementId”：“13”，
“设施类型”：“lc”，
“金额”：900000，
“现有投资回报率”：10，
“现有PF”：1000，
“回购”：3，
“蔓延”：1，
“任期”：21，
“保证金”：1000，
“贷款可变”：{
“类型”：“投资回报率/佣金”，
“价值”：15
},
“分手”：[{
“limitRequirementId”：“35”，
“设施类型”：“CC”，
“回购”：6，
“金额”：600，
“蔓延”：8，
“任期”：28，
“保证金”：13，
“贷款可变”：{
“类型”：“投资回报率/佣金”，
“价值”：14
}
}]
}
]
var数组=[]；
函数递归计数器（arr）{
for（设i=0；iconsole.log（array）

我不清楚您想要实现什么。你的数据真的是递归的吗？也就是说，在其他

limitBreakup

节点中是否有

limitBreakup

节点在其他

limitBreakup

节点中，等等？如果不是，递归可能没有什么意义我不知道这个评论是否是对我的回应。但该数据（已在问题中提供）仅显示一个嵌套级别。这不是递归结构，可能不会合理地使用递归算法<代码>地图应该可以。但是，如果它们可以嵌套任意深（甚至比显示的要深得多），那么递归地编写它可能是值得的。您希望从提供的输入中得到什么样的输出？请注意，类似于

data.map（{amount，limitBreakup}）=>（{amount，breakupAmounts:limitBreakup.map（b=>b.amount）}））

的内容将返回类似于

[{amount:800000，breakupAmounts:[8000，900]}，{amount 900000，breakupAmounts:[600]}]的结果。重新配置输出相对容易。但是如果数据实际上是递归的，我们需要做更多的工作。我不清楚你想要实现什么。你的数据真的是递归的吗？也就是说，在其他
limitBreakup
节点中是否有
limitBreakup
节点在其他
limitBreakup
节点中，等等？如果不是，递归可能会导致litt