Merging by array value (and doing calculations with the other keys) - php

Question

I'm having a difficult time finding a viable solution for this problem:
This is the array I have, and I want to group this array by product_name and count the quantity. But array structure needs to remain the same.
Array(
[0] => Array
(
[product_quantity] => 1
[product_name] => Appel
)
[1] => Array
(
[product_quantity] => 1
[product_name] => D-Day
)
[2] => Array
(
[product_quantity] => 4
[product_name] => D-Day
)
[3] => Array
(
[product_quantity] => 2
[product_name] => D-Day
)
[4] => Array
(
[product_quantity] => 1
[product_name] => Emiel
)
[5] => Array
(
[product_quantity] => 9
[product_name] => Emiel
)
[6] => Array
(
[product_quantity] => 3
[product_name] => Estella
)
[7] => Array
(
[product_quantity] => 4
[product_name] => Feeke
)
[8] => Array
(
[product_quantity] => 1
[product_name] => Feeke
)
[9] => Array
(
[product_quantity] => 7
[product_name] => Reset
)
[10] => Array
(
[product_quantity] => 1
[product_name] => Reset
))
What I need as output:
Array(
[0] => Array
(
[product_quantity] => 1
[product_name] => Appel
)
[1] => Array
(
[product_quantity] => 7
[product_name] => D-Day
)
[2] => Array
(
[product_quantity] => 10
[product_name] => Emiel
)
[3] => Array
(
[product_quantity] => 3
[product_name] => Estella
)
[4] => Array
(
[product_quantity] => 5
[product_name] => Feeke
)
[5] => Array
(
[product_quantity] => 8
[product_name] => Reset
)
)
I would love to hear some advice, or solutions on how to tackle this!

Answer 1

The goal can be reached in many ways. If you aim for speed then use a foreach to iterate over the input array, incrementally computing and storing the values into a new array (the body of the callback function below).
If you aim to impress your workmates or a recruiter with your knowledge of PHP then use array_reduce():
$output = array_values( // We don't need the keys of the generated array
array_reduce( // Incrementally process $input using a callback
$input,
// $carry is the partial result
// $item is the currently processed item
function(array $carry, array $item) {
// Extract the product name into a local variable
// we'll use it several times below
$name = $item['product_name'];
// If it's a new product then initialize its entry in the output
if (! array_key_exists($name, $carry)) {
$carry[$name] = array(
'product_quantity' => 0,
'product_name' => $name,
);
}
// Update the quantity of this group
$carry[$name]['product_quantity'] += $item['product_quantity'];
// Return the partial result
return $carry;
},
// Start with an empty array
array()
)
);
Update
The OP asked in a comment how to reuse the callback function and make it customizable ("how do I use a parameter to make 'product_name' dynamicaly?").
You can put the value ('product_name') into a variable ($key) outside the function and use the use language construct to let the anonymous function inherit it.
$key = 'product_name'; // The values needs to be in a variable
$output = array_values(
array_reduce(
$input,
// The 'use' keyword lets the anonymous function use a copy of $key
function(array $carry, array $item) use ($key) {
$name = $item[$key];
// The rest of the callback's code comes here unchanged
// ...
// Return the partial result
return $carry;
},
array()
)
);
See Example #3 on the documentation of anonymous functions for more examples.
You can store the callback function into a variable. This doesn't improve anything but the readability of the code. However, keep reading, this is just an intermediate step, the real magic happens below.
$key = 'abc';
$f = function(array $carry, array $item) use ($key) {
$name = $item[$key];
// The rest of the callback's code comes here unchanged
// ...
// Return the partial result
return $carry;
};
$output = array_values(array_reduce($input, $f, array()));
To make it really reusable you need to have a way to generate callbacks for different values of $key. Let's write a simple function that creates parametrized callbacks:
// This function creates a new callback that uses the value of argument $key
function makeFn($key)
{
return function(array $carry, array $item) use ($key) {
$name = $item[$key];
// The rest of the callback's code comes here unchanged
// ...
// Return the partial result
return $carry;
};
}
Now, let's use the new function. It creates different callback functions that can be used to reduce the array by using various keys:
$output1 = array_values(array_reduce($input, makeFn('product_name'), array()));
$output2 = array_values(array_reduce($input, makeFn('product_code'), array()));

Answer 2

I do not test it, but I think that it can solve your problem.
$stocks = [];
foreach ($products as $product) {
if (isset($stocks[$product['product_name']])) {
$stocks[$product['product_name']] += $product['product_quantity'];
} else {
$stocks[$product['product_name']] = $product['product_quantity'];
}
}
$finalList = [];
foreach ($stocks as $key => $stock) {
$finalList[] = [
'product_quantity' => $stock,
'product_name' => $key
];
}
print_r($finalList);