Question

我当然已经尝试搜索一个特定的例子，或者一个使我接近答案的例子。我正在尝试获取对象的多深度数组的总和。

我的数据结构如下：

[
    {
        "values":[
            {
                "values":[
                    {
                        "value":{
                            "value":"51214.35"
                        },
                    }
                ],
            }
        ],
    },
    {
        "values":[
            {
                "values":[
                    {
                        "value":{
                            "value":"10632.00"
                        },
                    },
                    {
                        "value":{
                            "value":"15000.00"
                        },
                    }
                ],
            }
        ],
    }
]

我想让它们成为每个对象的一个属性，该对象具有所有更深层次的值属性的总和。

例如：

[
        {
            "total":"51214.35",
            "values":[
                {
                    "total":"51214.35",
                    "values":[
                        {
                            "total":"51214.35",
                            "value":{
                                "value":"51214.35"
                            },
                        }
                    ],
                }
            ],
        },
        {
            "total":"25632.00",
            "values":[
                {
                    "total" : "25632.00",
                    "values":[
                        {
                            "total": "10632.00",
                            "value":{
                                "value":"10632.00"
                            },
                        },
                        {
                            "total": "15000.00",
                            "value":{
                                "value":"15000.00"
                            },
                        }
                    ],
                }
            ],
        }
    ]

我知道，由于深度未知，递归很可能会起作用。

Answer 1

您可以创建一个接受对象的函数，如果该对象具有value属性，则将其设置为totals属性。如果不是总和，则对数组values中的每个项目调用同一函数的总和。

您需要小心加总和，因为您使用的是字符串而不是数字作为值，但是否则，这是非常简单的递归。

let arr = [{"values":[{"values":[{"value":{"value":"51214.35"},}],}],},{"values":[{"values":[{"value":{"value":"10632.00"},},{"value":{"value":"15000.00"},}],}],}]

function setTotals(obj){
    obj.totals = obj.hasOwnProperty('value')
        ? parseFloat(obj.value.value)
        : obj.values.reduce((sum, item) => sum + setTotals(item), 0)
    return obj.totals
}
arr.forEach(item => setTotals(item))
console.log(arr)

Answer 2

const values = [
    {
        "values":[
            {
                "values":[
                    {
                        "value":{
                            "value":"51214.35"
                        },
                    }
                ],
            }
        ],
    },
    {
        "values":[
            {
                "values":[
                    {
                        "value":{
                            "value":"10632.00"
                        },
                    },
                    {
                        "value":{
                            "value":"15000.00"
                        },
                    }
                ],
            }
        ],
    }
];


const total = values => values.reduce((t, i) => {
  const currentTotal = i.value ? t + parseFloat(i.value.value) : i.values ? t + total(i.values) : t;
  i.total = currentTotal;
  return currentTotal;
}, 0);

total(values);

console.log(values);

Answer 3

尝试一下：

function calcTotal(data) {
    if (Array.isArray(data)) data.map(calcTotal)
    let total = 0
    if (data.hasOwnProperty('values')) total = data.values.map(calcTotal).reduce((acc, v) => acc + v.total, 0)
    else if (data.hasOwnProperty('value')) total = parseFloat(data.value.value)
    return Object.assign(data, { total })
}(data)

编辑：：好像有人比我快：-）

具有深度的阵列的总和

3 个答案: