0

我有一个数组，其结构类似于下面的结构。哪里有等级制度

[2] => Array
        (
            [sumW] => 200.39
            [child] => Array
                (
                    [3] => Array
                        (
                            [sumW] => 300.00
                        )
                    [4] => Array
                        (
                            [sumW] => 100.28
                            [child] => Array
                                (
                                    [5] => Array
                                        (
                                            [sumW] => 600
                                        )

                                    [6] => Array
                                        (
                                            [sumW] => 150
                                        )

                                 )
                         )

                    [7] => Array
                        (
                            [sumW] => 30.00
                            [child] => Array
                                (
                                    [8] => Array
                                        (
                                            [sumW] => 100.00
                                        )

                                 )
                         )

                 )
        )

```

我不知道如何在数组的每个级别对每个数组求和。这样每个级别都有它自己和它下面的级别的总和。

所以，例如，像

[2]   = [tot] => 1480.67
 [3]  = [tot] => 300.00
 [4]  = [tot] => 850.28
  [5] = [tot] => 600.00
  [6] = [tot] => 150.00
 [7]  = [tot] => 130.00
  [8] = [tot] => 100.00

等等。

该数组可以是无限深的层次，这只显示 3 个层次，但我的层次结构可以扩展超过 3 个层次。

我试过弄乱数组总和并在数组中设置父/子 ID。我能做的最好的就是获得 2->3,4,7 的值。但我无法让 [2] 包含 [5] 和 [6] 及以后的值。

编辑：

这是我尝试过的一种方法。我的原始数据中有 parent_ids 和 category_ids。这让我的总和在每个级别都深了 1 级。但并没有总结层次结构中的所有内容。

$tot=[];
$getSum = function ($array, $pid = null) use (&$getSum, &$tot) {
             $rpt = new Report;
             foreach ($array as $item) {
         // This returns my database value for this category.
                 $sum = $rpt->getCategoryTotal($item->category_id);

                 if($item->parent_id == $pid) {

                     if(!isset($tot[$item->category_id])){
                         $tot[$item->category_id] = $sum;
                     }   

                     if(isset($tot[$item->parent_id])){
                         $tot[$item->parent_id] += $sum;
                     }   

                     $child = $getSum($item->children, $item->category_id);
                 }
             }           
             return $sum;
         };

$result = $getSum($myDbData);
return dd($tot);
4

2 回答 2

0

我找到了一个似乎对我有用的解决方案。尚未对其进行彻底测试，但到目前为止似乎可以正常工作。

     function setTotals($category) {
         $category['totalW'] = $category['sumW'];
         if (isset($category['child']) && is_array($category['child'])) {
             $sub = [];
             $i = 0;
             foreach ($category['child'] as $cat) {
                 $sub[] = setTotals($cat);
                 $category['totalW'] += $sub[$i]['totalW'];
                 $i++;
             }
             $category['child'] = $sub;
         }
         return $category;
     }   
     setTotals($myArray);

这适用于问题中发布的数组结构，并为每个级别添加一个“总”行，以及该级别的总和，包括级别。

希望这对其他人有帮助。

信用：我在这里找到了这个帮助我完成这项工作。 键盘

于 2017-05-08T23:28:17.870 回答
0

我想到了这样的递归函数：

public function recursiveSum(array $source)
{
    $children = $source['child'] ?? [];

    $sum = $source['sumW'] ?? 0;

    foreach($children as $index => $child)
    {
        $source['child'][$index] = $this->recursiveSum($child);
        $sum += $source['child'][$index]['total'];
    }

    $source['total'] = $sum;
    return $source;
}

如果您需要上层的结果，则需要“child”键。

这是我为测试而制作的数据的实现：

$datas = [
    'child' => [
        2 => [
            'sumW' => 200.39,
            'child' => [
                3 => [
                    'sumW' => 300,
                ],
                4 => [
                    'sumW' => 100.28,
                    'child' => [
                        5 => [
                            'sumW' => 600,
                        ],
                        6 => [
                            'sumW' => 150,
                        ],
                    ]
                ],
                7 => [
                    'sumW' => 30,
                    'child' => [
                        5 => [
                            'sumW' => 100,
                        ],
                    ],
                ],
            ],
        ],
    ]
];

和输出：

array:2 [▼
    "child" => array:1 [▼
        2 => array:3 [▼
            "sumW" => 200.39
            "child" => array:3 [▼
                3 => array:2 [▼
                    "sumW" => 300
                    "total" => 300
                ]
                4 => array:3 [▼
                    "sumW" => 100.28
                    "child" => array:2 [▼
                        5 => array:2 [▼
                            "sumW" => 600
                            "total" => 600
                        ]
                        6 => array:2 [▼
                            "sumW" => 150
                            "total" => 150
                        ]
                    ]
                    "total" => 850.28
                ]
                7 => array:3 [▼
                    "sumW" => 30
                    "child" => array:1 [▼
                        5 => array:2 [▼
                            "sumW" => 100
                            "total" => 100
                        ]
                    ]
                    "total" => 130
                ]
            ]
            "total" => 1480.67
        ]
    ]
    "total" => 1480.67
]
于 2017-05-10T13:02:04.173 回答