Цикл над сложными объектами JSON - нужна логика для получения суммы значений

Question

Я потребляю ниже JSON из JENKINS API в приложении Angular. Я пытаюсь получить сумму значений ключа n из приведенного ниже JSON. Мне нужна логика для реализации в машинописи.

проблема здесь, структура JSON постоянно меняется. Как мне написать логику для расчета суммы значений ключа "n"

Ниже приведены примеры структуры JSON:

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

сумма = 18 (3 + 6 + 9)

Пример: 2

    {
   "J": [
          {

             "J" : [
                    {

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

сумма = 9

Answer 1

Вот рекурсивное решение 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 

Answer 2

Нет необходимости в причудливой логике, достаточно простой рекурсии 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));