Итерация массива внутри объекта и добавление свойства соответственно

Question

Итак, у меня проблема с рекурсией, вот данные:

let data = {
    label: "Root",
    datasets: [
        {
            label: "Parent 1"
            datasets: [
                {
                    label: "Child 1",
                    dataMax: 100,
                    datasets: 30
                },
                {
                    label: "Child 2",
                    dataMax: 30,
                    datasets: 30
                }
            ]
        },
        {
            label: "Parent 2",
            dataMax: 50,
            datasets: 30
        }
    ]
};

Что я хотел сделать , так это перебрать это и добавить свойство, скажем dataMax и данные о каждом родителе, у которого нет dataMax, и если у родителя есть два или более дочерних элемента, у dataMax будут общие значения его потомков.

Обратите внимание, data глубина и длина * случайны.

Вот что я пробовал:

let data = {
    label: "Root",
    datasets: [
        {
            label: "Parent 1",
            datasets: [
                {
                    label: "Child 1",
                    dataMax: 100,
                    datasets: 30
                },
                {
                    label: "Child 2",
                    dataMax: 30,
                    datasets: 30
                }
            ]
        },
        {
            label: "Parent 2",
            dataMax: 50,
            datasets: 30
        }
    ]
};

let setDatas = function(x, i, p){
    if (x == undefined) {
        console.log("--- This is x==undefined ---");
        return 1;
    } else if (Array.isArray(x.datasets)) {
        console.log("-------------- " + x.label + ", datasets[" + [i] + "]:");
        console.log(x.datasets[i]);
        return setDatas(x.datasets[i], i, x);
    } else {
        console.log("It's not an Array");
        ++i;
        return setDatas(p, i, p);
    }
}

setDatas(data, 0);

Мне удалось добраться до глубины, но я не могу вернуться к Корню, и я чувствовал, что что-то упустил, но просто не могу показатьсянайти его.Что я сделал не так?

Желаемый вывод:

let data = {
    label: "Root",
    dataMax: 180, // Total from dataMax of Parent 1 and 2
    datasets: [
        {
            label: "Parent 1",
            dataMax: 130, // Total from dataMax of "Child 1" and dataMax of "Child 2"
            datasets: [
                {
                    label: "Child 1",
                    dataMax: 100,
                    datasets: 30
                },
                {
                    label: "Child 2",
                    dataMax: 30,
                    datasets: 30
                }
            ]
        },
        {
            label: "Parent 2",
            dataMax: 50,
            datasets: 30
        }
    ]
};

Заранее спасибо.Не стесняйтесь спрашивать дополнительную информацию.

Answer 1

Вы можете использовать .reduce метод, который также сохраняет исходные данные

    const datasets = [
            {
                label: "Parent 1",
                datasets: [
                    {
                        label: "Child 1",
                        dataMax: 100,
                        datasets: 30
                    },
                    {
                        label: "Child 2",
                        dataMax: 30,
                        datasets: 30
                    }
                ]
            },
            {
                label: "Parent 2",
                dataMax: 50,
                datasets: 30
            }
        ]; 
    
    
    const redfinedDataset = datasets.reduce( (prev, curr) => {
      if(curr.dataMax) { return prev.concat([curr]);}  
      else {
           if(curr.datasets.length >0) {
            const dataMax = curr.datasets.reduce( (pds, cds) => pds += cds.dataMax, 0);
            const nds = Object.assign(curr, {dataMax});
            return prev.concat([nds]);
           }
         }
    }, []);
    
    console.log(redfinedDataset);

Answer 2

В вашей реальной функции вы не перебираете data.datasets, вы просто проверяете заданное data, вам нужно циклически перебирать вложенные data.datasets.

. Вы можете использовать комбинациюиз Array#map() и Array#reduce() такие методы:

function getDataMax(data) {
  if (data.datasets && Array.isArray(data.datasets)) {
    data.datasets = data.datasets.map(x => {
      if (!x.dataMax) {
        if (Array.isArray(x.datasets)) {
          //If inner datasets is an array do the recursive call
          getDataMax(x);
        }
      }
      return x;
    });
  }
  if (!data.dataMax)
    data.dataMax = data.datasets.map(x => x.dataMax).reduce((a, b) => (a + b));
}

Демонстрация:

let data = {
  label: "Root",
  datasets: [{
      label: "Parent 1",
      datasets: [{
          label: "Child 1",
          dataMax: 100,
          datasets: 30
        },
        {
          label: "Child 2",
          dataMax: 30,
          datasets: 30
        }
      ]
    },
    {
      label: "Parent 2",
      dataMax: 50,
      datasets: 30
    }
  ]
};


function getDataMax(data) {
  if (data.datasets && Array.isArray(data.datasets)) {
    data.datasets = data.datasets.map(x => {
      if (!x.dataMax) {
        if (Array.isArray(x.datasets)) {
          getDataMax(x);
        }
      }
      return x;
    });
  }
  if (!data.dataMax)
    data.dataMax = data.datasets.map(x => x.dataMax).reduce((a, b) => (a + b));
}
getDataMax(data);
console.log(data)

Answer 3

Проверьте, работает ли это:

data = {
    label: "Root",
    datasets: [{
        label: "Parent 1",
        datasets: [{
            label: "Child 1",
            dataMax: 100,
            datasets: 30
        }, {
            label: "Child 2",
            dataMax: 30,
            datasets: 30
        }]
    }, {
        label: "Parent 2",
        dataMax: 50,
        datasets: 30
    }]
}

function setData(data) {
    if (Array.isArray(data.datasets)) {
        let childMax = 0;

        for (let i = 0; i < data.datasets.length; i++) {
            childMax += setData(data.datasets[i]);
        }

        if (data.dataMax === undefined) {
            data.dataMax = childMax;
        }
    }

    return data.dataMax;
}

setData(data);