循環復雜的JSON對象 - 需要邏輯來獲取值的總和

Question

我在Angular應用程序中從JENKINS API消耗JSON以下。 我試圖從下面的JSON中獲取關鍵n的值的總和。 我需要一個邏輯來在打字稿中實現。

問題出在這里，JSON結構不斷變化。 如何編寫邏輯來計算鍵“ n ”的值的總和

以下是JSON結構的示例：

{
   "J": [
          {
             "n" : 3,
             "J" : [
                    {
                      "n": 6
                      "J": [
                             {
                             "n": 9
                              }
                           ]
                     }
                   ]
          }
        ]
}

sum = 18（3 + 6 + 9）

例如：2

    {
   "J": [
          {

             "J" : [
                    {

                      "J": [
                             {
                                 "J": [
                                        {
                                           "J": [
                                                  {
                                                    "n": 9
                                                  }
                                                ]
                                        }
                                      ]
                              }
                           ]
                     }
                   ]
          }
        ]
}

sum = 9

Answer 1

不需要花哨的邏輯， Array.reduce()的簡單遞歸就足夠了：

var sumOfN = function(o) {  
  return (o['J'] || []).reduce((m,x) => { 
    return m + sumOfN(x); 
  }, (o['n'] || 0));
};

示例＃1：

 var data = { "J": [ { "n" : 3, "J" : [ { "n": 6, "J": [ { "n": 9 } ] } ] } ] }; var sumOfN = function(o) { return (o['J'] || []).reduce((m,x) => { return m + sumOfN(x); }, (o['n'] || 0)); }; console.log('result = ' + sumOfN(data)); 

示例＃2：

 var data = { "J": [{ "J": [{ "J": [{ "J": [{ "J": [{ "n": 9 }] }] }] }] }] }; var sumOfN = function(o) { return (o['J'] || []).reduce((m,x) => { return m + sumOfN(x); }, (o['n'] || 0)); }; console.log('result = ' + sumOfN(data)); 

---

更新

例＃3

 var data = { "J": [{ "J": [ { "J": [{ "J": [{ "J": [{ "n": 9 }] }] }] }, { "J": [{ "n": 9 }, { "n": 9 } ] } ] }] }; var sumOfN = function(o) { return (o['J'] || []).reduce((m,x) => { return m + sumOfN(x); }, (o['n'] || 0)); }; console.log('result = ' + sumOfN(data)); 

Answer 2

這是一個遞歸的TypeScript解決方案：

type J = {
    n?: number,
    J?: J[]
}

function sum(j: J, acc = 0) {
    if (j.J != null) {
        for (let subJ of j.J) {
            acc = sum(subJ, acc);
        }
    }
    return acc + (j.n ? j.n : 0);
}


console.log(sum({
    "J": [
        {
            "n": 3,
            "J": [
                {
                    "n": 6,
                    "J": [
                        {
                            "n": 9
                        }
                    ]
                }
            ]
        }
    ]
})); // 18

console.log(sum({
    "J": [
        {

            "J": [
                {

                    "J": [
                        {
                            "J": [
                                {
                                    "J": [
                                        {
                                            "n": 9
                                        }
                                    ]
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    ]
})); // 9