Pivot an indexed array of associative arrays - php

Question

I want to convert this:
$arr = [
[
'type' => 'fruit',
'name' => 'apple',
'cost' => 1
],
[
'type' => 'fruit',
'name' => 'orange',
'cost' => 2
],
[
'type' => 'vegetable',
'name' => 'carrot',
'cost' => 2.5
],
[
'type' => 'vegetable',
'name' => 'avocado',
'cost' => 3.5
]
];
Into this:
$arr = [
[
'type' => 'fruit',
'apple' => '1',
'orange' => 2
],
[
'type' => 'vegetable',
'carrot' => 2.5,
'avocado' => 3.5
]
];
As you can see, I'm needing to group each type in a single array and pivoting fruit name and cost.

Answer 1

Here's a method for obtaining that exact array structure in the output. This was a touch trickier than I thought it would be:
//first build groups by type
$groups = array();
foreach($arr as $key => $array){
//$type is not necessary, it's just for clarity below
$type = $array['type'];
if( !isset($groups[$type]) ){
$groups[$type] = array();
$groups[$type]['type'] = $array['type'];
}
$groups[$type][$array['name']] = $array['cost'];
}
//then combine the groups into a master array
$out = array();
foreach($groups as $g){
$out[] = $g;
}
echo '<pre>'. print_r($out, true).'</pre>';

Answer 2

For something like this simply looping through your array as Rizier suggests should do the trick. If you're grouping by type, it would probably be easiest to use the type as the array key, so the format would be slightly different than you've requested. You'd be able access your resulting array like this:
$fruitItems = $newArr['fruit'];
Here's sample code:
$size = count($itemArray);
$newArr = []; //The array you want to create
for ($i = 0; $i < $size; $i++)
{
$item = $itemArray[$i];
$type = $item['type'];
$name = $item['name'];
$cost = $item['cost']
//If your new array doesn't have this type yet, make a sub-array
//with the type as key
if (!isset($newArr[$type]))
$newArr[$type] = [];
$newArr[$type][$name] = $cost; //In your type sub-array, add the new item
}
If you absolutely have to create an array with that structure, you can tweak the above code a little bit to search through your array and find the sub-array with the correct type. However, that seems a little over complicated.

Answer 3

In case someone needs a little more generic approch and has to handle multiple values in the same column I enlarged #larsAnders solution a bit.
Usage (to get the exact required output):
$pivot_fruits = arr_pivot($arr, 'type', 'name', 'cost', 'sum', false, false);
Function:
function arr_pivot(
$arr,
$arr_key_to_pivot_for_rows,
$arr_key_to_pivot_for_columns,
$arr_key_to_pivot_for_values,
$grouping_method = "sum",
$add_missing_columns=true,
$sort_columns=true){
if(!is_array($arr)) return false;
$pivot_row = $arr_key_to_pivot_for_rows;
$pivot_col = $arr_key_to_pivot_for_columns;
$pivot_val = $arr_key_to_pivot_for_values;
//first build groups by $col_name_to_pivot_for_rows
$row_groups = [];
$columns=[];
foreach ($arr as $row_key => $row) {
$group_label = $row[$pivot_row];
$col_label = $row[$pivot_col];
$value = $row[$pivot_val];
if( !isset($row_groups[$group_label]) ){
$row_groups[$group_label]=[];
$row_groups[$group_label][$pivot_row] = $group_label;
}
if(!isset($columns[$col_label])) $columns[$col_label]=[];
$row_groups[$group_label][$col_label][]=$value;
}
//then combine the groups into a return array
$arr_pivoted = [];
foreach($row_groups as $row_group){
//all columns except of the first one are pivoted columns. split into the row name and the columns itself
$row_group_columns = $row_group;
$row_group_row = array_shift($row_group_columns);
//ensure that all groups have all columns
if($add_missing_columns) $row_group_columns = array_merge($columns,$row_group_columns);
if($sort_columns) ksort($row_group_columns);
$row_group_columns_grouped=[];
//apply grouping function to columns
foreach ($row_group_columns as $column_name => $row_group_column){
$acount=count($row_group_column);
switch ($grouping_method){
default:
case 'sum':
$row_group_columns_grouped[$column_name] = array_sum($row_group_column);
break;
case 'avg':
$row_group_columns_grouped[$column_name] = $acount == 0 ? 0 : array_sum($row_group_column) / count($row_group_column);
break;
case 'count':
$row_group_columns_grouped[$column_name] = count($row_group_column);
break;
case 'max':
$row_group_columns_grouped[$column_name] = $acount == 0 ? 0 : max($row_group_column);
break;
case 'min':
$row_group_columns_grouped[$column_name] = $acount == 0 ? 0 : min($row_group_column);
break;
case 'concat':
case 'implode':
$row_group_columns_grouped[$column_name] = implode(',',$row_group_column);
break;
}
}
$arr_pivoted[] = array_merge([$pivot_row=>$row_group_row],$row_group_columns_grouped);
}
return $arr_pivoted;
}
PHPDoc:
/**
* Turns 2 dimensional array in a pivoted version
*
* #param array $arr 2 dimensional to pivot
* #param string $arr_key_to_pivot_for_rows input array key to use as rows
* #param string $arr_key_to_pivot_for_columns input array key to use as columns
* #param string $arr_key_to_pivot_for_values input array key to use as values
* #param string $grouping_method method to use on values out of sum|count|avg|min|max|concat. If values are not numeric use count or concat
* #param bool $add_missing_columns if true all occurring columns in any row are added if missing
* #param bool $sort_columns if true all columns will be sorted by column name (=key)
* #return array|bool false if input is not an array otherwise the pivoted result as 2 dimensional array
*/
If someone feels the urge to improve coding style, input validation and/or variable naming I would be very glad.

Answer 4

This task is as simple as grouping related data using temporary first level keys.
$array = [
['type' => 'fruit', 'name' => 'apple', 'cost' => 1],
['type' => 'fruit', 'name' => 'orange', 'cost' => 2],
['type' => 'vegetable', 'name' => 'carrot', 'cost' => 2.5],
['type' => 'vegetable', 'name' => 'avocado', 'cost' => 3.5]
];
$result = [];
foreach ($array as $row) {
$result[$row['type']]['type'] = $row['type'];
$result[$row['type']][$row['name']] = $row['cost'];
}
var_export(array_values($result));
Contrary to what is demonstrated by other answers on this page, parent elements do not need to be instantiated/declared before assigning a child element. (The same cannot be said for when assigning child properties in an object.) There is also no need for conditions or multiple loops for this basic task.
Output:
array (
0 =>
array (
'type' => 'fruit',
'apple' => 1,
'orange' => 2,
),
1 =>
array (
'type' => 'vegetable',
'carrot' => 2.5,
'avocado' => 3.5,
),
)
You can also abuse a body-less foreach() loop's destructuring syntax to perform the pivot. (Demo)
$array = [
['type' => 'fruit', 'name' => 'apple', 'cost' => 1],
['type' => 'fruit', 'name' => 'orange', 'cost' => 2],
['type' => 'vegetable', 'name' => 'carrot', 'cost' => 2.5],
['type' => 'vegetable', 'name' => 'avocado', 'cost' => 3.5]
];
$result = [];
foreach ($array as ['type' => $type, 'type' => $result[$type]['type'], 'name' => $name, 'cost' => $result[$type][$name]]);
var_export(array_values($result));
This provides the same result as above. Notice how the type key is written twice while destructuring -- it looks invalid, but it actually works.